/*!
* readHeaderWebP()
*
* Input: filename
* &w (<return> width)
* &h (<return> height)
* &spp (<return> spp (3 or 4))
* Return: 0 if OK, 1 on error
*/
l_int32
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((char *)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);
}
/* Retrieve header data from file and from array in memory */
static l_int32
get_header_data(const char *filename)
{
l_uint8 *data;
l_int32 ret1, ret2, format1, format2;
l_int32 w1, w2, h1, h2, d1, d2, bps1, bps2, spp1, spp2, iscmap1, iscmap2;
size_t nbytes1, nbytes2;
/* Read header from file */
nbytes1 = nbytesInFile(filename);
ret1 = pixReadHeader(filename, &format1, &w1, &h1, &bps1, &spp1, &iscmap1);
d1 = bps1 * spp1;
if (d1 == 24) d1 = 32;
if (ret1)
fprintf(stderr, "Error: couldn't read header data from file: %s\n",
filename);
else {
fprintf(stderr, "Format data for image %s with format %s:\n"
" nbytes = %ld, size (w, h, d) = (%d, %d, %d)\n"
" bps = %d, spp = %d, iscmap = %d\n",
filename, ImageFileFormatExtensions[format1], nbytes1,
w1, h1, d1, bps1, spp1, iscmap1);
if (format1 != IFF_PNG) {
fprintf(stderr, "Error: format is %d; should be %d\n",
format1, IFF_PNG);
ret1 = 1;
}
}
/* Read header from array in memory */
ret2 = 0;
#if HAVE_FMEMOPEN
data = l_binaryRead(filename, &nbytes2);
ret2 = pixReadHeaderMem(data, nbytes2, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
lept_free(data);
d2 = bps2 * spp2;
if (d2 == 24) d2 = 32;
if (ret2)
fprintf(stderr, "Error: couldn't mem-read header data: %s\n", filename);
else {
if (nbytes1 != nbytes2 || format1 != format2 || w1 != w2 ||
h1 != h2 || d1 != d2 || bps1 != bps2 || spp1 != spp2 ||
iscmap1 != iscmap2) {
fprintf(stderr, "Incomsistency reading image %s with format %s\n",
filename, ImageFileFormatExtensions[IFF_PNG]);
ret2 = 1;
}
}
#endif /* HAVE_FMEMOPEN */
return ret1 || ret2;
}
int main(int argc,
char **argv)
{
l_uint8 *data;
l_int32 w, h, n1, n2, n, i, minval, maxval;
l_int32 ncolors, rval, gval, bval, equal;
l_int32 *rmap, *gmap, *bmap;
l_uint32 color;
l_float32 gamma;
BOX *box;
FILE *fp;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixb, *pixg, *pixc, *pixd;
PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2;
PIXA *pixa, *pixa2, *pixa3;
PIXCMAP *cmap, *cmap2;
RGBA_QUAD *cta;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------------------ (1) ----------------------------*/
/* Blend with a white background */
pix1 = pixRead("books_logo.png");
pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display);
pix2 = pixAlphaBlendUniform(pix1, 0xffffff00);
pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
/* Generate an alpha layer based on the white background */
pix3 = pixSetAlphaOverWhite(pix2);
pixSetSpp(pix3, 3);
pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */
regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */
pixSetSpp(pix3, 4);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */
pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display);
/* Render on a light yellow background */
pix4 = pixAlphaBlendUniform(pix3, 0xffffe000);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* ------------------------ (2) ----------------------------*/
lept_rmdir("alpha");
lept_mkdir("alpha");
/* Make the transparency (alpha) layer.
* pixs is the mask. We turn it into a transparency (alpha)
* layer by converting to 8 bpp. A small convolution fuzzes
* the mask edges so that you don't see the pixels. */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
pixg = pixConvert1To8(NULL, pixs, 0, 255);
pixg2 = pixBlockconvGray(pixg, NULL, 1, 1);
regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display);
/* Make the viewable image.
* pixc is the image that we see where the alpha layer is
* opaque -- i.e., greater than 0. Scale it to the same
* size as the mask. To visualize what this will look like
* when displayed over a black background, create the black
* background image, pixb, and do the blending with pixcs1
* explicitly using the alpha layer pixg2. */
pixc = pixRead("tetons.jpg");
pixcs1 = pixScaleToSize(pixc, w, h);
regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display);
pixb = pixCreateTemplate(pixcs1); /* black */
pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display);
/* Embed the alpha layer pixg2 into the color image pixc.
* Write it out as is. Then clean pixcs1 (to 0) under the fully
* transparent part of the alpha layer, and write that result
* out as well. */
pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL);
pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG);
pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0);
pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG);
/* What will this look like over a black background?
* Do the blending explicitly and display. It should
* look identical to the blended result pixd1 before cleaning. */
pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display);
/* Read the two images back, ignoring the transparency layer.
* The uncleaned image will come back identical to pixcs1.
* However, the cleaned image will be black wherever
* the alpha layer was fully transparent. It will
* look the same when viewed through the alpha layer,
* but have much better compression. */
pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */
pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */
n1 = nbytesInFile("/tmp/alpha/pixcs1.png");
n2 = nbytesInFile("/tmp/alpha/pixcs2.png");
fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display);
pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent",
rp->display);
pixa = pixaCreate(0);
pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32);
pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display);
pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixg);
pixDestroy(&pixg2);
pixDestroy(&pixc);
pixDestroy(&pixcs1);
pixDestroy(&pixcs2);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------------------ (3) ----------------------------*/
color = 0xffffa000;
gamma = 1.0;
minval = 0;
maxval = 200;
box = boxCreate(0, 85, 600, 100);
pixa = pixaCreate(6);
pix1 = pixRead("blend-green1.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green2.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green3.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-orange.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-yellow.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-red.png");
pixaAddPix(pixa, pix1, L_INSERT);
n = pixaGetCount(pixa);
pixa2 = pixaCreate(n);
pixa3 = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */
pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display);
pixaAddPix(pixa2, pix2, L_INSERT);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */
pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display);
pixaAddPix(pixa3, pix2, L_INSERT);
pixDestroy(&pix1);
}
if (rp->display) {
pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test",
"/tmp/alpha/blending1.pdf");
pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test",
"/tmp/alpha/blending2.pdf");
}
pixaDestroy(&pixa);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
boxDestroy(&box);
/* ------------------------ (4) ----------------------------*/
/* Use one image as the alpha component for a second image */
pix1 = pixRead("test24.jpg");
pix2 = pixRead("marge.jpg");
pix3 = pixScale(pix2, 1.9, 2.2);
pix4 = pixConvertTo8(pix3, 0);
pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
/* Set the alpha value in a colormap to bval */
pix5 = pixOctreeColorQuant(pix1, 128, 0);
cmap = pixGetColormap(pix5);
pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
cta = (RGBA_QUAD *)cmap->array;
cta[i].alpha = bval;
}
/* Test binary serialization/deserialization of colormap with alpha */
pixcmapSerializeToMemory(cmap, 4, &ncolors, &data);
cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */
pixcmapDestroy(&cmap2);
lept_free(data);
/* Test ascii serialization/deserialization of colormap with alpha */
fp = fopenWriteStream("/tmp/alpha/cmap.4", "w");
pixcmapWriteStream(fp, cmap);
fclose(fp);
fp = fopenReadStream("/tmp/alpha/cmap.4");
cmap2 = pixcmapReadStream(fp);
fclose(fp);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */
pixcmapDestroy(&cmap2);
/* Test r/w for cmapped pix with non-opaque alpha */
pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */
pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG);
pix6 = pixRead("/tmp/alpha/fourcomp.png");
regTestComparePix(rp, pix5, pix6); /* 28 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
lept_free(rmap);
lept_free(gmap);
lept_free(bmap);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
#if HAVE_FMEMOPEN
char psname[256];
#endif /* HAVE_FMEMOPEN */
char *tempname;
l_uint8 *data;
l_int32 i, d, n, success, failure, same;
l_int32 w, h, bps, spp;
size_t size, nbytes;
PIX *pix1, *pix2, *pix4, *pix8, *pix16, *pix32;
PIX *pix, *pixt, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
#if !HAVE_LIBJPEG
fprintf(stderr, "Omitting libjpeg tests in ioformats_reg\n");
#endif /* !HAVE_LIBJPEG */
#if !HAVE_LIBTIFF
fprintf(stderr, "Omitting libtiff tests in ioformats_reg\n");
#endif /* !HAVE_LIBTIFF */
#if !HAVE_LIBPNG || !HAVE_LIBZ
fprintf(stderr, "Omitting libpng tests in ioformats_reg\n");
#endif /* !HAVE_LIBPNG || !HAVE_LIBZ */
if (regTestSetup(argc, argv, &rp))
return 1;
/* --------- Part 1: Test all lossless formats for r/w to file ---------*/
failure = FALSE;
success = TRUE;
fprintf(stderr, "Test bmp 1 bpp file:\n");
if (ioFormatTest(BMP_FILE)) success = FALSE;
#if HAVE_LIBTIFF
fprintf(stderr, "\nTest other 1 bpp file:\n");
if (ioFormatTest(FILE_1BPP)) success = FALSE;
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBPNG
fprintf(stderr, "\nTest 2 bpp file:\n");
if (ioFormatTest(FILE_2BPP)) success = FALSE;
fprintf(stderr, "\nTest 2 bpp file with cmap:\n");
if (ioFormatTest(FILE_2BPP_C)) success = FALSE;
fprintf(stderr, "\nTest 4 bpp file:\n");
if (ioFormatTest(FILE_4BPP)) success = FALSE;
fprintf(stderr, "\nTest 4 bpp file with cmap:\n");
if (ioFormatTest(FILE_4BPP_C)) success = FALSE;
fprintf(stderr, "\nTest 8 bpp grayscale file with cmap:\n");
if (ioFormatTest(FILE_8BPP_1)) success = FALSE;
fprintf(stderr, "\nTest 8 bpp color file with cmap:\n");
if (ioFormatTest(FILE_8BPP_2)) success = FALSE;
#endif /* HAVE_LIBPNG */
#if HAVE_LIBJPEG
fprintf(stderr, "\nTest 8 bpp file without cmap:\n");
if (ioFormatTest(FILE_8BPP_3)) success = FALSE;
#endif /* HAVE_LIBJPEG */
#if HAVE_LIBTIFF
fprintf(stderr, "\nTest 16 bpp file:\n");
if (ioFormatTest(FILE_16BPP)) success = FALSE;
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBJPEG
fprintf(stderr, "\nTest 32 bpp file:\n");
if (ioFormatTest(FILE_32BPP)) success = FALSE;
#endif /* HAVE_LIBJPEG */
if (success)
fprintf(stderr,
"\n ********** Success on all i/o format tests *********\n");
else
fprintf(stderr,
"\n ******* Failure on at least one i/o format test ******\n");
if (!success) failure = TRUE;
/* ------------------ Part 2: Test tiff r/w to file ------------------- */
#if !HAVE_LIBTIFF
goto part6;
#endif /* !HAVE_LIBTIFF */
fprintf(stderr, "\nTest tiff r/w and format extraction\n");
pixa = pixaCreate(6);
pix1 = pixRead(BMP_FILE);
pix2 = pixConvert1To2(NULL, pix1, 3, 0);
pix4 = pixConvert1To4(NULL, pix1, 15, 0);
pix16 = pixRead(FILE_16BPP);
fprintf(stderr, "Input format: %d\n", pixGetInputFormat(pix16));
pix8 = pixConvert16To8(pix16, 1);
pix32 = pixRead(FILE_32BPP);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixaAddPix(pixa, pix8, L_INSERT);
pixaAddPix(pixa, pix16, L_INSERT);
pixaAddPix(pixa, pix32, L_INSERT);
n = pixaGetCount(pixa);
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
fprintf(stderr, "%d bpp\n", d);
if (i == 0) { /* 1 bpp */
pixWrite("/tmp/junkg3.tif", pix, IFF_TIFF_G3);
pixWrite("/tmp/junkg4.tif", pix, IFF_TIFF_G4);
pixWrite("/tmp/junkrle.tif", pix, IFF_TIFF_RLE);
pixWrite("/tmp/junkpb.tif", pix, IFF_TIFF_PACKBITS);
if (testcomp("/tmp/junkg3.tif", pix, IFF_TIFF_G3)) success = FALSE;
if (testcomp("/tmp/junkg4.tif", pix, IFF_TIFF_G4)) success = FALSE;
if (testcomp("/tmp/junkrle.tif", pix, IFF_TIFF_RLE))
success = FALSE;
if (testcomp("/tmp/junkpb.tif", pix, IFF_TIFF_PACKBITS))
success = FALSE;
}
pixWrite("/tmp/junklzw.tif", pix, IFF_TIFF_LZW);
pixWrite("/tmp/junkzip.tif", pix, IFF_TIFF_ZIP);
pixWrite("/tmp/junknon.tif", pix, IFF_TIFF);
if (testcomp("/tmp/junklzw.tif", pix, IFF_TIFF_LZW)) success = FALSE;
if (testcomp("/tmp/junkzip.tif", pix, IFF_TIFF_ZIP)) success = FALSE;
if (testcomp("/tmp/junknon.tif", pix, IFF_TIFF)) success = FALSE;
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on tiff r/w to file *********\n\n");
else
fprintf(stderr,
"\n ******* Failure on at least one tiff r/w to file ******\n\n");
if (!success) failure = TRUE;
/* ------------------ Part 3: Test tiff r/w to memory ----------------- */
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
fprintf(stderr, "%d bpp\n", d);
if (i == 0) { /* 1 bpp */
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_G3);
nbytes = nbytesInFile("/tmp/junkg3.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_G3)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_G4);
nbytes = nbytesInFile("/tmp/junkg4.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_G4)) success = FALSE;
readHeaderMemTiff(data, size, 0, &w, &h, &bps, &spp,
NULL, NULL, NULL);
fprintf(stderr, "(w,h,bps,spp) = (%d,%d,%d,%d)\n", w, h, bps, spp);
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_RLE);
nbytes = nbytesInFile("/tmp/junkrle.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_RLE)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_PACKBITS);
nbytes = nbytesInFile("/tmp/junkpb.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_PACKBITS)) success = FALSE;
lept_free(data);
}
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_LZW);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_LZW)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_ZIP);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_ZIP)) success = FALSE;
readHeaderMemTiff(data, size, 0, &w, &h, &bps, &spp, NULL, NULL, NULL);
fprintf(stderr, "(w,h,bps,spp) = (%d,%d,%d,%d)\n", w, h, bps, spp);
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF)) success = FALSE;
lept_free(data);
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on tiff r/w to memory *********\n\n");
else
fprintf(stderr,
"\n ******* Failure on at least one tiff r/w to memory ******\n\n");
if (!success) failure = TRUE;
/* ---------------- Part 4: Test non-tiff r/w to memory ---------------- */
#if HAVE_FMEMOPEN
pixDisplayWrite(NULL, -1);
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
sprintf(psname, "/tmp/junkps.%d", d);
fprintf(stderr, "%d bpp\n", d);
if (d != 16) {
if (test_writemem(pix, IFF_PNG, NULL)) success = FALSE;
if (test_writemem(pix, IFF_BMP, NULL)) success = FALSE;
}
if (test_writemem(pix, IFF_PNM, NULL)) success = FALSE;
if (test_writemem(pix, IFF_PS, psname)) success = FALSE;
if (d == 8 || d == 32)
if (test_writemem(pix, IFF_JFIF_JPEG, NULL)) success = FALSE;
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on non-tiff r/w to memory *********\n\n");
else
fprintf(stderr,
"\n **** Failure on at least one non-tiff r/w to memory *****\n\n");
if (!success) failure = TRUE;
#else
fprintf(stderr,
"\n ***** Non-tiff r/w to memory not enabled *****\n\n");
#endif /* HAVE_FMEMOPEN */
pixaDestroy(&pixa);
/* ------------ Part 5: Test multipage tiff r/w to memory ------------ */
/* Make a multipage tiff file, and read it back into memory */
success = TRUE;
pix = pixRead("feyn.tif");
pixa = pixaSplitPix(pix, 3, 3, 0, 0);
for (i = 0; i < 9; i++) {
pixt = pixaGetPix(pixa, i, L_CLONE);
if (i == 0)
pixWriteTiff("/tmp/junktiffmpage.tif", pixt, IFF_TIFF_G4, "w");
else
pixWriteTiff("/tmp/junktiffmpage.tif", pixt, IFF_TIFF_G4, "a");
pixDestroy(&pixt);
}
data = l_binaryRead("/tmp/junktiffmpage.tif", &nbytes);
pixaDestroy(&pixa);
/* Read the individual pages from memory to a pix */
pixa = pixaCreate(9);
for (i = 0; i < 9; i++) {
pixt = pixReadMemTiff(data, nbytes, i);
pixaAddPix(pixa, pixt, L_INSERT);
}
lept_free(data);
/* Un-tile the pix in the pixa back to the original image */
pixt = pixaDisplayUnsplit(pixa, 3, 3, 0, 0);
pixaDestroy(&pixa);
/* Clip to foreground to remove any extra rows or columns */
pixClipToForeground(pix, &pix1, NULL);
pixClipToForeground(pixt, &pix2, NULL);
pixEqual(pix1, pix2, &same);
if (same)
fprintf(stderr,
"\n ******* Success on tiff multipage read from memory ******\n\n");
else
fprintf(stderr,
"\n ******* Failure on tiff multipage read from memory ******\n\n");
if (!same) failure = TRUE;
pixDestroy(&pix);
pixDestroy(&pixt);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Part 6: Test 24 bpp writing ------------ */
#if !HAVE_LIBTIFF
part6:
#endif /* !HAVE_LIBTIFF */
#if !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF
goto finish;
#endif /* !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF */
/* Generate a 24 bpp (not 32 bpp !!) rgb pix and write it out */
success = TRUE;
pix = pixRead("marge.jpg");
pixt = make_24_bpp_pix(pix);
pixWrite("/tmp/junk24.png", pixt, IFF_PNG);
pixWrite("/tmp/junk24.jpg", pixt, IFF_JFIF_JPEG);
pixWrite("/tmp/junk24.tif", pixt, IFF_TIFF);
pixd = pixRead("/tmp/junk24.png");
pixEqual(pix, pixd, &same);
if (!same) success = FALSE;
pixDestroy(&pixd);
pixd = pixRead("/tmp/junk24.jpg");
regTestCompareSimilarPix(rp, pix, pixd, 10, 0.0002, 0);
pixDestroy(&pixd);
pixd = pixRead("/tmp/junk24.tif");
pixEqual(pix, pixd, &same);
if (!same) success = FALSE;
pixDestroy(&pixd);
if (success)
fprintf(stderr,
"\n ******* Success on 24 bpp rgb writing *******\n\n");
else
fprintf(stderr,
"\n ******* Failure on 24 bpp rgb writing *******\n\n");
if (!success) failure = TRUE;
pixDestroy(&pix);
pixDestroy(&pixt);
/* -------------- Part 7: Read header information -------------- */
success = TRUE;
if (get_header_data(FILE_1BPP, IFF_TIFF_G4)) success = FALSE;
if (get_header_data(FILE_2BPP, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_2BPP_C, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_4BPP, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_4BPP_C, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_1, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_2, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_3, IFF_JFIF_JPEG)) success = FALSE;
if (get_header_data(FILE_16BPP, IFF_TIFF_ZIP)) success = FALSE;
if (get_header_data(FILE_32BPP, IFF_JFIF_JPEG)) success = FALSE;
#if HAVE_FMEMOPEN
pix = pixRead(FILE_8BPP_1);
tempname = genTempFilename((const char *)"/tmp", (const char *)".pnm",
1, 1);
pixWrite(tempname, pix, IFF_PNM);
if (get_header_data(tempname, IFF_PNM)) success = FALSE;
pixDestroy(&pix);
lept_free(tempname);
#endif /* HAVE_FMEMOPEN */
pix = pixRead(FILE_1BPP);
tempname = genTempFilename((const char *)"/tmp", (const char *)".tif",
1, 1);
pixWrite(tempname, pix, IFF_TIFF_G3);
if (get_header_data(tempname, IFF_TIFF_G3)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_G4);
if (get_header_data(tempname, IFF_TIFF_G4)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_PACKBITS);
if (get_header_data(tempname, IFF_TIFF_PACKBITS)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_RLE);
if (get_header_data(tempname, IFF_TIFF_RLE)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_LZW);
if (get_header_data(tempname, IFF_TIFF_LZW)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_ZIP);
if (get_header_data(tempname, IFF_TIFF_ZIP)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF);
if (get_header_data(tempname, IFF_TIFF)) success = FALSE;
pixDestroy(&pix);
lept_free(tempname);
if (success)
fprintf(stderr,
"\n ******* Success on reading headers *******\n\n");
else
fprintf(stderr,
"\n ******* Failure on reading headers *******\n\n");
if (!success) failure = TRUE;
#if !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF
finish:
#endif /* !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF */
if (!failure)
fprintf(stderr,
" ******* Success on all tests *******\n\n");
else
fprintf(stderr,
" ******* Failure on at least one test *******\n\n");
return regTestCleanup(rp);
}
/* Retrieve header data from file */
static l_int32
get_header_data(const char *filename,
l_int32 true_format)
{
char buf[64];
l_uint8 *data;
l_int32 ret1, ret2, format1, format2;
l_int32 w1, w2, h1, h2, d1, d2, bps1, bps2, spp1, spp2, iscmap1, iscmap2;
size_t size1, size2;
/* Fail silently if library is not available */
#if !HAVE_LIBJPEG
if (true_format == IFF_JFIF_JPEG)
return 0;
#endif /* !HAVE_LIBJPEG */
#if !HAVE_LIBPNG
if (true_format == IFF_PNG)
return 0;
#endif /* !HAVE_LIBPNG */
#if !HAVE_LIBTIFF
if (true_format == IFF_TIFF_G3 || true_format == IFF_TIFF_G4 ||
true_format == IFF_TIFF_ZIP || true_format == IFF_TIFF_LZW ||
true_format == IFF_TIFF_PACKBITS || true_format == IFF_TIFF_RLE ||
true_format == IFF_TIFF)
return 0;
#endif /* !HAVE_LIBTIFF */
/* Read header from file */
size1 = nbytesInFile(filename);
ret1 = pixReadHeader(filename, &format1, &w1, &h1, &bps1, &spp1, &iscmap1);
d1 = bps1 * spp1;
if (d1 == 24) d1 = 32;
if (ret1)
fprintf(stderr, "Error: couldn't read header data: %s\n", filename);
else {
if (format1 > IFF_PNG && format1 < IFF_PNM) {
get_tiff_compression_name(buf, format1);
fprintf(stderr, "Format data for image %s with format %s:\n"
" nbytes = %ld, size (w, h, d) = (%d, %d, %d)\n"
" bps = %d, spp = %d, iscmap = %d\n",
filename, buf, size1, w1, h1, d1, bps1, spp1, iscmap1);
} else {
fprintf(stderr, "Format data for image %s with format %s:\n"
" nbytes = %ld, size (w, h, d) = (%d, %d, %d)\n"
" bps = %d, spp = %d, iscmap = %d\n",
filename, ImageFileFormatExtensions[format1], size1,
w1, h1, d1, bps1, spp1, iscmap1);
}
if (format1 != true_format) {
fprintf(stderr, "Error: format is %d; should be %d\n",
format1, true_format);
ret1 = 1;
}
}
/* Read header from array in memory */
data = l_binaryRead(filename, &size2);
ret2 = pixReadHeaderMem(data, size2, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
lept_free(data);
d2 = bps2 * spp2;
if (d2 == 24) d2 = 32;
if (ret2)
fprintf(stderr, "Error: couldn't mem-read header data: %s\n", filename);
else {
if (size1 != size2 || format1 != format2 || w1 != w2 ||
h1 != h2 || d1 != d2 || bps1 != bps2 || spp1 != spp2 ||
iscmap1 != iscmap2) {
fprintf(stderr, "Incomsistency reading image %s with format %s\n",
filename, buf);
ret2 = 1;
}
}
return ret1 || ret2;
}
int main(int argc,
char **argv)
{
char *str;
l_uint8 *data1, *data2;
l_int32 i, n, same1, same2;
size_t size1, size2, slice, total, start, end;
FILE *fp;
L_DNA *da;
SARRAY *sa;
L_BYTEA *lba1, *lba2, *lba3, *lba4, *lba5;
static char mainName[] = "byteatest";
if (argc != 1)
return ERROR_INT("syntax: byteatest", mainName, 1);
lept_mkdir("bytea");
/* Test basic init, join and split */
lba1 = l_byteaInitFromFile("feyn.tif");
lba2 = l_byteaInitFromFile("test24.jpg");
size1 = l_byteaGetSize(lba1);
size2 = l_byteaGetSize(lba2);
l_byteaJoin(lba1, &lba2);
lba3 = l_byteaInitFromMem(lba1->data, size1);
lba4 = l_byteaInitFromMem(lba1->data + size1, size2);
/* Split by hand */
l_binaryWrite("/tmp/bytea/junk1.dat", "w", lba3->data, lba3->size);
l_binaryWrite("/tmp/bytea/junk2.dat", "w", lba4->data, lba4->size);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk1.dat", &same1);
filesAreIdentical("test24.jpg", "/tmp/bytea/junk2.dat", &same2);
if (same1 && same2)
fprintf(stderr, "OK for join file\n");
else
fprintf(stderr, "Error: files are different!\n");
/* Split by function */
l_byteaSplit(lba1, size1, &lba5);
l_binaryWrite("/tmp/bytea/junk3.dat", "w", lba1->data, lba1->size);
l_binaryWrite("/tmp/bytea/junk4.dat", "w", lba5->data, lba5->size);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk3.dat", &same1);
filesAreIdentical("test24.jpg", "/tmp/bytea/junk4.dat", &same2);
if (same1 && same2)
fprintf(stderr, "OK for split file\n");
else
fprintf(stderr, "Error: files are different!\n");
l_byteaDestroy(&lba1);
l_byteaDestroy(&lba2);
l_byteaDestroy(&lba3);
l_byteaDestroy(&lba4);
l_byteaDestroy(&lba5);
/* Test appending with strings */
data1 = l_binaryRead("kernel_reg.c", &size1);
sa = sarrayCreateLinesFromString((char *)data1, 1);
lba1 = l_byteaCreate(0);
n = sarrayGetCount(sa);
for (i = 0; i < n; i++) {
str = sarrayGetString(sa, i, L_NOCOPY);
l_byteaAppendString(lba1, str);
l_byteaAppendString(lba1, (char *)"\n");
}
data2 = l_byteaGetData(lba1, &size2);
l_binaryWrite("/tmp/bytea/junk5.dat", "w", data2, size2);
filesAreIdentical("kernel_reg.c", "/tmp/bytea/junk5.dat", &same1);
if (same1)
fprintf(stderr, "OK for appended string data\n");
else
fprintf(stderr, "Error: appended string data is different!\n");
lept_free(data1);
sarrayDestroy(&sa);
l_byteaDestroy(&lba1);
/* Test appending with binary data */
slice = 1000;
total = nbytesInFile("breviar-a38.jp2");
lba1 = l_byteaCreate(100);
n = 1 + total / slice;
fprintf(stderr, "******************************************************\n");
fprintf(stderr, "* Testing error checking: ignore two reported errors *\n");
for (i = 0, start = 0; i <= n; i++, start += slice) {
data1 = l_binaryReadSelect("breviar-a38.jp2", start, slice, &size1);
l_byteaAppendData(lba1, data1, size1);
lept_free(data1);
}
fprintf(stderr, "******************************************************\n");
data2 = l_byteaGetData(lba1, &size2);
l_binaryWrite("/tmp/bytea/junk6.dat", "w", data2, size2);
filesAreIdentical("breviar-a38.jp2", "/tmp/bytea/junk6.dat", &same1);
if (same1)
fprintf(stderr, "OK for appended binary data\n");
else
fprintf(stderr, "Error: appended binary data is different!\n");
l_byteaDestroy(&lba1);
/* Test search */
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "/tmp/bytea/junk7.pdf",
0, 0, 100, NULL, NULL, 0);
lba1 = l_byteaInitFromFile("/tmp/bytea/junk7.pdf");
l_byteaFindEachSequence(lba1, (l_uint8 *)" 0 obj\n", 7, &da);
/* l_dnaWriteStream(stderr, da); */
n = l_dnaGetCount(da);
if (n == 6)
fprintf(stderr, "OK for search: found 6 instances\n");
else
fprintf(stderr, "Error in search: found %d instances, not 6\n", n);
l_byteaDestroy(&lba1);
l_dnaDestroy(&da);
/* Test write to file */
lba1 = l_byteaInitFromFile("feyn.tif");
fp = lept_fopen("/tmp/bytea/junk8.dat", "wb");
size1 = l_byteaGetSize(lba1);
for (start = 0; start < size1; start += 1000) {
end = L_MIN(start + 1000 - 1, size1 - 1);
l_byteaWriteStream(fp, lba1, start, end);
}
lept_fclose(fp);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk8.dat", &same1);
if (same1)
fprintf(stderr, "OK for written binary data\n");
else
fprintf(stderr, "Error: written binary data is different!\n");
l_byteaDestroy(&lba1);
return 0;
}
