#endif /* HAVE_CONFIG_H */
#include "allheaders.h"
/* --------------------------------------------*/
#if HAVE_LIBWEBP /* defined in environ.h */
/* --------------------------------------------*/
#include "webp/decode.h"
#include "webp/encode.h"
/*---------------------------------------------------------------------*
* Reading WebP *
*---------------------------------------------------------------------*/
/*!
* \brief pixReadStreamWebP()
*
* \param[in] fp file stream corresponding to WebP image
* \return pix 32 bpp, or NULL on error
*/
PIX *
pixReadStreamWebP(FILE *fp)
{
l_uint8 *filedata;
size_t filesize;
PIX *pix;
PROCNAME("pixReadStreamWebP");
if (!fp)
return (PIX *)ERROR_PTR("fp not defined", procName, NULL);
/* Read data from file and decode into Y,U,V arrays */
rewind(fp);
if ((filedata = l_binaryReadStream(fp, &filesize)) == NULL)
return (PIX *)ERROR_PTR("filedata not read", procName, NULL);
pix = pixReadMemWebP(filedata, filesize);
LEPT_FREE(filedata);
return pix;
}
/*!
* \brief pixReadMemWebP()
*
* \param[in] filedata webp compressed data in memory
* \param[in] filesize number of bytes in data
* \return pix 32 bpp, or NULL on error
*
*
* Notes:
* (1) When the encoded data only has 3 channels (no alpha),
* WebPDecodeRGBAInto() generates a raster of 32-bit pixels, with
* the alpha channel set to opaque (255).
* (2) We don't need to use the gnu runtime functions like fmemopen()
* for redirecting data from a stream to memory, because
* the webp library has been written with memory-to-memory
* functions at the lowest level (which is good!). And, in
* any event, fmemopen() doesn't work with l_binaryReadStream().
*
*/
PIX *
pixReadMemWebP(const l_uint8 *filedata,
size_t filesize)
{
l_uint8 *out = NULL;
l_int32 w, h, has_alpha, wpl, stride;
l_uint32 *data;
size_t size;
PIX *pix;
WebPBitstreamFeatures features;
PROCNAME("pixReadMemWebP");
if (!filedata)
return (PIX *)ERROR_PTR("filedata not defined", procName, NULL);
if (WebPGetFeatures(filedata, filesize, &features))
return (PIX *)ERROR_PTR("Invalid WebP file", procName, NULL);
w = features.width;
h = features.height;
has_alpha = features.has_alpha;
/* Write from compressed Y,U,V arrays to pix raster data */
pix = pixCreate(w, h, 32);
pixSetInputFormat(pix, IFF_WEBP);
if (has_alpha) pixSetSpp(pix, 4);
data = pixGetData(pix);
wpl = pixGetWpl(pix);
stride = wpl * 4;
size = (size_t)stride * h;
out = WebPDecodeRGBAInto(filedata, filesize, (uint8_t *)data, size,
stride);
if (out == NULL) { /* error: out should also point to data */
pixDestroy(&pix);
return (PIX *)ERROR_PTR("WebP decode failed", procName, NULL);
}
/* The WebP API expects data in RGBA order. The pix stores
* in host-dependent order with R as the MSB and A as the LSB.
* On little-endian machines, the bytes in the word must
* be swapped; e.g., R goes from byte 0 (LSB) to byte 3 (MSB).
* No swapping is necessary for big-endians. */
pixEndianByteSwap(pix);
return pix;
}
/*!
* \brief readHeaderWebP()
*
* \param[in] filename
* \param[out] pw width
* \param[out] ph height
* \param[out] pspp spp (3 or 4)
* \return 0 if OK, 1 on error
*/
l_ok
readHeaderWebP(const char *filename,
l_int32 *pw,
l_int32 *ph,
l_int32 *pspp)
{
l_uint8 data[100]; /* expect size info within the first 50 bytes or so */
l_int32 nbytes, bytesread;
size_t filesize;
FILE *fp;
PROCNAME("readHeaderWebP");
if (!pw || !ph || !pspp)
return ERROR_INT("input ptr(s) not defined", procName, 1);
*pw = *ph = *pspp = 0;
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
/* Read no more than 100 bytes from the file */
if ((filesize = nbytesInFile(filename)) == 0)
return ERROR_INT("no file size found", procName, 1);
if (filesize < 100)
L_WARNING("very small webp file\n", procName);
nbytes = L_MIN(filesize, 100);
if ((fp = fopenReadStream(filename)) == NULL)
return ERROR_INT("image file not found", procName, 1);
bytesread = fread(data, 1, nbytes, fp);
fclose(fp);
if (bytesread != nbytes)
return ERROR_INT("failed to read requested data", procName, 1);
return readHeaderMemWebP(data, nbytes, pw, ph, pspp);
}
/*!
* \brief readHeaderMemWebP()
*
* \param[in] data
* \param[in] size 100 bytes is sufficient
* \param[out] pw width
* \param[out] ph height
* \param[out] pspp spp (3 or 4)
* \return 0 if OK, 1 on error
*/
l_ok
readHeaderMemWebP(const l_uint8 *data,
size_t size,
l_int32 *pw,
l_int32 *ph,
l_int32 *pspp)
{
WebPBitstreamFeatures features;
PROCNAME("readHeaderWebP");
if (pw) *pw = 0;
if (ph) *ph = 0;
if (pspp) *pspp = 0;
if (!data)
return ERROR_INT("data not defined", procName, 1);
if (!pw || !ph || !pspp)
return ERROR_INT("input ptr(s) not defined", procName, 1);
if (WebPGetFeatures(data, (l_int32)size, &features))
return ERROR_INT("invalid WebP file", procName, 1);
*pw = features.width;
*ph = features.height;
*pspp = (features.has_alpha) ? 4 : 3;
return 0;
}
/*---------------------------------------------------------------------*
* Writing WebP *
*---------------------------------------------------------------------*/
/*!
* \brief pixWriteWebP()
*
* \param[in] filename
* \param[in] pixs
* \param[in] quality 0 - 100; default ~80
* \param[in] lossless use 1 for lossless; 0 for lossy
* \return 0 if OK, 1 on error
*
*
* Notes:
* (1) Special top-level function allowing specification of quality.
*
*/
l_ok
pixWriteWebP(const char *filename,
PIX *pixs,
l_int32 quality,
l_int32 lossless)
{
l_int32 ret;
FILE *fp;
PROCNAME("pixWriteWebP");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if ((fp = fopenWriteStream(filename, "wb+")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
ret = pixWriteStreamWebP(fp, pixs, quality, lossless);
fclose(fp);
if (ret)
return ERROR_INT("pixs not compressed to stream", procName, 1);
return 0;
}
/*!
* \brief pixWriteStreampWebP()
*
* \param[in] fp file stream
* \param[in] pixs all depths
* \param[in] quality 0 - 100; default ~80
* \param[in] lossless use 1 for lossless; 0 for lossy
* \return 0 if OK, 1 on error
*
*
* Notes:
* (1) See pixWriteMemWebP() for details.
* (2) Use 'free', and not leptonica's 'LEPT_FREE', for all heap data
* that is returned from the WebP library.
*
*/
l_ok
pixWriteStreamWebP(FILE *fp,
PIX *pixs,
l_int32 quality,
l_int32 lossless)
{
l_uint8 *filedata;
size_t filebytes, nbytes;
PROCNAME("pixWriteStreamWebP");
if (!fp)
return ERROR_INT("stream not open", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
pixSetPadBits(pixs, 0);
pixWriteMemWebP(&filedata, &filebytes, pixs, quality, lossless);
rewind(fp);
nbytes = fwrite(filedata, 1, filebytes, fp);
free(filedata);
if (nbytes != filebytes)
return ERROR_INT("Write error", procName, 1);
return 0;
}
/*!
* \brief pixWriteMemWebP()
*
* \param[out] pencdata webp encoded data of pixs
* \param[out] pencsize size of webp encoded data
* \param[in] pixs any depth, cmapped OK
* \param[in] quality 0 - 100; default ~80
* \param[in] lossless use 1 for lossless; 0 for lossy
* \return 0 if OK, 1 on error
*
*
* Notes:
* (1) Lossless and lossy encoding are entirely different in webp.
* %quality applies to lossy, and is ignored for lossless.
* (2) The input image is converted to RGB if necessary. If spp == 3,
* we set the alpha channel to fully opaque (255), and
* WebPEncodeRGBA() then removes the alpha chunk when encoding,
* setting the internal header field has_alpha to 0.
*
*/
l_ok
pixWriteMemWebP(l_uint8 **pencdata,
size_t *pencsize,
PIX *pixs,
l_int32 quality,
l_int32 lossless)
{
l_int32 w, h, d, wpl, stride;
l_uint32 *data;
PIX *pix1, *pix2;
PROCNAME("pixWriteMemWebP");
if (!pencdata)
return ERROR_INT("&encdata not defined", procName, 1);
*pencdata = NULL;
if (!pencsize)
return ERROR_INT("&encsize not defined", procName, 1);
*pencsize = 0;
if (!pixs)
return ERROR_INT("&pixs not defined", procName, 1);
if (lossless == 0 && (quality < 0 || quality > 100))
return ERROR_INT("quality not in [0 ... 100]", procName, 1);
if ((pix1 = pixRemoveColormap(pixs, REMOVE_CMAP_TO_FULL_COLOR)) == NULL)
return ERROR_INT("failure to remove color map", procName, 1);
/* Convert to rgb if not 32 bpp; pix2 must not be a clone of pixs. */
if (pixGetDepth(pix1) != 32)
pix2 = pixConvertTo32(pix1);
else
pix2 = pixCopy(NULL, pix1);
pixDestroy(&pix1);
pixGetDimensions(pix2, &w, &h, &d);
if (w <= 0 || h <= 0 || d != 32) {
pixDestroy(&pix2);
return ERROR_INT("pix2 not 32 bpp or of 0 size", procName, 1);
}
/* If spp == 3, need to set alpha layer to opaque (all 1s). */
if (pixGetSpp(pix2) == 3)
pixSetComponentArbitrary(pix2, L_ALPHA_CHANNEL, 255);
/* The WebP API expects data in RGBA order. The pix stores
* in host-dependent order with R as the MSB and A as the LSB.
* On little-endian machines, the bytes in the word must
* be swapped; e.g., R goes from byte 0 (LSB) to byte 3 (MSB).
* No swapping is necessary for big-endians. */
pixEndianByteSwap(pix2);
wpl = pixGetWpl(pix2);
data = pixGetData(pix2);
stride = wpl * 4;
if (lossless) {
*pencsize = WebPEncodeLosslessRGBA((uint8_t *)data, w, h,
stride, pencdata);
} else {
*pencsize = WebPEncodeRGBA((uint8_t *)data, w, h, stride,
quality, pencdata);
}
pixDestroy(&pix2);
if (*pencsize == 0) {
free(*pencdata);
*pencdata = NULL;
return ERROR_INT("webp encoding failed", procName, 1);
}
return 0;
}
/* --------------------------------------------*/
#endif /* HAVE_LIBWEBP */
/* --------------------------------------------*/