/* 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;
}
static void
get_format_data(l_int32 i,
l_uint8 *data,
size_t size)
{
l_int32 ret, format, w, h, d, bps, spp, iscmap;
ret = pixReadHeaderMem(data, size, &format, &w, &h, &bps, &spp, &iscmap);
d = bps * spp;
if (d == 24) d = 32;
if (ret)
fprintf(stderr, "Error: couldn't read data: size = %d\n",
(l_int32)size);
else
fprintf(stderr, "Format data for image %d:\n"
" format: %s, size (w, h, d) = (%d, %d, %d)\n"
" bps = %d, spp = %d, iscmap = %d\n",
i, ImageFileFormatExtensions[format], w, h, d,
bps, spp, iscmap);
return;
}
/* 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;
}
main(int argc,
char **argv)
{
char buf[256];
size_t nbytes;
l_int32 i, w, h, success, display;
l_int32 format, bps, spp, iscmap, format2, w2, h2, bps2, spp2, iscmap2;
l_uint8 *data;
l_uint32 *data32, *data32r;
BOX *box;
FILE *fp;
PIX *pixs, *pixt, *pixt2, *pixd;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Test basic serialization/deserialization */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
/* Serialize to memory */
pixSerializeToMemory(pixs, &data32, &nbytes);
/* Just for fun, write and read back from file */
arrayWrite("/tmp/array", "w", data32, nbytes);
data32r = (l_uint32 *)arrayRead("/tmp/array", (l_int32 *)(&nbytes));
/* Deserialize */
pixd = pixDeserializeFromMemory(data32r, nbytes);
regTestComparePix(fp, argv, pixs, pixd, i, &success);
pixDestroy(&pixd);
pixDestroy(&pixs);
FREE(data32);
FREE(data32r);
}
/* Test read/write fileio interface */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixGetDimensions(pixs, &w, &h, NULL);
box = boxCreate(0, 0, L_MIN(150, w), L_MIN(150, h));
pixt = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
snprintf(buf, sizeof(buf), "/tmp/pixs.%d", i);
pixWrite(buf, pixt, IFF_SPIX);
regTestCheckFile(fp, argv, buf, i, &success);
pixt2 = pixRead(buf);
regTestComparePix(fp, argv, pixt, pixt2, nfiles + i, &success);
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixt2);
}
/* Test read header. Note that for rgb input, spp = 3,
* but for 32 bpp spix, we set spp = 4. */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixWriteMem(&data, &nbytes, pixs, IFF_SPIX);
pixReadHeader(filename[i], &format, &w, &h, &bps, &spp, &iscmap);
pixReadHeaderMem(data, nbytes, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
if (format2 != 16 || w != w2 || h != h2 || bps != bps2 ||
iscmap != iscmap2) {
if (fp)
fprintf(fp, "Failure comparing data");
else
fprintf(stderr, "Failure comparing data");
success = FALSE;
}
pixDestroy(&pixs);
FREE(data);
}
#if 0
/* Do timing */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
startTimer();
pixSerializeToMemory(pixs, &data32, &nbytes);
pixd = pixDeserializeFromMemory(data32, nbytes);
fprintf(stderr, "Time for %s: %7.3f sec\n", filename[i], stopTimer());
FREE(data32);
pixDestroy(&pixs);
pixDestroy(&pixd);
}
#endif
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv)
{
char buf[256];
size_t size;
l_int32 i, w, h;
l_int32 format, bps, spp, iscmap, format2, w2, h2, bps2, spp2, iscmap2;
l_uint8 *data;
l_uint32 *data32, *data32r;
BOX *box;
PIX *pixs, *pixt, *pixt2, *pixd;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Test basic serialization/deserialization */
data32 = NULL;
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
/* Serialize to memory */
pixSerializeToMemory(pixs, &data32, &size);
/* Just for fun, write and read back from file */
l_binaryWrite("/tmp/regout/array", "w", data32, size);
data32r = (l_uint32 *)l_binaryRead("/tmp/regout/array", &size);
/* Deserialize */
pixd = pixDeserializeFromMemory(data32r, size);
regTestComparePix(rp, pixs, pixd); /* i */
pixDestroy(&pixd);
pixDestroy(&pixs);
lept_free(data32);
lept_free(data32r);
}
/* Test read/write fileio interface */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixGetDimensions(pixs, &w, &h, NULL);
box = boxCreate(0, 0, L_MIN(150, w), L_MIN(150, h));
pixt = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
snprintf(buf, sizeof(buf), "/tmp/regout/pixs.%d.spix", rp->index + 1);
pixWrite(buf, pixt, IFF_SPIX);
regTestCheckFile(rp, buf); /* nfiles + 2 * i */
pixt2 = pixRead(buf);
regTestComparePix(rp, pixt, pixt2); /* nfiles + 2 * i + 1 */
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixt2);
}
/* Test read header. Note that for rgb input, spp = 3,
* but for 32 bpp spix, we set spp = 4. */
data = NULL;
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixWriteMem(&data, &size, pixs, IFF_SPIX);
pixReadHeader(filename[i], &format, &w, &h, &bps, &spp, &iscmap);
pixReadHeaderMem(data, size, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
if (format2 != IFF_SPIX || w != w2 || h != h2 || bps != bps2 ||
iscmap != iscmap2) {
if (rp->fp)
fprintf(rp->fp, "Failure comparing data");
else
fprintf(stderr, "Failure comparing data");
}
pixDestroy(&pixs);
lept_free(data);
}
#if 0
/* Do timing */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
startTimer();
pixSerializeToMemory(pixs, &data32, &size);
pixd = pixDeserializeFromMemory(data32, size);
fprintf(stderr, "Time for %s: %7.3f sec\n", filename[i], stopTimer());
lept_free(data32);
pixDestroy(&pixs);
pixDestroy(&pixd);
}
#endif
return regTestCleanup(rp);
}