152 #include <config_auto.h>
156 #include "allheaders.h"
159 static const l_uint32 MaxPtrArraySize = 1000000;
163 static const size_t MaxDataSize = 1000000000;
166 extern l_int32 NumImageFileFormatExtensions;
167 extern const char *ImageFileFormatExtensions[];
172 l_uint8 **pdata,
size_t *pnbytes);
203 PROCNAME(
"pixcompCreateFromPix");
206 return (
PIXC *)ERROR_PTR(
"pix not defined", procName, NULL);
207 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
208 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
209 return (
PIXC *)ERROR_PTR(
"invalid comptype", procName, NULL);
211 pixc = (
PIXC *)LEPT_CALLOC(1,
sizeof(
PIXC));
214 if (pixGetColormap(pix))
221 ret = pixWriteMem(&data, &size, pix, format);
223 L_ERROR(
"write to memory failed\n", procName);
254 l_int32 format, w, h, d, bps, spp, iscmap;
257 PROCNAME(
"pixcompCreateFromString");
260 return (
PIXC *)ERROR_PTR(
"data not defined", procName, NULL);
262 return (
PIXC *)ERROR_PTR(
"invalid copyflag", procName, NULL);
264 if (
pixReadHeaderMem(data, size, &format, &w, &h, &bps, &spp, &iscmap) == 1)
265 return (
PIXC *)ERROR_PTR(
"header data not read", procName, NULL);
266 pixc = (
PIXC *)LEPT_CALLOC(1,
sizeof(
PIXC));
267 d = (spp == 3) ? 32 : bps * spp;
307 PROCNAME(
"pixcompCreateFromFile");
310 return (
PIXC *)ERROR_PTR(
"filename not defined", procName, NULL);
311 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
312 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
313 return (
PIXC *)ERROR_PTR(
"invalid comptype", procName, NULL);
316 if (format == IFF_UNKNOWN) {
317 L_ERROR(
"unreadable file: %s\n", procName, filename);
325 if ((format == IFF_TIFF_G4 && comptype != IFF_PNG) ||
326 (format == IFF_JFIF_JPEG && comptype != IFF_PNG))
328 if (comptype != IFF_DEFAULT && comptype == format) {
332 return (
PIXC *)ERROR_PTR(
"pixc not made (string)", procName, NULL);
338 if ((pix =
pixRead(filename)) == NULL)
339 return (
PIXC *)ERROR_PTR(
"pix not read", procName, NULL);
342 return (
PIXC *)ERROR_PTR(
"pixc not made", procName, NULL);
365 PROCNAME(
"pixcompDestroy");
368 L_WARNING(
"ptr address is null!\n", procName);
372 if ((pixc = *ppixc) == NULL)
375 LEPT_FREE(pixc->
data);
377 LEPT_FREE(pixc->
text);
398 l_uint8 *datas, *datad;
401 PROCNAME(
"pixcompCopy");
404 return (
PIXC *)ERROR_PTR(
"pixcs not defined", procName, NULL);
406 if (size > MaxDataSize)
407 return (
PIXC *)ERROR_PTR(
"size > 1 GB; too big", procName, NULL);
409 pixcd = (
PIXC *)LEPT_CALLOC(1,
sizeof(
PIXC));
416 if (pixcs->
text != NULL)
422 if ((datad = (l_uint8 *)LEPT_CALLOC(size,
sizeof(l_int8))) == NULL) {
424 return (
PIXC *)ERROR_PTR(
"pixcd not made", procName, NULL);
426 memcpy(datad, datas, size);
449 PROCNAME(
"pixcompGetDimensions");
452 return ERROR_INT(
"pixc not defined", procName, 1);
453 if (pw) *pw = pixc->
w;
454 if (ph) *ph = pixc->
h;
455 if (pd) *pd = pixc->
d;
474 PROCNAME(
"pixcompGetParameters");
477 return ERROR_INT(
"pixc not defined", procName, 1);
478 if (pxres) *pxres = pixc->
xres;
479 if (pyres) *pyres = pixc->
yres;
480 if (pcomptype) *pcomptype = pixc->
comptype;
481 if (pcmapflag) *pcmapflag = pixc->
cmapflag;
520 PROCNAME(
"pixcompDetermineFormat");
523 return ERROR_INT(
"&format not defined", procName, 1);
525 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
526 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
527 return ERROR_INT(
"invalid comptype", procName, 1);
529 if (comptype == IFF_DEFAULT) {
531 *pformat = IFF_TIFF_G4;
534 else if (d >= 8 && !cmapflag)
535 *pformat = IFF_JFIF_JPEG;
536 }
else if (comptype == IFF_TIFF_G4 && d == 1) {
537 *pformat = IFF_TIFF_G4;
538 }
else if (comptype == IFF_JFIF_JPEG && d >= 8 && !cmapflag) {
539 *pformat = IFF_JFIF_JPEG;
558 l_int32 w, h, d, cmapinpix, format;
561 PROCNAME(
"pixCreateFromPixcomp");
564 return (
PIX *)ERROR_PTR(
"pixc not defined", procName, NULL);
567 return (
PIX *)ERROR_PTR(
"pix not read", procName, NULL);
575 L_INFO(
"pix width %d != pixc width %d\n", procName, w, pixc->
w);
576 L_ERROR(
"pix width %d != pixc width\n", procName, w);
579 L_ERROR(
"pix height %d != pixc height\n", procName, h);
582 L_WARNING(
"pix depth %d != pixc depth 16\n", procName, d);
584 L_ERROR(
"pix depth %d != pixc depth\n", procName, d);
586 cmapinpix = (pixGetColormap(pix) != NULL);
588 L_ERROR(
"pix cmap flag inconsistent\n", procName);
589 format = pixGetInputFormat(pix);
591 L_ERROR(
"pix comptype %d not equal to pixc comptype\n",
613 PROCNAME(
"pixacompCreate");
615 if (n <= 0 || n > MaxPtrArraySize)
618 pixac = (
PIXAC *)LEPT_CALLOC(1,
sizeof(
PIXAC));
622 if ((pixac->
pixc = (
PIXC **)LEPT_CALLOC(n,
sizeof(
PIXC *))) == NULL) {
624 return (
PIXAC *)ERROR_PTR(
"pixc ptrs not made", procName, NULL);
628 return (
PIXAC *)ERROR_PTR(
"boxa not made", procName, NULL);
684 PROCNAME(
"pixacompCreateWithInit");
686 if (n <= 0 || n > MaxPtrArraySize)
687 return (
PIXAC *)ERROR_PTR(
"n out of valid bounds", procName, NULL);
689 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
690 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
691 return (
PIXAC *)ERROR_PTR(
"invalid comptype", procName, NULL);
693 comptype = IFF_TIFF_G4;
696 L_WARNING(
"offset < 0; setting to 0\n", procName);
701 return (
PIXAC *)ERROR_PTR(
"pixac not made", procName, NULL);
707 for (i = 0; i < n; i++) {
747 PROCNAME(
"pixacompCreateFromPixa");
750 return (
PIXAC *)ERROR_PTR(
"pixa not defined", procName, NULL);
751 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
752 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
753 return (
PIXAC *)ERROR_PTR(
"invalid comptype", procName, NULL);
756 return (
PIXAC *)ERROR_PTR(
"invalid accesstype", procName, NULL);
760 return (
PIXAC *)ERROR_PTR(
"pixac not made", procName, NULL);
761 for (i = 0; i < n; i++) {
766 if ((boxa =
pixaGetBoxa(pixa, accesstype)) != NULL) {
804 PROCNAME(
"pixacompCreateFromFiles");
807 return (
PIXAC *)ERROR_PTR(
"dirname not defined", procName, NULL);
808 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
809 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
810 return (
PIXAC *)ERROR_PTR(
"invalid comptype", procName, NULL);
813 return (
PIXAC *)ERROR_PTR(
"sa not made", procName, NULL);
844 PROCNAME(
"pixacompCreateFromSA");
847 return (
PIXAC *)ERROR_PTR(
"sarray not defined", procName, NULL);
848 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
849 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
850 return (
PIXAC *)ERROR_PTR(
"invalid comptype", procName, NULL);
854 for (i = 0; i < n; i++) {
857 L_ERROR(
"pixc not read from file: %s\n", procName, str);
883 PROCNAME(
"pixacompDestroy");
885 if (ppixac == NULL) {
886 L_WARNING(
"ptr address is NULL!\n", procName);
890 if ((pixac = *ppixac) == NULL)
893 for (i = 0; i < pixac->
n; i++)
895 LEPT_FREE(pixac->
pixc);
927 l_int32 cmapflag, format;
930 PROCNAME(
"pixacompAddPix");
933 return ERROR_INT(
"pixac not defined", procName, 1);
935 return ERROR_INT(
"pix not defined", procName, 1);
936 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
937 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
938 return ERROR_INT(
"invalid format", procName, 1);
940 cmapflag = pixGetColormap(pix) ? 1 : 0;
943 return ERROR_INT(
"pixc not made", procName, 1);
971 PROCNAME(
"pixacompAddPixcomp");
974 return ERROR_INT(
"pixac not defined", procName, 1);
976 return ERROR_INT(
"pixc not defined", procName, 1);
978 return ERROR_INT(
"invalid copyflag", procName, 1);
983 return ERROR_INT(
"extension failed", procName, 1);
987 pixac->
pixc[n] = pixc;
1014 size_t oldsize, newsize;
1016 PROCNAME(
"pixacompExtendArray");
1019 return ERROR_INT(
"pixac not defined", procName, 1);
1020 if (pixac->
nalloc > MaxPtrArraySize)
1021 return ERROR_INT(
"pixac has too many ptrs", procName, 1);
1023 newsize = 2 * oldsize;
1024 if (newsize > 8 * MaxPtrArraySize)
1025 return ERROR_INT(
"newsize > 8 MB; too large", procName, 1);
1028 oldsize, newsize)) == NULL)
1029 return ERROR_INT(
"new ptr array not returned", procName, 1);
1062 PROCNAME(
"pixacompReplacePix");
1065 return ERROR_INT(
"pixac not defined", procName, 1);
1067 aindex = index - pixac->
offset;
1068 if (aindex < 0 || aindex >= n)
1069 return ERROR_INT(
"array index out of bounds", procName, 1);
1071 return ERROR_INT(
"pix not defined", procName, 1);
1072 if (comptype != IFF_DEFAULT && comptype != IFF_TIFF_G4 &&
1073 comptype != IFF_PNG && comptype != IFF_JFIF_JPEG)
1074 return ERROR_INT(
"invalid format", procName, 1);
1106 PROCNAME(
"pixacompReplacePixcomp");
1109 return ERROR_INT(
"pixac not defined", procName, 1);
1111 aindex = index - pixac->
offset;
1112 if (aindex < 0 || aindex >= n)
1113 return ERROR_INT(
"array index out of bounds", procName, 1);
1115 return ERROR_INT(
"pixc not defined", procName, 1);
1119 pixac->
pixc[aindex] = pixc;
1138 PROCNAME(
"pixacompAddBox");
1141 return ERROR_INT(
"pixac not defined", procName, 1);
1143 return ERROR_INT(
"box not defined", procName, 1);
1145 return ERROR_INT(
"invalid copyflag", procName, 1);
1164 PROCNAME(
"pixacompGetCount");
1167 return ERROR_INT(
"pixac not defined", procName, 0);
1196 PROCNAME(
"pixacompGetPixcomp");
1199 return (
PIXC *)ERROR_PTR(
"pixac not defined", procName, NULL);
1201 return (
PIXC *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1202 aindex = index - pixac->
offset;
1203 if (aindex < 0 || aindex >= pixac->
n)
1204 return (
PIXC *)ERROR_PTR(
"array index not valid", procName, NULL);
1207 return pixac->
pixc[aindex];
1233 PROCNAME(
"pixacompGetPix");
1236 return (
PIX *)ERROR_PTR(
"pixac not defined", procName, NULL);
1237 aindex = index - pixac->
offset;
1238 if (aindex < 0 || aindex >= pixac->
n)
1239 return (
PIX *)ERROR_PTR(
"array index not valid", procName, NULL);
1271 PROCNAME(
"pixacompGetPixDimensions");
1274 return ERROR_INT(
"pixac not defined", procName, 1);
1275 aindex = index - pixac->
offset;
1276 if (aindex < 0 || aindex >= pixac->
n)
1277 return ERROR_INT(
"array index not valid", procName, 1);
1279 if ((pixc = pixac->
pixc[aindex]) == NULL)
1280 return ERROR_INT(
"pixc not found!", procName, 1);
1297 PROCNAME(
"pixacompGetBoxa");
1300 return (
BOXA *)ERROR_PTR(
"pixac not defined", procName, NULL);
1302 return (
BOXA *)ERROR_PTR(
"boxa not defined", procName, NULL);
1305 return (
BOXA *)ERROR_PTR(
"invalid accesstype", procName, NULL);
1320 PROCNAME(
"pixacompGetBoxaCount");
1323 return ERROR_INT(
"pixac not defined", procName, 0);
1360 PROCNAME(
"pixacompGetBox");
1363 return (
BOX *)ERROR_PTR(
"pixac not defined", procName, NULL);
1365 return (
BOX *)ERROR_PTR(
"boxa not defined", procName, NULL);
1366 aindex = index - pixac->
offset;
1367 if (aindex < 0 || aindex >= pixac->
boxa->
n)
1368 return (
BOX *)ERROR_PTR(
"array index not valid", procName, NULL);
1370 return (
BOX *)ERROR_PTR(
"invalid accesstype", procName, NULL);
1372 box = pixac->
boxa->
box[aindex];
1374 if (accesstype ==
L_COPY)
1410 PROCNAME(
"pixacompGetBoxGeometry");
1413 return ERROR_INT(
"pixac not defined", procName, 1);
1414 aindex = index - pixac->
offset;
1415 if (aindex < 0 || aindex >= pixac->
n)
1416 return ERROR_INT(
"array index not valid", procName, 1);
1419 return ERROR_INT(
"box not found!", procName, 1);
1442 PROCNAME(
"pixacompGetOffset");
1445 return ERROR_INT(
"pixac not defined", procName, 0);
1468 PROCNAME(
"pixacompSetOffset");
1471 return ERROR_INT(
"pixac not defined", procName, 1);
1472 pixac->
offset = L_MAX(0, offset);
1498 l_int32 i, n, offset;
1502 PROCNAME(
"pixaCreateFromPixacomp");
1505 return (
PIXA *)ERROR_PTR(
"pixac not defined", procName, NULL);
1508 return (
PIXA *)ERROR_PTR(
"invalid accesstype", procName, NULL);
1514 return (
PIXA *)ERROR_PTR(
"pixa not made", procName, NULL);
1515 for (i = 0; i < n; i++) {
1517 L_WARNING(
"pix %d not made\n", procName, i);
1559 BOXA *boxas, *boxad;
1562 PROCNAME(
"pixacompJoin");
1565 return ERROR_INT(
"pixacd not defined", procName, 1);
1571 if (iend < 0 || iend >= n)
1574 return ERROR_INT(
"istart > iend; nothing to add", procName, 1);
1576 for (i = istart; i <= iend; i++) {
1584 iend = L_MIN(iend, nb - 1);
1585 boxaJoin(boxad, boxas, istart, iend);
1609 l_int32 i, n1, n2, n, nb1, nb2;
1611 PIXC *pixc1, *pixc2;
1614 PROCNAME(
"pixacompInterleave");
1617 return (
PIXAC *)ERROR_PTR(
"pixac1 not defined", procName, NULL);
1619 return (
PIXAC *)ERROR_PTR(
"pixac2 not defined", procName, NULL);
1624 return (
PIXAC *)ERROR_PTR(
"at least one input pixac is empty",
1627 L_WARNING(
"counts differ: %d != %d\n", procName, n1, n2);
1632 for (i = 0; i < n; i++) {
1673 PROCNAME(
"pixacompRead");
1676 return (
PIXAC *)ERROR_PTR(
"filename not defined", procName, NULL);
1679 return (
PIXAC *)ERROR_PTR(
"stream not opened", procName, NULL);
1683 return (
PIXAC *)ERROR_PTR(
"pixac not read", procName, NULL);
1704 l_int32 n, offset, i, w, h, d, ignore;
1705 l_int32 comptype, cmapflag, version, xres, yres;
1711 PROCNAME(
"pixacompReadStream");
1714 return (
PIXAC *)ERROR_PTR(
"stream not defined", procName, NULL);
1716 if (fscanf(fp,
"\nPixacomp Version %d\n", &version) != 1)
1717 return (
PIXAC *)ERROR_PTR(
"not a pixacomp file", procName, NULL);
1719 return (
PIXAC *)ERROR_PTR(
"invalid pixacomp version", procName, NULL);
1720 if (fscanf(fp,
"Number of pixcomp = %d\n", &n) != 1)
1721 return (
PIXAC *)ERROR_PTR(
"not a pixacomp file", procName, NULL);
1722 if (fscanf(fp,
"Offset of index into array = %d", &offset) != 1)
1723 return (
PIXAC *)ERROR_PTR(
"offset not read", procName, NULL);
1725 return (
PIXAC *)ERROR_PTR(
"num pixcomp ptrs < 0", procName, NULL);
1726 if (n > MaxPtrArraySize)
1727 return (
PIXAC *)ERROR_PTR(
"too many pixcomp ptrs", procName, NULL);
1728 if (n == 0) L_INFO(
"the pixacomp is empty\n", procName);
1731 return (
PIXAC *)ERROR_PTR(
"pixac not made", procName, NULL);
1734 return (
PIXAC *)ERROR_PTR(
"boxa not made", procName, NULL);
1740 for (i = 0; i < n; i++) {
1741 if (fscanf(fp,
"\nPixcomp[%d]: w = %d, h = %d, d = %d\n",
1742 &ignore, &w, &h, &d) != 4) {
1744 return (
PIXAC *)ERROR_PTR(
"dimension reading", procName, NULL);
1746 if (fscanf(fp,
" comptype = %d, size = %zu, cmapflag = %d\n",
1747 &comptype, &size, &cmapflag) != 3) {
1749 return (
PIXAC *)ERROR_PTR(
"comptype/size reading", procName, NULL);
1751 if (size > MaxDataSize) {
1753 L_ERROR(
"data size = %zu is too big", procName, size);
1762 if (fgets(buf,
sizeof(buf), fp) == NULL) {
1764 return (
PIXAC *)ERROR_PTR(
"fgets read fail", procName, NULL);
1766 if (sscanf(buf,
" xres = %d, yres = %d\n", &xres, &yres) != 2) {
1768 return (
PIXAC *)ERROR_PTR(
"read fail for res", procName, NULL);
1770 if ((data = (l_uint8 *)LEPT_CALLOC(1, size)) == NULL) {
1772 return (
PIXAC *)ERROR_PTR(
"calloc fail for data", procName, NULL);
1774 if (fread(data, 1, size, fp) != size) {
1777 return (
PIXAC *)ERROR_PTR(
"error reading data", procName, NULL);
1780 pixc = (
PIXC *)LEPT_CALLOC(1,
sizeof(
PIXC));
1815 PROCNAME(
"pixacompReadMem");
1818 return (
PIXAC *)ERROR_PTR(
"data not defined", procName, NULL);
1820 return (
PIXAC *)ERROR_PTR(
"stream not opened", procName, NULL);
1824 if (!pixac) L_ERROR(
"pixac not read\n", procName);
1850 PROCNAME(
"pixacompWrite");
1853 return ERROR_INT(
"filename not defined", procName, 1);
1855 return ERROR_INT(
"pixacomp not defined", procName, 1);
1858 return ERROR_INT(
"stream not opened", procName, 1);
1862 return ERROR_INT(
"pixacomp not written to stream", procName, 1);
1881 PROCNAME(
"pixacompWriteStream");
1884 return ERROR_INT(
"stream not defined", procName, 1);
1886 return ERROR_INT(
"pixac not defined", procName, 1);
1890 fprintf(fp,
"Number of pixcomp = %d\n", n);
1891 fprintf(fp,
"Offset of index into array = %d", pixac->
offset);
1893 for (i = 0; i < n; i++) {
1896 return ERROR_INT(
"pixc not found", procName, 1);
1897 fprintf(fp,
"\nPixcomp[%d]: w = %d, h = %d, d = %d\n",
1898 i, pixc->
w, pixc->
h, pixc->
d);
1899 fprintf(fp,
" comptype = %d, size = %zu, cmapflag = %d\n",
1901 fprintf(fp,
" xres = %d, yres = %d\n", pixc->
xres, pixc->
yres);
1902 fwrite(pixc->
data, 1, pixc->
size, fp);
1930 PROCNAME(
"pixacompWriteMem");
1932 if (pdata) *pdata = NULL;
1933 if (psize) *psize = 0;
1935 return ERROR_INT(
"&data not defined", procName, 1);
1937 return ERROR_INT(
"&size not defined", procName, 1);
1939 return ERROR_INT(
"&pixac not defined", procName, 1);
1942 if ((fp = open_memstream((
char **)pdata, psize)) == NULL)
1943 return ERROR_INT(
"stream not opened", procName, 1);
1947 *psize = *psize - 1;
1949 L_INFO(
"work-around: writing to a temp file\n", procName);
1952 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
1954 if ((fp = tmpfile()) == NULL)
1955 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
2004 l_float32 scalefactor,
2008 const char *fileout)
2014 PROCNAME(
"pixacompConvertToPdf");
2017 return ERROR_INT(
"pixac not defined", procName, 1);
2020 title, &data, &nbytes);
2023 return ERROR_INT(
"conversion to pdf failed", procName, 1);
2029 L_ERROR(
"pdf data not written to file\n", procName);
2057 l_float32 scalefactor,
2065 l_int32 i, n, ret, scaledres, pagetype;
2071 PROCNAME(
"pixacompConvertToPdfData");
2074 return ERROR_INT(
"&data not defined", procName, 1);
2077 return ERROR_INT(
"&nbytes not defined", procName, 1);
2080 return ERROR_INT(
"pixac not defined", procName, 1);
2081 if (scalefactor <= 0.0) scalefactor = 1.0;
2085 L_WARNING(
"invalid compression type; using per-page default\n",
2093 for (i = 0; i < n; i++) {
2096 L_ERROR(
"pix[%d] not retrieved\n", procName, i);
2099 if (pixGetWidth(pixs) == 1) {
2100 L_INFO(
"placeholder image[%d] has w = 1\n", procName, i);
2104 if (scalefactor != 1.0)
2105 pix =
pixScale(pixs, scalefactor, scalefactor);
2109 scaledres = (l_int32)(res * scalefactor);
2115 L_ERROR(
"encoding type selection failed for pix[%d]\n",
2122 0, 0, scaledres, title, NULL, 0);
2125 L_ERROR(
"pdf encoding failed for pix[%d]\n", procName, i);
2134 L_ERROR(
"no pdf files made\n", procName);
2143 for (i = 0; i < n; i++) {
2177 l_int32 i, n, ret, comptype;
2183 PROCNAME(
"pixacompFastConvertToPdfData");
2186 return ERROR_INT(
"&data not defined", procName, 1);
2189 return ERROR_INT(
"&nbytes not defined", procName, 1);
2192 return ERROR_INT(
"pixac not defined", procName, 1);
2197 for (i = 0; i < n; i++) {
2199 L_ERROR(
"pixc[%d] not retrieved\n", procName, i);
2203 if (comptype != IFF_JFIF_JPEG) {
2204 L_ERROR(
"pixc[%d] not jpeg compressed\n", procName, i);
2209 L_ERROR(
"pdf encoding failed for pixc[%d]\n", procName, i);
2218 L_ERROR(
"no pdf files made\n", procName);
2228 for (i = 0; i < n; i++) {
2264 PROCNAME(
"pixacompFastConvertToPdfData");
2267 return ERROR_INT(
"&data not defined", procName, 1);
2270 return ERROR_INT(
"&nbytes not defined", procName, 1);
2273 return ERROR_INT(
"pixc not defined", procName, 1);
2300 l_int32 i, n, nboxes;
2303 PROCNAME(
"pixacompWriteStreamInfo");
2306 return ERROR_INT(
"fp not defined", procName, 1);
2308 return ERROR_INT(
"pixac not defined", procName, 1);
2311 fprintf(fp,
"Pixacomp Info for %s:\n", text);
2313 fprintf(fp,
"Pixacomp Info:\n");
2316 fprintf(fp,
"Number of pixcomp: %d\n", n);
2317 fprintf(fp,
"Size of pixcomp array alloc: %d\n", pixac->
nalloc);
2318 fprintf(fp,
"Offset of index into array: %d\n", pixac->
offset);
2320 fprintf(fp,
"Boxa has %d boxes\n", nboxes);
2322 fprintf(fp,
"Boxa is empty\n");
2323 for (i = 0; i < n; i++) {
2344 PROCNAME(
"pixcompWriteStreamInfo");
2347 return ERROR_INT(
"fp not defined", procName, 1);
2349 return ERROR_INT(
"pixc not defined", procName, 1);
2352 fprintf(fp,
" Pixcomp Info for %s:", text);
2354 fprintf(fp,
" Pixcomp Info:");
2355 fprintf(fp,
" width = %d, height = %d, depth = %d\n",
2356 pixc->
w, pixc->
h, pixc->
d);
2357 fprintf(fp,
" xres = %d, yres = %d, size in bytes = %zu\n",
2360 fprintf(fp,
" has colormap\n");
2362 fprintf(fp,
" no colormap\n");
2363 if (pixc->
comptype < NumImageFileFormatExtensions) {
2364 fprintf(fp,
" comptype = %s (%d)\n",
2367 fprintf(fp,
" Error!! Invalid comptype index: %d\n", pixc->
comptype);
2407 PROCNAME(
"pixacompDisplayTiledAndScaled");
2410 return (
PIX *)ERROR_PTR(
"pixac not defined", procName, NULL);
2413 return (
PIX *)ERROR_PTR(
"pixa not made", procName, NULL);
2416 background, spacing, border);
2437 PROCNAME(
"pixacompWriteFiles");
2440 return ERROR_INT(
"pixac not defined", procName, 1);
2443 return ERROR_INT(
"invalid subdir", procName, 1);
2446 for (i = 0; i < n; i++) {
2448 snprintf(buf,
sizeof(buf),
"/tmp/%s/%03d", subdir, i);
2454 extern const char *ImageFileFormatExtensions[];
2475 PROCNAME(
"pixcompWriteFile");
2478 return ERROR_INT(
"pixc not defined", procName, 1);
2480 snprintf(buf,
sizeof(buf),
"%s.%s", rootname,
2481 ImageFileFormatExtensions[pixc->
comptype]);
BOXA * boxaReadStream(FILE *fp)
boxaReadStream()
BOXA * boxaCopy(BOXA *boxa, l_int32 copyflag)
boxaCopy()
void boxDestroy(BOX **pbox)
boxDestroy()
BOX * boxClone(BOX *box)
boxClone()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
l_ok boxaExtendArray(BOXA *boxa)
boxaExtendArray()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
BOX * boxCopy(BOX *box)
boxCopy()
BOXA * boxaCreate(l_int32 n)
boxaCreate()
l_ok boxaWriteStream(FILE *fp, BOXA *boxa)
boxaWriteStream()
l_ok boxaJoin(BOXA *boxad, BOXA *boxas, l_int32 istart, l_int32 iend)
boxaJoin()
void l_byteaDestroy(L_BYTEA **pba)
l_byteaDestroy()
L_BYTEA * l_byteaInitFromMem(const l_uint8 *data, size_t size)
l_byteaInitFromMem()
l_ok selectDefaultPdfEncoding(PIX *pix, l_int32 *ptype)
selectDefaultPdfEncoding()
L_COMP_DATA * l_generateJpegDataMem(l_uint8 *data, size_t nbytes, l_int32 ascii85flag)
l_generateJpegDataMem()
l_ok pixConvertToPdfData(PIX *pix, l_int32 type, l_int32 quality, l_uint8 **pdata, size_t *pnbytes, l_int32 x, l_int32 y, l_int32 res, const char *title, L_PDF_DATA **plpd, l_int32 position)
pixConvertToPdfData()
l_ok ptraConcatenatePdfToData(L_PTRA *pa_data, SARRAY *sa, l_uint8 **pdata, size_t *pnbytes)
ptraConcatenatePdfToData()
l_ok cidConvertToPdfData(L_COMP_DATA *cid, const char *title, l_uint8 **pdata, size_t *pnbytes)
cidConvertToPdfData()
l_ok pixSetResolution(PIX *pix, l_int32 xres, l_int32 yres)
pixSetResolution()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
char * pixGetText(PIX *pix)
pixGetText()
l_ok pixSetText(PIX *pix, const char *textstring)
pixSetText()
l_ok pixGetResolution(const PIX *pix, l_int32 *pxres, l_int32 *pyres)
pixGetResolution()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
#define PIXACOMP_VERSION_NUMBER
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
BOXA * pixaGetBoxa(PIXA *pixa, l_int32 accesstype)
pixaGetBoxa()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
PIX * pixaDisplayTiledAndScaled(PIXA *pixa, l_int32 outdepth, l_int32 tilewidth, l_int32 ncols, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledAndScaled()
l_ok pixacompJoin(PIXAC *pixacd, PIXAC *pixacs, l_int32 istart, l_int32 iend)
pixacompJoin()
PIXC * pixcompCreateFromPix(PIX *pix, l_int32 comptype)
pixcompCreateFromPix()
PIXAC * pixacompReadStream(FILE *fp)
pixacompReadStream()
PIXAC * pixacompCreateFromPixa(PIXA *pixa, l_int32 comptype, l_int32 accesstype)
pixacompCreateFromPixa()
void pixacompDestroy(PIXAC **ppixac)
pixacompDestroy()
l_ok pixacompFastConvertToPdfData(PIXAC *pixac, const char *title, l_uint8 **pdata, size_t *pnbytes)
pixacompFastConvertToPdfData()
l_ok pixacompWriteStream(FILE *fp, PIXAC *pixac)
pixacompWriteStream()
PIXAC * pixacompCreateFromSA(SARRAY *sa, l_int32 comptype)
pixacompCreateFromSA()
l_ok pixacompWrite(const char *filename, PIXAC *pixac)
pixacompWrite()
void pixcompDestroy(PIXC **ppixc)
pixcompDestroy()
PIXA * pixaCreateFromPixacomp(PIXAC *pixac, l_int32 accesstype)
pixaCreateFromPixacomp()
l_ok pixacompWriteMem(l_uint8 **pdata, size_t *psize, PIXAC *pixac)
pixacompWriteMem()
PIXAC * pixacompRead(const char *filename)
pixacompRead()
static const l_int32 InitialPtrArraySize
PIXAC * pixacompReadMem(const l_uint8 *data, size_t size)
pixacompReadMem()
PIXAC * pixacompCreateWithInit(l_int32 n, l_int32 offset, PIX *pix, l_int32 comptype)
pixacompCreateWithInit()
l_ok pixacompConvertToPdfData(PIXAC *pixac, l_int32 res, l_float32 scalefactor, l_int32 type, l_int32 quality, const char *title, l_uint8 **pdata, size_t *pnbytes)
pixacompConvertToPdfData()
PIXC * pixacompGetPixcomp(PIXAC *pixac, l_int32 index, l_int32 copyflag)
pixacompGetPixcomp()
PIXAC * pixacompCreateFromFiles(const char *dirname, const char *substr, l_int32 comptype)
pixacompCreateFromFiles()
PIX * pixacompDisplayTiledAndScaled(PIXAC *pixac, l_int32 outdepth, l_int32 tilewidth, l_int32 ncols, l_int32 background, l_int32 spacing, l_int32 border)
pixacompDisplayTiledAndScaled()
l_int32 pixacompGetBoxaCount(PIXAC *pixac)
pixacompGetBoxaCount()
l_ok pixcompGetParameters(PIXC *pixc, l_int32 *pxres, l_int32 *pyres, l_int32 *pcomptype, l_int32 *pcmapflag)
pixcompGetParameters()
l_ok pixcompWriteFile(const char *rootname, PIXC *pixc)
pixcompWriteFile()
l_ok pixacompReplacePix(PIXAC *pixac, l_int32 index, PIX *pix, l_int32 comptype)
pixacompReplacePix()
PIXAC * pixacompCreate(l_int32 n)
pixacompCreate()
static l_int32 pixacompExtendArray(PIXAC *pixac)
pixacompExtendArray()
l_ok pixcompGetDimensions(PIXC *pixc, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixcompGetDimensions()
l_ok pixacompConvertToPdf(PIXAC *pixac, l_int32 res, l_float32 scalefactor, l_int32 type, l_int32 quality, const char *title, const char *fileout)
pixacompConvertToPdf()
BOX * pixacompGetBox(PIXAC *pixac, l_int32 index, l_int32 accesstype)
pixacompGetBox()
PIXC * pixcompCreateFromString(l_uint8 *data, size_t size, l_int32 copyflag)
pixcompCreateFromString()
PIXC * pixcompCopy(PIXC *pixcs)
pixcompCopy()
l_ok pixacompSetOffset(PIXAC *pixac, l_int32 offset)
pixacompSetOffset()
static l_int32 pixcompFastConvertToPdfData(PIXC *pixc, const char *title, l_uint8 **pdata, size_t *pnbytes)
pixcompFastConvertToPdfData()
PIXAC * pixacompInterleave(PIXAC *pixac1, PIXAC *pixac2)
pixacompInterleave()
l_ok pixacompWriteStreamInfo(FILE *fp, PIXAC *pixac, const char *text)
pixacompWriteStreamInfo()
PIXC * pixcompCreateFromFile(const char *filename, l_int32 comptype)
pixcompCreateFromFile()
l_ok pixacompGetBoxGeometry(PIXAC *pixac, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
pixacompGetBoxGeometry()
l_int32 pixacompGetOffset(PIXAC *pixac)
pixacompGetOffset()
l_int32 pixacompGetCount(PIXAC *pixac)
pixacompGetCount()
l_ok pixacompAddPix(PIXAC *pixac, PIX *pix, l_int32 comptype)
pixacompAddPix()
l_ok pixacompAddBox(PIXAC *pixac, BOX *box, l_int32 copyflag)
pixacompAddBox()
l_ok pixacompAddPixcomp(PIXAC *pixac, PIXC *pixc, l_int32 copyflag)
pixacompAddPixcomp()
l_ok pixcompDetermineFormat(l_int32 comptype, l_int32 d, l_int32 cmapflag, l_int32 *pformat)
pixcompDetermineFormat()
PIX * pixacompGetPix(PIXAC *pixac, l_int32 index)
pixacompGetPix()
l_ok pixacompWriteFiles(PIXAC *pixac, const char *subdir)
pixacompWriteFiles()
BOXA * pixacompGetBoxa(PIXAC *pixac, l_int32 accesstype)
pixacompGetBoxa()
PIX * pixCreateFromPixcomp(PIXC *pixc)
pixCreateFromPixcomp()
l_ok pixcompWriteStreamInfo(FILE *fp, PIXC *pixc, const char *text)
pixcompWriteStreamInfo()
l_ok pixacompReplacePixcomp(PIXAC *pixac, l_int32 index, PIXC *pixc)
pixacompReplacePixcomp()
l_ok pixacompGetPixDimensions(PIXAC *pixac, l_int32 index, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixacompGetPixDimensions()
L_PTRA * ptraCreate(l_int32 n)
ptraCreate()
l_ok ptraGetActualCount(L_PTRA *pa, l_int32 *pcount)
ptraGetActualCount()
l_ok ptraAdd(L_PTRA *pa, void *item)
ptraAdd()
void ptraDestroy(L_PTRA **ppa, l_int32 freeflag, l_int32 warnflag)
ptraDestroy()
void * ptraRemove(L_PTRA *pa, l_int32 index, l_int32 flag)
ptraRemove()
l_ok findFileFormat(const char *filename, l_int32 *pformat)
findFileFormat()
PIX * pixReadMem(const l_uint8 *data, size_t size)
pixReadMem()
PIX * pixRead(const char *filename)
pixRead()
l_ok pixReadHeaderMem(const l_uint8 *data, size_t size, l_int32 *pformat, l_int32 *pw, l_int32 *ph, l_int32 *pbps, l_int32 *pspp, l_int32 *piscmap)
pixReadHeaderMem()
char * sarrayGetString(SARRAY *sa, l_int32 index, l_int32 copyflag)
sarrayGetString()
l_int32 sarrayGetCount(SARRAY *sa)
sarrayGetCount()
void sarrayDestroy(SARRAY **psa)
sarrayDestroy()
SARRAY * getSortedPathnamesInDirectory(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
getSortedPathnamesInDirectory()
PIX * pixScale(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScale()
char * stringNew(const char *src)
stringNew()
l_uint8 * l_binaryReadStream(FILE *fp, size_t *pnbytes)
l_binaryReadStream()
FILE * fopenReadFromMemory(const l_uint8 *data, size_t size)
fopenReadFromMemory()
FILE * fopenWriteStream(const char *filename, const char *modestring)
fopenWriteStream()
l_int32 lept_mkdir(const char *subdir)
lept_mkdir()
l_ok l_binaryWrite(const char *filename, const char *operation, const void *data, size_t nbytes)
l_binaryWrite()
void * reallocNew(void **pindata, size_t oldsize, size_t newsize)
reallocNew()
FILE * fopenWriteWinTempfile(void)
fopenWriteWinTempfile()
FILE * fopenReadStream(const char *filename)
fopenReadStream()
l_uint8 * l_binaryCopy(const l_uint8 *datas, size_t size)
l_binaryCopy()
l_uint8 * l_binaryRead(const char *filename, size_t *pnbytes)
l_binaryRead()