static void
GetImageMask(PIX *pixs,
l_int32 res,
BOXA **pboxa,
const char *debugfile)
{
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
pixSetResolution(pixs, 200, 200);
pix1 = pixConvertTo1(pixs, 100);
pix2 = pixGenerateHalftoneMask(pix1, NULL, NULL, NULL);
pix3 = pixMorphSequence(pix2, "c20.1 + c1.20", 0);
*pboxa = pixConnComp(pix3, NULL, 8);
if (debugfile) {
pixa = pixaCreate(0);
pixaAddPix(pixa, pixs, L_COPY);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pix4 = pixaDisplayTiledInRows(pixa, 32, 1800, 0.25, 0, 25, 2);
pixWrite(debugfile, pix4, IFF_JFIF_JPEG);
pixDisplay(pix4, 100, 100);
pixDestroy(&pix4);
pixaDestroy(&pixa);
} else {
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
return;
}
void MainWindow::on_actionChange_resolution_triggered() {
DPIDialog dpi_dialog(this, pixs->xres, pixs->yres);
if (dpi_dialog.exec() == QDialog::Accepted) {
int x_dpi = dpi_dialog.xDPI->value();
int y_dpi = dpi_dialog.yDPI->value();
if (x_dpi != pixs->xres || y_dpi != pixs->yres) {
modified = true;
pixSetResolution(pixs, x_dpi, y_dpi);
updateTitle();
}
}
}
Pix* upscale(Pix* pix) {
l_int32 pixPixelCount = pixGetWidth(pix)* pixGetHeight(pix);
const l_int32 MIN_PIXEL_COUNT = 3 * 1024*1024;
if (pixPixelCount < MIN_PIXEL_COUNT) {
l_float32 scale = ((double) MIN_PIXEL_COUNT) / pixPixelCount;
scale = sqrt(scale);
Pix* scaled = pixScale(pix, scale,scale);
l_int32 xres, yres;
pixGetResolution(pix, &xres, &yres);
pixSetResolution(scaled, 600, 600);
return scaled;
}
return pixClone(pix);
}
void setResolutionBasedOnTextSize(Pix* pix, l_float32 textLineHeight){
FUNCNAME("setResolutionBasedOnTextSize");
l_uint32 res;
//12pt at 300dpi is roughly 48px
//since font size is unknown we assume 12pt font
//48*x = 300. x = 6.25
if(textLineHeight==0){
l_int32 size = pixGetWidth(pix)*pixGetHeight(pix);
//1mil==100, 3mill==300
res = L_MIN(75, L_MAX(300, size/1000));
} else {
res = L_MIN(600, 6.25 * textLineHeight);
}
L_INFO("text line height = %.2f, dpi = %i\n", procName, textLineHeight, res);
pixSetResolution(pix, res, res);
}
int main(int argc,
char **argv)
{
char buffer[512];
char *tempfile1, *tempfile2;
l_uint8 *data;
l_int32 i, j, w, h, seq, ret, same;
size_t nbytes;
const char *title;
BOX *box;
BOXA *boxa1, *boxa2;
L_BYTEA *ba;
L_PDF_DATA *lpd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixt, *pixg, *pixgc, *pixc;
static char mainName[] = "pdfiotest";
if (argc != 1)
return ERROR_INT("syntax: pdfiotest", mainName, 1);
l_pdfSetDateAndVersion(0);
lept_mkdir("lept/pdf");
#if 1
/* --------------- Single image tests ------------------- */
fprintf(stderr, "\n*** Writing single images as pdf files\n");
convertToPdf("weasel2.4c.png", L_FLATE_ENCODE, 0, "/tmp/lept/pdf/file01.pdf",
0, 0, 72, "weasel2.4c.png", NULL, 0);
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "/tmp/lept/pdf/file02.pdf",
0, 0, 72, "test24.jpg", NULL, 0);
convertToPdf("feyn.tif", L_G4_ENCODE, 0, "/tmp/lept/pdf/file03.pdf",
0, 0, 300, "feyn.tif", NULL, 0);
pixs = pixRead("feyn.tif");
pixConvertToPdf(pixs, L_G4_ENCODE, 0, "/tmp/lept/pdf/file04.pdf", 0, 0, 300,
"feyn.tif", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("test24.jpg");
pixConvertToPdf(pixs, L_JPEG_ENCODE, 5, "/tmp/lept/pdf/file05.pdf",
0, 0, 72, "test24.jpg", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("feyn.tif");
pixt = pixScaleToGray2(pixs);
pixWrite("/tmp/lept/pdf/feyn8.png", pixt, IFF_PNG);
convertToPdf("/tmp/lept/pdf/feyn8.png", L_JPEG_ENCODE, 0,
"/tmp/lept/pdf/file06.pdf", 0, 0, 150, "feyn8.png", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixt);
convertToPdf("weasel4.16g.png", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file07.pdf", 0, 0, 30,
"weasel4.16g.png", NULL, 0);
pixs = pixRead("test24.jpg");
pixg = pixConvertTo8(pixs, 0);
box = boxCreate(100, 100, 100, 100);
pixc = pixClipRectangle(pixs, box, NULL);
pixgc = pixClipRectangle(pixg, box, NULL);
pixWrite("/tmp/lept/pdf/pix32.jpg", pixc, IFF_JFIF_JPEG);
pixWrite("/tmp/lept/pdf/pix8.jpg", pixgc, IFF_JFIF_JPEG);
convertToPdf("/tmp/lept/pdf/pix32.jpg", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file08.pdf", 0, 0, 72, "pix32.jpg", NULL, 0);
convertToPdf("/tmp/lept/pdf/pix8.jpg", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file09.pdf", 0, 0, 72, "pix8.jpg", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixc);
pixDestroy(&pixgc);
boxDestroy(&box);
#endif
#if 1
/* --------------- Multiple image tests ------------------- */
fprintf(stderr, "\n*** Writing multiple images as single page pdf files\n");
pix1 = pixRead("feyn-fract.tif");
pix2 = pixRead("weasel8.240c.png");
/* l_pdfSetDateAndVersion(0); */
/* First, write the 1 bpp image through the mask onto the weasels */
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/lept/pdf/file10.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
/* Now, write the 1 bpp image over the weasels */
l_pdfSetG4ImageMask(0);
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/lept/pdf/file11.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
l_pdfSetG4ImageMask(1);
pixDestroy(&pix1);
pixDestroy(&pix2);
#endif
#if 1
/* -------- pdf convert segmented with no image regions -------- */
fprintf(stderr, "\n*** Writing segmented images without image regions\n");
pix1 = pixRead("rabi.png");
pix2 = pixScaleToGray2(pix1);
pixWrite("/tmp/lept/pdf/rabi8.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixThresholdTo4bpp(pix2, 16, 1);
pixWrite("/tmp/lept/pdf/rabi4.png", pix3, IFF_PNG);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file12.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file13.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file14.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file15.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file16.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file17.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file18.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file19.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file20.pdf");
#endif
#if 1
/* ---------- pdf convert segmented with image regions ---------- */
fprintf(stderr, "\n*** Writing segmented images with image regions\n");
/* Get the image region(s) for rabi.png. There are two
* small bogus regions at the top, but we'll keep them for
* the demonstration. */
pix1 = pixRead("rabi.png");
pixSetResolution(pix1, 300, 300);
pixGetDimensions(pix1, &w, &h, NULL);
pix2 = pixGenerateHalftoneMask(pix1, NULL, NULL, NULL);
pix3 = pixMorphSequence(pix2, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file21.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file22.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file23.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file24.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file25.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file26.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file27.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file28.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file29.pdf");
/* 4 bpp input, cmap, data output */
data = NULL;
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file30.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file31.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file32.pdf", "w", data, nbytes);
lept_free(data);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* -------- pdf convert segmented from color image -------- */
fprintf(stderr, "\n*** Writing color segmented images\n");
pix1 = pixRead("candelabrum.011.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/lept/pdf/candelabrum3.jpg", pix2, IFF_JFIF_JPEG);
GetImageMask(pix2, 200, &boxa1, "/tmp/lept/pdf/seg1.jpg");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_G4_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file33.pdf");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_JPEG_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file34.pdf");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_FLATE_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file35.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/lept/pdf/lion16.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixRead("lion-mask.00016.tif");
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 3.0, 3.0);
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_G4_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file36.pdf");
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_JPEG_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file37.pdf");
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file38.pdf");
/* Quantize the non-image part and flate encode.
* This is useful because it results in a smaller file than
* when you flate-encode the un-quantized non-image regions. */
pix4 = pixScale(pix3, 3.0, 3.0); /* higher res mask, for combining */
pix5 = QuantizeNonImageRegion(pix2, pix4, 12);
pixWrite("/tmp/lept/pdf/lion16-quant.png", pix5, IFF_PNG);
convertToPdfSegmented("/tmp/lept/pdf/lion16-quant.png", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file39.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* ------------------ Test multipage pdf generation ----------------- */
fprintf(stderr, "\n*** Writing multipage pdfs from single page pdfs\n");
/* Generate a multi-page pdf from all these files */
startTimer();
concatenatePdf("/tmp/lept/pdf", "file", "/tmp/lept/pdf/cat_lept.pdf");
fprintf(stderr,
"All files have been concatenated: /tmp/lept/pdf/cat_lept.pdf\n"
"Concatenation time: %7.3f\n", stopTimer());
#endif
#if 1
/* ----------- Test corruption recovery by concatenation ------------ */
/* Put two good pdf files in a directory */
lept_rmdir("lept/good");
lept_mkdir("lept/good");
lept_cp("testfile1.pdf", "lept/good", NULL, NULL);
lept_cp("testfile2.pdf", "lept/good", NULL, NULL);
concatenatePdf("/tmp/lept/good", "file", "/tmp/lept/pdf/good.pdf");
/* Make a bad version with the pdf id removed, so that it is not
* recognized as a pdf */
lept_rmdir("lept/bad");
lept_mkdir("lept/bad");
ba = l_byteaInitFromFile("testfile2.pdf");
data = l_byteaGetData(ba, &nbytes);
l_binaryWrite("/tmp/lept/bad/testfile0.notpdf.pdf", "w",
data + 10, nbytes - 10);
/* Make a version with a corrupted trailer */
if (data)
data[2297] = '2'; /* munge trailer object 6: change 458 --> 428 */
l_binaryWrite("/tmp/lept/bad/testfile2.bad.pdf", "w", data, nbytes);
l_byteaDestroy(&ba);
/* Copy testfile1.pdf to the /tmp/lept/bad directory. Then
* run concat on the bad files. The "not pdf" file should be
* ignored, and the corrupted pdf file should be properly parsed,
* so the resulting concatenated pdf files should be identical. */
fprintf(stderr, "\nWe attempt to build from the bad directory\n");
lept_cp("testfile1.pdf", "lept/bad", NULL, NULL);
concatenatePdf("/tmp/lept/bad", "file", "/tmp/lept/pdf/bad.pdf");
filesAreIdentical("/tmp/lept/pdf/good.pdf", "/tmp/lept/pdf/bad.pdf", &same);
if (same)
fprintf(stderr, "Fixed: files are the same\n"
"Attempt succeeded\n");
else
fprintf(stderr, "Busted: files are different\n");
#endif
#if 0
fprintf(stderr, "\n*** pdftk writes multipage pdfs from images\n");
tempfile1 = genPathname("/tmp/lept/pdf", "file*.pdf");
tempfile2 = genPathname("/tmp/lept/pdf", "cat_pdftk.pdf");
snprintf(buffer, sizeof(buffer), "pdftk %s output %s",
tempfile1, tempfile2);
ret = system(buffer); /* pdftk */
lept_free(tempfile1);
lept_free(tempfile2);
#endif
#if 1
/* -- Test simple interface for generating multi-page pdf from images -- */
fprintf(stderr, "\n*** Writing multipage pdfs from images\n");
/* Put four image files in a directory. They will be encoded thus:
* file1.png: flate (8 bpp, only 10 colors)
* file2.jpg: dct (8 bpp, 256 colors because of the jpeg encoding)
* file3.tif: g4 (1 bpp)
* file4.jpg: dct (32 bpp) */
lept_mkdir("lept/image");
pix1 = pixRead("feyn.tif");
pix2 = pixRead("rabi.png");
pix3 = pixScaleToGray3(pix1);
pix4 = pixScaleToGray3(pix2);
pix5 = pixScale(pix1, 0.33, 0.33);
pix6 = pixRead("test24.jpg");
pixWrite("/tmp/lept/image/file1.png", pix3, IFF_PNG); /* 10 colors */
pixWrite("/tmp/lept/image/file2.jpg", pix4, IFF_JFIF_JPEG); /* 256 colors */
pixWrite("/tmp/lept/image/file3.tif", pix5, IFF_TIFF_G4);
pixWrite("/tmp/lept/image/file4.jpg", pix6, IFF_JFIF_JPEG);
startTimer();
convertFilesToPdf("/tmp/lept/image", "file", 100, 0.8, 0, 75, "4 file test",
"/tmp/lept/pdf/fourimages.pdf");
fprintf(stderr, "4-page pdf generated: /tmp/lept/pdf/fourimages.pdf\n"
"Time: %7.3f\n", stopTimer());
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
#endif
return 0;
}
/*!
* pixReadStreamJp2k()
*
* Input: stream
* reduction (scaling factor: 1, 2, 4, 8)
* box (<optional> for extracting a subregion), can be null
* hint (a bitwise OR of L_JP2K_* values; 0 for default)
* debug (output callback messages, etc)
* Return: pix (8 or 32 bpp), or null on error
*
* Notes:
* (1) See pixReadJp2k() for usage.
*/
PIX *
pixReadStreamJp2k(FILE *fp,
l_uint32 reduction,
BOX *box,
l_int32 hint,
l_int32 debug)
{
const char *opjVersion;
l_int32 i, j, index, bx, by, bw, bh, val, rval, gval, bval, aval;
l_int32 w, h, wpl, bps, spp, xres, yres, reduce, prec, colorspace;
l_uint32 pixel;
l_uint32 *data, *line;
opj_dparameters_t parameters; /* decompression parameters */
opj_image_t *image = NULL;
opj_codec_t *l_codec = NULL; /* handle to decompressor */
opj_stream_t *l_stream = NULL; /* opj stream */
PIX *pix = NULL;
PROCNAME("pixReadStreamJp2k");
if (!fp)
return (PIX *)ERROR_PTR("fp not defined", procName, NULL);
opjVersion = opj_version();
if (opjVersion[0] != '2') {
L_ERROR("version is %s; must be 2.0 or higher\n", procName, opjVersion);
return NULL;
}
if ((opjVersion[2] - 0x30) != OPJ_VERSION_MINOR) {
L_ERROR("version %s: differs from minor = %d\n",
procName, opjVersion, OPJ_VERSION_MINOR);
return NULL;
}
/* Get the resolution and the bits/sample */
rewind(fp);
fgetJp2kResolution(fp, &xres, &yres);
freadHeaderJp2k(fp, NULL, NULL, &bps, NULL);
rewind(fp);
if (bps > 8) {
L_ERROR("found %d bps; can only handle 8 bps\n", procName, bps);
return NULL;
}
/* Set decoding parameters to default values */
opj_set_default_decoder_parameters(¶meters);
/* Find and set the reduce parameter, which is log2(reduction).
* Valid reductions are powers of 2, and are determined when the
* compressed string is made. A request for an invalid reduction
* will cause an error in opj_read_header(), and no image will
* be returned. */
for (reduce = 0; (1L << reduce) < reduction; reduce++) { }
if ((1L << reduce) != reduction) {
L_ERROR("invalid reduction %d; not power of 2\n", procName, reduction);
return NULL;
}
parameters.cp_reduce = reduce;
/* Open decompression 'stream'. In 2.0, we could call this:
* opj_stream_create_default_file_stream(fp, 1)
* but the file stream interface was removed in 2.1. */
if ((l_stream = opjCreateStream(fp, 1)) == NULL) {
L_ERROR("failed to open the stream\n", procName);
return NULL;
}
if ((l_codec = opj_create_decompress(OPJ_CODEC_JP2)) == NULL) {
L_ERROR("failed to make the codec\n", procName);
opj_stream_destroy(l_stream);
return NULL;
}
/* Catch and report events using callbacks */
if (debug) {
opj_set_info_handler(l_codec, info_callback, NULL);
opj_set_warning_handler(l_codec, warning_callback, NULL);
opj_set_error_handler(l_codec, error_callback, NULL);
}
/* Setup the decoding parameters using user parameters */
if (!opj_setup_decoder(l_codec, ¶meters)){
L_ERROR("failed to set up decoder\n", procName);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
return NULL;
}
/* Read the main header of the codestream and, if necessary,
* the JP2 boxes */
if(!opj_read_header(l_stream, l_codec, &image)){
L_ERROR("failed to read the header\n", procName);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return NULL;
}
/* Set up to decode a rectangular region */
if (box) {
boxGetGeometry(box, &bx, &by, &bw, &bh);
if (!opj_set_decode_area(l_codec, image, bx, by,
bx + bw, by + bh)) {
L_ERROR("failed to set the region for decoding\n", procName);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return NULL;
}
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) &&
opj_end_decompress(l_codec, l_stream))) {
L_ERROR("failed to decode the image\n", procName);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return NULL;
}
/* Close the byte stream */
opj_stream_destroy(l_stream);
/* Get the image parameters */
spp = image->numcomps;
w = image->comps[0].w;
h = image->comps[0].h;
prec = image->comps[0].prec;
if (prec != bps)
L_WARNING("precision %d != bps %d!\n", procName, prec, bps);
if (debug) {
L_INFO("w = %d, h = %d, bps = %d, spp = %d\n",
procName, w, h, bps, spp);
colorspace = image->color_space;
if (colorspace == OPJ_CLRSPC_SRGB)
L_INFO("colorspace is sRGB\n", procName);
else if (colorspace == OPJ_CLRSPC_GRAY)
L_INFO("colorspace is grayscale\n", procName);
else if (colorspace == OPJ_CLRSPC_SYCC)
L_INFO("colorspace is YUV\n", procName);
}
/* Free the codec structure */
if (l_codec)
opj_destroy_codec(l_codec);
/* Convert the image to a pix */
if (spp == 1)
pix = pixCreate(w, h, 8);
else
pix = pixCreate(w, h, 32);
pixSetResolution(pix, xres, yres);
data = pixGetData(pix);
wpl = pixGetWpl(pix);
index = 0;
if (spp == 1) {
for (i = 0; i < h; i++) {
line = data + i * wpl;
for (j = 0; j < w; j++) {
val = image->comps[0].data[index];
SET_DATA_BYTE(line, j, val);
index++;
}
}
} else if (spp == 2) { /* convert to RGBA */
for (i = 0; i < h; i++) {
line = data + i * wpl;
for (j = 0; j < w; j++) {
val = image->comps[0].data[index];
aval = image->comps[1].data[index];
composeRGBAPixel(val, val, val, aval, &pixel);
line[j] = pixel;
index++;
}
}
} else if (spp >= 3) {
for (i = 0; i < h; i++) {
line = data + i * wpl;
for (j = 0; j < w; j++) {
rval = image->comps[0].data[index];
gval = image->comps[1].data[index];
bval = image->comps[2].data[index];
if (spp == 3) {
composeRGBPixel(rval, gval, bval, &pixel);
} else { /* spp == 4 */
aval = image->comps[3].data[index];
composeRGBAPixel(rval, gval, bval, aval, &pixel);
}
line[j] = pixel;
index++;
}
}
}
/* Free the opj image data structure */
opj_image_destroy(image);
return pix;
}
