forked from enlightenment/efl
354 lines
8.5 KiB
C++
354 lines
8.5 KiB
C++
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <sys/mman.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <libgen.h>
|
|
|
|
#include <GlobalParams.h>
|
|
#include <PDFDoc.h>
|
|
#include <ErrorCodes.h>
|
|
#include <Page.h>
|
|
#include <SplashOutputDev.h>
|
|
#include <splash/SplashBitmap.h>
|
|
|
|
#include <Eina.h>
|
|
|
|
#include "shmfile.h"
|
|
#include "timeout.h"
|
|
|
|
#define DATA32 unsigned int
|
|
|
|
//#define PDF_DBG
|
|
|
|
#ifdef PDF_DBG
|
|
#define D(fmt, args...) fprintf(stderr, fmt, ## args)
|
|
#else
|
|
#define D(fmt, args...)
|
|
#endif
|
|
|
|
|
|
PDFDoc *pdfdoc;
|
|
bool locked = false;
|
|
|
|
::Page *page;
|
|
int width = 0, height = 0;
|
|
int crop_width = 0, crop_height = 0;
|
|
void *data = NULL;
|
|
double dpi = -1.0;
|
|
|
|
#define DEF_DPI 72.0
|
|
|
|
Eina_Bool poppler_init(const char *file, int page_nbr, int size_w, int size_h)
|
|
{
|
|
Object obj;
|
|
double w, h, cw, ch;
|
|
int rot;
|
|
|
|
if (!file || !*file)
|
|
return EINA_FALSE;
|
|
|
|
if (page_nbr < 0)
|
|
return EINA_FALSE;
|
|
|
|
if (!(globalParams = new GlobalParams()))
|
|
return EINA_FALSE;
|
|
|
|
if (!eina_init())
|
|
goto del_global_param;
|
|
|
|
#ifndef HAVE_POPPLER_031
|
|
if (globalParams->getAntialias())
|
|
globalParams->setAntialias((char *)"yes");
|
|
if (globalParams->getVectorAntialias())
|
|
globalParams->setVectorAntialias((char *)"yes");
|
|
#endif
|
|
|
|
pdfdoc = new PDFDoc(new GooString(file), NULL);
|
|
if (!pdfdoc)
|
|
goto del_global_param;
|
|
|
|
if (!pdfdoc->isOk() || (pdfdoc->getErrorCode() == errEncrypted))
|
|
goto del_pdfdoc;
|
|
|
|
if (page_nbr >= pdfdoc->getNumPages())
|
|
goto del_pdfdoc;
|
|
|
|
/* load the page */
|
|
|
|
page = pdfdoc->getCatalog()->getPage(page_nbr + 1);
|
|
if (!page || !page->isOk())
|
|
goto del_pdfdoc;
|
|
|
|
w = page->getMediaWidth();
|
|
h = page->getMediaHeight();
|
|
cw = page->getCropWidth();
|
|
ch = page->getCropHeight();
|
|
rot = page->getRotate();
|
|
if (cw > w) cw = w;
|
|
if (ch > h) ch = h;
|
|
if ((rot == 90) || (rot == 270))
|
|
{
|
|
double t;
|
|
// swap width & height
|
|
t = w; w = h; h = t;
|
|
// swap crop width & height
|
|
t = cw; cw = ch; ch = t;
|
|
}
|
|
|
|
if ((size_w > 0) || (size_h > 0))
|
|
{
|
|
double w2 = cw, h2 = ch;
|
|
|
|
w2 = size_w;
|
|
h2 = (size_w * ch) / cw;
|
|
if (h2 > size_h)
|
|
{
|
|
h2 = size_h;
|
|
w2 = (size_h * cw) / ch;
|
|
}
|
|
D("XXXXXXXXXXXXXXXXXXXXx %3.3fx%3.3f\n", w2, h2);
|
|
if (w2 > h2) dpi = (w2 * DEF_DPI) / cw;
|
|
else dpi = (h2 * DEF_DPI) / ch;
|
|
}
|
|
|
|
if (dpi > 0.0)
|
|
{
|
|
cw = (cw * dpi) / DEF_DPI;
|
|
ch = (ch * dpi) / DEF_DPI;
|
|
w = (w * dpi) / DEF_DPI;
|
|
h = (h * dpi) / DEF_DPI;
|
|
}
|
|
width = w;
|
|
height = h;
|
|
crop_width = cw;
|
|
crop_height = ch;
|
|
|
|
return EINA_TRUE;
|
|
|
|
del_pdfdoc:
|
|
delete pdfdoc;
|
|
del_global_param:
|
|
delete globalParams;
|
|
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
void poppler_shutdown()
|
|
{
|
|
delete pdfdoc;
|
|
eina_shutdown();
|
|
delete globalParams;
|
|
}
|
|
|
|
void poppler_load_image(int size_w EINA_UNUSED, int size_h EINA_UNUSED)
|
|
{
|
|
SplashOutputDev *output_dev;
|
|
SplashColor white;
|
|
SplashColorPtr color_ptr;
|
|
DATA32 *src, *dst;
|
|
int y;
|
|
|
|
white[0] = 255;
|
|
white[1] = 255;
|
|
white[2] = 255;
|
|
white[3] = 255;
|
|
|
|
output_dev = new SplashOutputDev(splashModeXBGR8, 4, gFalse, white);
|
|
if (!output_dev)
|
|
return;
|
|
|
|
#if defined(HAVE_POPPLER_020) || defined(HAVE_POPPLER_031)
|
|
output_dev->startDoc(pdfdoc);
|
|
#else
|
|
output_dev->startDoc(pdfdoc->getXRef());
|
|
#endif
|
|
|
|
if (dpi <= 0.0) dpi = DEF_DPI;
|
|
|
|
#ifdef HAVE_POPPLER_031
|
|
output_dev->setFontAntialias(EINA_TRUE);
|
|
output_dev->setVectorAntialias(EINA_TRUE);
|
|
#endif
|
|
|
|
#if defined(HAVE_POPPLER_020) || defined(HAVE_POPPLER_031)
|
|
page->displaySlice(output_dev, dpi, dpi,
|
|
0, false, false,
|
|
0, 0, width, height,
|
|
false, NULL, NULL);
|
|
#else
|
|
page->displaySlice(output_dev, dpi, dpi,
|
|
0, false, false,
|
|
0, 0, width, height,
|
|
false, pdfdoc->getCatalog());
|
|
#endif
|
|
color_ptr = output_dev->getBitmap()->getDataPtr();
|
|
|
|
shm_alloc(crop_width * crop_height * sizeof(DATA32));
|
|
if (!shm_addr) goto del_outpput_dev;
|
|
data = shm_addr;
|
|
src = (DATA32 *)color_ptr;
|
|
dst = (DATA32 *)data;
|
|
for (y = 0; y < crop_height; y++)
|
|
{
|
|
memcpy(dst, src, crop_width * sizeof(DATA32));
|
|
src += width;
|
|
dst += crop_width;
|
|
}
|
|
|
|
del_outpput_dev:
|
|
delete output_dev;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
Eina_Tmpstr *tmpdir = NULL;
|
|
Eina_Tmpstr *generated = NULL;
|
|
char *extension;
|
|
char *dir;
|
|
char *file;
|
|
int i;
|
|
int size_w = 0, size_h = 0;
|
|
int head_only = 0;
|
|
int page_num = 0;
|
|
|
|
if (argc < 2) return -1;
|
|
// file is ALWAYS first arg, other options come after
|
|
file = argv[1];
|
|
for (i = 2; i < argc; i++)
|
|
{
|
|
if (!strcmp(argv[i], "-head"))
|
|
// asked to only load header, not body/data
|
|
head_only = 1;
|
|
else if (!strcmp(argv[i], "-key"))
|
|
{
|
|
i++;
|
|
page_num = atoi(argv[i]);
|
|
i++;
|
|
}
|
|
else if (!strcmp(argv[i], "-opt-scale-down-by"))
|
|
{ // not used by pdf loader
|
|
i++;
|
|
// int scale_down = atoi(argv[i]);
|
|
}
|
|
else if (!strcmp(argv[i], "-opt-dpi"))
|
|
{
|
|
i++;
|
|
dpi = ((double)atoi(argv[i])) / 1000.0; // dpi is an int multiplied by 1000 (so 72dpi is 72000)
|
|
i++;
|
|
}
|
|
else if (!strcmp(argv[i], "-opt-size"))
|
|
{ // not used by pdf loader
|
|
i++;
|
|
size_w = atoi(argv[i]);
|
|
i++;
|
|
size_h = atoi(argv[i]);
|
|
}
|
|
}
|
|
|
|
D("dpi....: %f\n", dpi);
|
|
D("page...: %d\n", page_num);
|
|
|
|
// This is a funny hack to call an external tool to generate a pdf that will then be processed by poppler
|
|
extension = strrchr(file, '.');
|
|
dir = dirname(argv[0]);
|
|
if (extension && dir && strcmp(extension, ".pdf"))
|
|
{
|
|
if (eina_file_mkdtemp("evas_generic_pdf_loaderXXXXXX", &tmpdir))
|
|
{
|
|
Eina_Strbuf *tmp;
|
|
FILE *cmd;
|
|
|
|
tmp = eina_strbuf_new();
|
|
eina_strbuf_append_printf(tmp, "%s/evas_generic_pdf_loader.%s '%s' %s", dir, extension + 1, file, tmpdir);
|
|
|
|
cmd = popen(eina_strbuf_string_get(tmp), "r");
|
|
D("running preprocessing process '%s'...\n", eina_strbuf_string_get(tmp));
|
|
eina_strbuf_reset(tmp);
|
|
|
|
if (cmd)
|
|
{
|
|
struct stat st;
|
|
const char *filename;
|
|
char buf[1024];
|
|
|
|
while (fgets(buf, sizeof (buf), cmd))
|
|
;
|
|
pclose(cmd);
|
|
|
|
filename = basename(file);
|
|
generated = eina_tmpstr_add_length(filename, strlen(filename) - strlen(extension));
|
|
|
|
eina_strbuf_append_printf(tmp, "%s/%s.pdf", tmpdir, generated);
|
|
|
|
eina_tmpstr_del(generated);
|
|
generated = NULL;
|
|
|
|
if (stat(eina_strbuf_string_get(tmp), &st) == 0)
|
|
{
|
|
generated = eina_tmpstr_add_length(eina_strbuf_string_get(tmp),
|
|
eina_strbuf_length_get(tmp));
|
|
file = (char*) generated;
|
|
}
|
|
}
|
|
|
|
D("generated file: '%s'\n", generated);
|
|
eina_strbuf_free(tmp);
|
|
}
|
|
}
|
|
|
|
// Let's force a timeout if things go wrong
|
|
timeout_init(10);
|
|
|
|
// Now process the pdf (or the generated pdf)
|
|
D("poppler_file_init\n");
|
|
if (!poppler_init(file, page_num, size_w, size_h))
|
|
return -1;
|
|
D("poppler_file_init done\n");
|
|
|
|
D("dpi2...: %f\n", dpi);
|
|
if (!head_only)
|
|
{
|
|
poppler_load_image(size_w, size_h);
|
|
}
|
|
|
|
D("size...: %ix%i\n", width, height);
|
|
D("crop...: %ix%i\n", crop_width, crop_height);
|
|
D("alpha..: 1\n");
|
|
|
|
printf("size %i %i\n", crop_width, crop_height);
|
|
printf("alpha 0\n");
|
|
|
|
if (!head_only)
|
|
{
|
|
if (shm_fd >= 0) printf("shmfile %s\n", shmfile);
|
|
else
|
|
{
|
|
// could also to "tmpfile %s\n" like shmfile but just
|
|
// a mmaped tmp file on the system
|
|
printf("data\n");
|
|
fwrite(data, crop_width * crop_height * sizeof(DATA32), 1, stdout);
|
|
}
|
|
shm_free();
|
|
}
|
|
else
|
|
printf("done\n");
|
|
|
|
poppler_shutdown();
|
|
|
|
if (tmpdir)
|
|
{
|
|
if (generated) unlink(generated);
|
|
rmdir(tmpdir);
|
|
|
|
eina_tmpstr_del(tmpdir);
|
|
eina_tmpstr_del(generated);
|
|
}
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|