/**

 * File: WebP IO

 *

 * Read and write WebP images.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif /* HAVE_CONFIG_H */

#ifdef HAVE_LIBWEBP

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <stdlib.h>

#include "gd.h"

#include "gd_errors.h"

#include "gdhelpers.h"

#include "webp/decode.h"

#include "webp/encode.h"

#define GD_WEBP_ALLOC_STEP (4*1024)

/*

  Function: gdImageCreateFromWebp

    <gdImageCreateFromWebp> is called to load truecolor images from

    WebP format files. Invoke <gdImageCreateFromWebp> with an

    already opened pointer to a file containing the desired

    image. <gdImageCreateFromWebp> returns a <gdImagePtr> to the new

    truecolor image, or NULL if unable to load the image (most often

    because the file is corrupt or does not contain a WebP

    image). <gdImageCreateFromWebp> 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>.

    *The returned image is always a truecolor image.*

  Variants:

    <gdImageCreateFromJpegPtr> creates an image from WebP data

    already in memory.

    <gdImageCreateFromJpegCtx> reads its data via the function

    pointers in a <gdIOCtx> structure.

  Parameters:

    infile - The input FILE pointer.

  Returns:

    A pointer to the new *truecolor* image.  This will need to be

    destroyed with <gdImageDestroy> once it is no longer needed.

    On error, returns NULL.

*/

BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp (FILE * inFile)

{

	gdImagePtr im;

	gdIOCtx *in = gdNewFileCtx(inFile);

	if (!in) {

		return 0;

	}

	im = gdImageCreateFromWebpCtx(in);

	in->gd_free(in);

	return im;

}

/*

  Function: gdImageCreateFromWebpPtr

    See <gdImageCreateFromWebp>.

  Parameters:

    size            - size of WebP data in bytes.

    data            - pointer to WebP data.

*/

BGD_DECLARE(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;

}

/*

  Function: gdImageCreateFromWebpCtx

    See <gdImageCreateFromWebp>.

*/

BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile)

{

	int    width, height;

	uint8_t   *filedata = NULL;

	uint8_t    *argb = NULL;

	unsigned char   *read, *temp;

	size_t size = 0, n;

	gdImagePtr im;

	int x, y;

	uint8_t *p;

	do {

		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(temp);

		return NULL;

	}

	im = gdImageCreateTrueColor(width, height);

	if (!im) {

		gdFree(temp);

		return NULL;

	}

	argb = WebPDecodeARGB(filedata, size, &width, &height);

	if (!argb) {

		gd_error("gd-webp cannot allocate temporary buffer");

		gdFree(temp);

		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);

		}

	}

	/* do not use gdFree here, in case gdFree/alloc is mapped to something else than libc */

	free(argb);

	gdFree(temp);

	im->saveAlphaFlag = 1;

	return im;

}

/* returns 0 on success, 1 on failure */

static int _gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quality)

{

	uint8_t *argb;

	int x, y;

	uint8_t *p;

	uint8_t *out;

	size_t out_size;

    int ret = 0;

	if (im == NULL) {

		return 1;

	}

	if (!gdImageTrueColor(im)) {

		gd_error("Palette image not supported by webp");

		return 1;

	}

	if (quality == -1) {

		quality = 80;

	}

	if (overflow2(gdImageSX(im), 4)) {

		return 1;

	}

	if (overflow2(gdImageSX(im) * 4, gdImageSY(im))) {

		return 1;

	}

	argb = (uint8_t *)gdMalloc(gdImageSX(im) * 4 * gdImageSY(im));

	if (!argb) {

		return 1;

	}

	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;

		}

	}

	out_size = WebPEncodeRGBA(argb, gdImageSX(im), gdImageSY(im), gdImageSX(im) * 4, quality, &out;;

	if (out_size == 0) {

		gd_error("gd-webp encoding failed");

        ret = 1;

		goto freeargb;

	}

	gdPutBuf(out, out_size, outfile);

	free(out);

freeargb:

	gdFree(argb);

    return ret;

}

/*

  Function: gdImageWebpCtx

    Write the image as WebP data via a <gdIOCtx>. See <gdImageWebpEx>

    for more details.

  Parameters:

    im      - The image to write.

    outfile - The output sink.

    quality - Image quality.

  Returns:

    Nothing.

*/

BGD_DECLARE(void) gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quality)

{

	_gdImageWebpCtx(im, outfile, quality);

}

/*

  Function: gdImageWebpEx

    <gdImageWebpEx> outputs the specified image to the specified file in

    WebP format. The file must be open for writing. Under MSDOS and

    all versions of Windows, it is important to use "wb" as opposed to

    simply "w" as the mode when opening the file, and under Unix there

    is no penalty for doing so. <gdImageWebpEx> does not close the file;

    your code must do so.

	If _quality_ is -1, a reasonable quality value (which should yield a

	good general quality / size tradeoff for most situations) is used. Otherwise

	_quality_ should be a value in the range 0-100, higher quality values

	usually implying both higher quality and larger image sizes.

  Variants:

    <gdImageWebpCtx> stores the image using a <gdIOCtx> struct.

    <gdImageWebpPtrEx> stores the image to RAM.

  Parameters:

    im      - The image to save.

    outFile - The FILE pointer to write to.

    quality - Compression quality (0-100).

  Returns:

    Nothing.

*/

BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quality)

{

	gdIOCtx *out = gdNewFileCtx(outFile);

	if (out == NULL) {

		return;

	}

	_gdImageWebpCtx(im, out, quality);

	out->gd_free(out);

}

/*

  Function: gdImageWebp

    Variant of <gdImageWebpEx> which uses the default quality (-1).

  Parameters:

    im      - The image to save

    outFile - The FILE pointer to write to.

  Returns:

    Nothing.

*/

BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile)

{

	gdIOCtx *out = gdNewFileCtx(outFile);

	if (out == NULL) {

		return;

	}

	_gdImageWebpCtx(im, out, -1);

	out->gd_free(out);

}

/*

  Function: gdImageWebpPtr

    See <gdImageWebpEx>.

*/

BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size)

{

	void *rv;

	gdIOCtx *out = gdNewDynamicCtx(2048, NULL);

	if (out == NULL) {

		return NULL;

	}

	if (_gdImageWebpCtx(im, out, -1)) {

		rv = NULL;

	} else {

		rv = gdDPExtractData(out, size);

	}

	out->gd_free(out);

	return rv;

}

/*

  Function: gdImageWebpPtrEx

    See <gdImageWebpEx>.

*/

BGD_DECLARE(void *) gdImageWebpPtrEx (gdImagePtr im, int *size, int quality)

{

	void *rv;

	gdIOCtx *out = gdNewDynamicCtx(2048, NULL);

	if (out == NULL) {

		return NULL;

	}

	if (_gdImageWebpCtx(im, out, quality)) {

        rv = NULL;

    } else {

        rv = gdDPExtractData(out, size);

    }

	out->gd_free(out);

	return rv;

}

#endif /* HAVE_LIBWEBP */