mirror of http://192.168.1.51:8099/lmh188/twain3.0
418 lines
13 KiB
C
418 lines
13 KiB
C
/*====================================================================*
|
|
- Copyright (C) 2001 Leptonica. All rights reserved.
|
|
-
|
|
- Redistribution and use in source and binary forms, with or without
|
|
- modification, are permitted provided that the following conditions
|
|
- are met:
|
|
- 1. Redistributions of source code must retain the above copyright
|
|
- notice, this list of conditions and the following disclaimer.
|
|
- 2. Redistributions in binary form must reproduce the above
|
|
- copyright notice, this list of conditions and the following
|
|
- disclaimer in the documentation and/or other materials
|
|
- provided with the distribution.
|
|
-
|
|
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
- ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY
|
|
- CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
- EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
- PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
- OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*====================================================================*/
|
|
|
|
/*!
|
|
* \file webpio.c
|
|
* <pre>
|
|
*
|
|
* Reading WebP
|
|
* PIX *pixReadStreamWebP()
|
|
* PIX *pixReadMemWebP()
|
|
*
|
|
* Reading WebP header
|
|
* l_int32 readHeaderWebP()
|
|
* l_int32 readHeaderMemWebP()
|
|
*
|
|
* Writing WebP
|
|
* l_int32 pixWriteWebP() [ special top level ]
|
|
* l_int32 pixWriteStreamWebP()
|
|
* l_int32 pixWriteMemWebP()
|
|
* </pre>
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config_auto.h"
|
|
#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
|
|
*
|
|
* <pre>
|
|
* 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().
|
|
* </pre>
|
|
*/
|
|
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
|
|
*
|
|
* <pre>
|
|
* Notes:
|
|
* (1) Special top-level function allowing specification of quality.
|
|
* </pre>
|
|
*/
|
|
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
|
|
*
|
|
* <pre>
|
|
* 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.
|
|
* </pre>
|
|
*/
|
|
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
|
|
*
|
|
* <pre>
|
|
* 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.
|
|
* </pre>
|
|
*/
|
|
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 */
|
|
/* --------------------------------------------*/
|