added test for text selection functionality
[swftools.git] / lib / pdf / pdf.cc
1 #include <stdio.h>
2 #include <string.h>
3 #include "../gfxdevice.h"
4 #include "../gfxsource.h"
5 #include "../devices/rescale.h"
6 #include "../log.h"
7 #include "config.h"
8 #include "GlobalParams.h"
9 #include "InfoOutputDev.h"
10 #include "GFXOutputDev.h"
11 #include "FullBitmapOutputDev.h"
12 #include "BitmapOutputDev.h"
13 #include "../mem.h"
14 #include "pdf.h"
15 #define NO_ARGPARSER
16 #include "../args.h"
17
18 static double zoom = 72; /* xpdf: 86 */
19 static int zoomtowidth = 0;
20 static int multiply = 1;
21 static char* global_page_range = 0;
22
23 static int globalparams_count=0;
24
25 typedef struct _parameter
26 {
27     struct _parameter *next;
28     const char*name;
29     const char*value;
30 } parameter_t;
31 typedef struct _parameterlist
32 {
33     parameter_t* device_config;
34     parameter_t* device_config_next;
35 } parameterlist_t;
36
37 typedef struct _pdf_page_info
38 {
39     int xMin, yMin, xMax, yMax;
40     int width,height;
41     int number_of_images;
42     int number_of_links;
43     int number_of_fonts;
44     char has_info;
45 } pdf_page_info_t;
46
47 typedef struct _pdf_doc_internal
48 {
49     char config_bitmap_optimizing;
50     char config_full_bitmap_optimizing;
51     char config_print;
52     parameterlist_t parameters;
53
54     int protect;
55     int nocopy;
56     int noprint;
57     
58     PDFDoc*doc;
59     Object docinfo;
60     InfoOutputDev*info;
61
62     pdf_page_info_t*pages;
63     char*filename;
64
65     /* page map */
66     int*pagemap;
67     int pagemap_size;
68     int pagemap_pos;
69
70     gfxsource_t*parent;
71 } pdf_doc_internal_t;
72
73 typedef struct _pdf_page_internal
74 {
75 } pdf_page_internal_t;
76
77 typedef struct _dev_output_internal
78 {
79     CommonOutputDev*outputDev;
80 } dev_output_internal_t;
81
82
83 typedef struct _gfxsource_internal
84 {
85     parameterlist_t parameters;
86 } gfxsource_internal_t;
87
88
89 static const char* dirseparator()
90 {
91 #ifdef WIN32
92     return "\\";
93 #else
94     return "/";
95 #endif
96 }
97
98 static void storeDeviceParameter(parameterlist_t*i, const char*name, const char*value)
99 {
100     parameter_t*o = i->device_config;
101     while(o) {
102         if(!strcmp(name, o->name)) {
103             /* overwrite old value */
104             free((void*)o->value);
105             o->value = strdup(value);
106             return;
107         }
108         o = o->next;
109     }
110     parameter_t*p = new parameter_t();
111     p->name = strdup(name);
112     p->value = strdup(value);
113     p->next = 0;
114
115     if(i->device_config_next) {
116         i->device_config_next->next = p;
117         i->device_config_next = p;
118     } else {
119         i->device_config = p;
120         i->device_config_next = p;
121     }
122 }
123
124
125
126 void pdfpage_destroy(gfxpage_t*pdf_page)
127 {
128     pdf_page_internal_t*i= (pdf_page_internal_t*)pdf_page->internal;
129     free(pdf_page->internal);pdf_page->internal = 0;
130     free(pdf_page);pdf_page=0;
131 }
132
133 static void render2(gfxpage_t*page, gfxdevice_t*dev, int x,int y, int x1,int y1,int x2,int y2)
134 {
135     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
136     gfxsource_internal_t*i = (gfxsource_internal_t*)pi->parent->internal;
137
138     if(!pi->config_print && pi->nocopy) {msg("<fatal> PDF disallows copying");exit(0);}
139     if(pi->config_print && pi->noprint) {msg("<fatal> PDF disallows printing");exit(0);}
140
141     CommonOutputDev*outputDev = 0;
142     if(pi->config_full_bitmap_optimizing) {
143         FullBitmapOutputDev*d = new FullBitmapOutputDev(pi->info, pi->doc);
144         outputDev = (CommonOutputDev*)d;
145     } else if(pi->config_bitmap_optimizing) {
146         BitmapOutputDev*d = new BitmapOutputDev(pi->info, pi->doc);
147         outputDev = (CommonOutputDev*)d;
148     } else {
149         GFXOutputDev*d = new GFXOutputDev(pi->info, pi->doc);
150         outputDev = (CommonOutputDev*)d;
151     }
152     /* pass global parameters to PDF driver*/
153     parameter_t*p = i->parameters.device_config;
154     while(p) {
155         outputDev->setParameter(p->name, p->value);
156         p = p->next;
157     }
158     p = pi->parameters.device_config;
159     while(p) {
160         outputDev->setParameter(p->name, p->value);
161         p = p->next;
162     }
163
164     outputDev->setPageMap(pi->pagemap, pi->pagemap_pos);
165     outputDev->setMove(x,y);
166     outputDev->setClip(x1,y1,x2,y2);
167
168     gfxdevice_t* middev=0;
169     if(multiply>1) {
170         middev = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
171         gfxdevice_rescale_init(middev, 0x00000000, 0, 0, 1.0 / multiply);
172         gfxdevice_rescale_setdevice(middev, dev);
173         middev->setparameter(middev, "protect", "1");
174         dev = middev;
175     } 
176         
177     if(!pi) {
178         msg("<fatal> pdf_page_render: Parent PDF this page belongs to doesn't exist yet/anymore");
179         return;
180     }
181
182     if(!pi->pages[page->nr-1].has_info) {
183         msg("<fatal> pdf_page_render: page %d was previously set as not-to-render via the \"pages\" option", page->nr);
184         return;
185     }
186
187     if(pi->protect) {
188         dev->setparameter(dev, "protect", "1");
189     }
190
191     outputDev->setDevice(dev);
192     pi->doc->displayPage((OutputDev*)outputDev, page->nr, zoom*multiply, zoom*multiply, /*rotate*/0, true, true, pi->config_print);
193     pi->doc->processLinks((OutputDev*)outputDev, page->nr);
194     outputDev->finishPage();
195     outputDev->setDevice(0);
196     delete outputDev;
197
198     if(middev) {
199         gfxdevice_rescale_setdevice(middev, 0x00000000);
200         middev->finish(middev);
201     }
202
203 }
204
205     
206 void pdfpage_render(gfxpage_t*page, gfxdevice_t*output)
207 {
208     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
209     render2(page, output, 0,0, 0,0,0,0);
210 }
211
212 void pdfpage_rendersection(gfxpage_t*page, gfxdevice_t*output, gfxcoord_t x, gfxcoord_t y, gfxcoord_t _x1, gfxcoord_t _y1, gfxcoord_t _x2, gfxcoord_t _y2)
213 {
214     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
215
216     int x1=(int)_x1,y1=(int)_y1,x2=(int)_x2,y2=(int)_y2;
217     if((x1|y1|x2|y2)==0) x2++;
218
219     render2(page, output, (int)x*multiply,(int)y*multiply,
220                           (int)x1*multiply,(int)y1*multiply,(int)x2*multiply,(int)y2*multiply);
221 }
222
223 void pdf_doc_destroy(gfxdocument_t*gfx)
224 {
225     pdf_doc_internal_t*i= (pdf_doc_internal_t*)gfx->internal;
226
227     delete i->doc; i->doc=0;
228     free(i->pages); i->pages = 0;
229
230     i->docinfo.free();
231
232     if(i->filename) {
233         free(i->filename);i->filename=0;
234     }
235     
236     if(i->info) {
237         delete i->info;i->info=0;
238     }
239
240     free(gfx->internal);gfx->internal=0;
241     free(gfx);gfx=0;
242
243     if(global_page_range) {
244         free(global_page_range);
245         global_page_range = 0;
246     }
247     
248     /*globalparams_count--;
249     if(!globalparams_count) {
250         delete globalParams;
251         globalParams = 0;
252         globalparams_count = 0;
253     }*/
254 }
255
256 static void add_page_to_map(gfxdocument_t*gfx, int pdfpage, int outputpage)
257 {
258     pdf_doc_internal_t*i= (pdf_doc_internal_t*)gfx->internal;
259     if(pdfpage < 0)
260         return;
261     if(pdfpage >= i->pagemap_size) {
262         int oldlen = i->pagemap_size;
263         i->pagemap_size = oldlen + 1024;
264         if(pdfpage > i->pagemap_size)
265             i->pagemap_size = pdfpage+1;
266
267         if(i->pages) {
268             i->pagemap = (int*)malloc(i->pagemap_size*sizeof(int));
269         } else {
270             i->pagemap = (int*)realloc(i->pages, i->pagemap_size*sizeof(int));
271         }
272         memset(&i->pagemap[oldlen], -1, (i->pagemap_size-oldlen)*sizeof(int));
273     }
274     i->pagemap[pdfpage] = outputpage;
275     if(pdfpage > i->pagemap_pos)
276         i->pagemap_pos = pdfpage;
277 }
278
279 void pdf_doc_set_parameter(gfxdocument_t*gfx, const char*name, const char*value)
280 {
281     pdf_doc_internal_t*i= (pdf_doc_internal_t*)gfx->internal;
282     if(!strcmp(name, "pagemap")) {
283         int pdfpage=0, outputpage=0;
284         sscanf(value,"%d:%d", &pdfpage, &outputpage);
285         add_page_to_map(gfx, pdfpage, outputpage);
286     } else if(!strcmp(name, "poly2bitmap")) {
287         i->config_bitmap_optimizing = atoi(value);
288     } else if(!strcmp(name, "bitmapfonts") || !strcmp(name, "bitmap")) {
289         i->config_full_bitmap_optimizing = atoi(value);
290     } else if(!strcmp(name, "asprint")) {
291         i->config_print = 1;
292     } else {
293         storeDeviceParameter(&i->parameters, name, value);
294     }
295 }
296
297 gfxpage_t* pdf_doc_getpage(gfxdocument_t*doc, int page)
298 {
299     pdf_doc_internal_t*di= (pdf_doc_internal_t*)doc->internal;
300
301     if(page < 1 || page > doc->num_pages)
302         return 0;
303     
304     gfxpage_t* pdf_page = (gfxpage_t*)malloc(sizeof(gfxpage_t));
305     pdf_page_internal_t*pi= (pdf_page_internal_t*)malloc(sizeof(pdf_page_internal_t));
306     memset(pi, 0, sizeof(pdf_page_internal_t));
307     pdf_page->internal = pi;
308
309     pdf_page->destroy = pdfpage_destroy;
310     pdf_page->render = pdfpage_render;
311     pdf_page->rendersection = pdfpage_rendersection;
312     pdf_page->width = di->pages[page-1].width;
313     pdf_page->height = di->pages[page-1].height;
314
315     pdf_page->parent = doc;
316     pdf_page->nr = page;
317     return pdf_page;
318 }
319
320 static char*getInfoString(Dict *infoDict, const char *key)
321 {
322     Object obj;
323     GString *s1, *s2;
324     int i;
325
326     if (infoDict && infoDict->lookup((char*)key, &obj)->isString()) {
327         s1 = obj.getString();
328         if ((s1->getChar(0) & 0xff) == 0xfe &&
329             (s1->getChar(1) & 0xff) == 0xff) {
330             s2 = new GString();
331             for (i = 2; i < obj.getString()->getLength(); i += 2) {
332               if (s1->getChar(i) == '\0') {
333                 s2->append(s1->getChar(i+1));
334               } else {
335                 delete s2;
336                 s2 = new GString("<unicode>");
337                 break;
338               }
339             }
340             char*ret = strdup(s2->getCString());
341             delete s2;
342             obj.free();
343             return ret;
344         } else {
345             char*ret = strdup(s1->getCString());
346             obj.free();
347             return ret;
348         }
349     }
350     return strdup("");
351 }
352
353 static char*getInfoDate(Dict *infoDict, const char *key) 
354 {
355     Object obj;
356     char *s;
357
358     if (infoDict && infoDict->lookup((char*)key, &obj)->isString()) {
359         s = obj.getString()->getCString();
360         if (s[0] == 'D' && s[1] == ':') {
361           s += 2;
362         }
363         char*ret = strdup(s);
364         obj.free();
365         return ret;
366     }
367     return strdup("");
368 }
369
370 char* pdf_doc_getinfo(gfxdocument_t*doc, const char*name)
371 {
372     pdf_doc_internal_t*i= (pdf_doc_internal_t*)doc->internal;
373     if(!strcmp(name, "title")) return getInfoString(i->docinfo.getDict(), "Title");
374     else if(!strcmp(name, "subject")) return getInfoString(i->docinfo.getDict(), "Subject");
375     else if(!strcmp(name, "keywords")) return getInfoString(i->docinfo.getDict(), "Keywords");
376     else if(!strcmp(name, "author")) return getInfoString(i->docinfo.getDict(), "Author");
377     else if(!strcmp(name, "creator")) return getInfoString(i->docinfo.getDict(), "Creator");
378     else if(!strcmp(name, "producer")) return getInfoString(i->docinfo.getDict(), "Producer");
379     else if(!strcmp(name, "creationdate")) return getInfoDate(i->docinfo.getDict(), "CreationDate");
380     else if(!strcmp(name, "moddate")) return getInfoDate(i->docinfo.getDict(), "ModDate");
381     else if(!strcmp(name, "linearized")) return strdup(i->doc->isLinearized() ? "yes" : "no");
382     else if(!strcmp(name, "tagged")) return strdup(i->doc->getStructTreeRoot()->isDict() ? "yes" : "no");
383     else if(!strcmp(name, "encrypted")) return strdup(i->doc->isEncrypted() ? "yes" : "no");
384     else if(!strcmp(name, "oktoprint")) return strdup(i->doc->okToPrint() ? "yes" : "no");
385     else if(!strcmp(name, "oktocopy")) return strdup(i->doc->okToCopy() ? "yes" : "no");
386     else if(!strcmp(name, "oktochange")) return strdup(i->doc->okToChange() ? "yes" : "no");
387     else if(!strcmp(name, "oktoaddnotes")) return strdup(i->doc->okToAddNotes() ? "yes" : "no");
388     else if(!strcmp(name, "version")) { 
389         char buf[32];
390         sprintf(buf, "%.1f", i->doc->getPDFVersion());
391         return strdup(buf);
392     }
393     return 0;
394 }
395
396
397 static void pdf_set_parameter(gfxsource_t*src, const char*name, const char*value)
398 {
399     gfxsource_internal_t*i = (gfxsource_internal_t*)src->internal;
400     parameterlist_t*p = &i->parameters;
401     msg("<verbose> setting parameter %s to \"%s\"", name, value);
402     if(!strncmp(name, "fontdir", strlen("fontdir"))) {
403         addGlobalFontDir(value);
404     } else if(!strcmp(name, "pages")) {
405         global_page_range = strdup(value);
406     } else if(!strncmp(name, "font", strlen("font")) && name[4]!='q') {
407         addGlobalFont(value);
408     } else if(!strncmp(name, "languagedir", strlen("languagedir"))) {
409         addGlobalLanguageDir(value);
410     } else if(!strcmp(name, "zoomtowidth")) {
411         zoomtowidth = atoi(value);
412     } else if(!strcmp(name, "zoom")) {
413         char buf[80];
414         zoom = atof(value);
415     } else if(!strcmp(name, "jpegdpi") || !strcmp(name, "ppmdpi")) {
416         msg("<error> %s not supported anymore. Please use jpegsubpixels/ppmsubpixels");
417     } else if(!strcmp(name, "multiply")) {
418         multiply = atoi(value);
419     } else if(!strcmp(name, "help")) {
420         printf("\nPDF device global parameters:\n");
421         printf("fontdir=<dir>     a directory with additional fonts\n");
422         printf("font=<filename>   an additional font filename\n");
423         printf("pages=<range>     the range of pages to convert (example: pages=1-100,210-)\n");
424         printf("zoom=<dpi>        the resultion (default: 72)\n");
425         printf("languagedir=<dir> Add an xpdf language directory\n");
426         printf("multiply=<times>  Render everything at <times> the resolution\n");
427         printf("poly2bitmap       Convert graphics to bitmaps\n");
428         printf("bitmap            Convert everything to bitmaps\n");
429     }   
430 }
431
432 void pdf_doc_prepare(gfxdocument_t*doc, gfxdevice_t*dev)
433 {
434     pdf_doc_internal_t*i= (pdf_doc_internal_t*)doc->internal;
435     i->info->dumpfonts(dev);
436 }
437
438 static gfxdocument_t*pdf_open(gfxsource_t*src, const char*filename)
439 {
440     gfxsource_internal_t*isrc = (gfxsource_internal_t*)src->internal;
441     gfxdocument_t*pdf_doc = (gfxdocument_t*)malloc(sizeof(gfxdocument_t));
442     memset(pdf_doc, 0, sizeof(gfxdocument_t));
443     pdf_doc_internal_t*i= (pdf_doc_internal_t*)malloc(sizeof(pdf_doc_internal_t));
444     memset(i, 0, sizeof(pdf_doc_internal_t));
445     i->parent = src;
446     pdf_doc->internal = i;
447     char*userPassword=0;
448     
449     i->filename = strdup(filename);
450
451     char*x = 0;
452     if((x = strchr((char*)filename, '|'))) {
453         *x = 0;
454         userPassword = x+1;
455     }
456     
457     GString *fileName = new GString(filename);
458     GString *userPW;
459
460     // open PDF file
461     if (userPassword && userPassword[0]) {
462       userPW = new GString(userPassword);
463     } else {
464       userPW = NULL;
465     }
466     i->doc = new PDFDoc(fileName, userPW);
467     if (userPW) {
468       delete userPW;
469     }
470     if (!i->doc->isOk()) {
471         printf("xpdf reports document as broken.\n");
472         return 0;
473     }
474
475     // get doc info
476     i->doc->getDocInfo(&i->docinfo);
477     
478     pdf_doc->num_pages = i->doc->getNumPages();
479     i->protect = 0;
480     if (i->doc->isEncrypted()) {
481           if(!i->doc->okToCopy()) {
482               i->nocopy = 1;
483           }
484           if(!i->doc->okToPrint()) {
485               i->noprint = 1;
486           }
487           if(!i->doc->okToChange() || !i->doc->okToAddNotes())
488               i->protect = 1;
489     }
490         
491     if(zoomtowidth && i->doc->getNumPages()) {
492         Page*page = i->doc->getCatalog()->getPage(1);
493         PDFRectangle *r = page->getCropBox();
494         double width_before = r->x2 - r->x1;
495         zoom = 72.0 * zoomtowidth / width_before;
496         msg("<notice> Rendering at %f DPI. (Page width at 72 DPI: %f, target width: %d)", zoom, width_before, zoomtowidth);
497     }
498
499     i->info = new InfoOutputDev(i->doc->getXRef());
500     int t;
501     i->pages = (pdf_page_info_t*)malloc(sizeof(pdf_page_info_t)*pdf_doc->num_pages);
502     memset(i->pages,0,sizeof(pdf_page_info_t)*pdf_doc->num_pages);
503     for(t=1;t<=pdf_doc->num_pages;t++) {
504         if(!global_page_range || is_in_range(t, global_page_range)) {
505             i->doc->displayPage((OutputDev*)i->info, t, zoom, zoom, /*rotate*/0, /*usemediabox*/true, /*crop*/true, i->config_print);
506             i->doc->processLinks((OutputDev*)i->info, t);
507             i->pages[t-1].xMin = i->info->x1;
508             i->pages[t-1].yMin = i->info->y1;
509             i->pages[t-1].xMax = i->info->x2;
510             i->pages[t-1].yMax = i->info->y2;
511             i->pages[t-1].width = i->info->x2 - i->info->x1;
512             i->pages[t-1].height = i->info->y2 - i->info->y1;
513             i->pages[t-1].number_of_images = i->info->num_ppm_images + i->info->num_jpeg_images;
514             i->pages[t-1].number_of_links = i->info->num_links;
515             i->pages[t-1].number_of_fonts = i->info->num_fonts;
516             i->pages[t-1].has_info = 1;
517         }
518     }
519
520     pdf_doc->get = 0;
521     pdf_doc->destroy = pdf_doc_destroy;
522     pdf_doc->set_parameter = pdf_doc_set_parameter;
523     pdf_doc->getinfo = pdf_doc_getinfo;
524     pdf_doc->getpage = pdf_doc_getpage;
525     pdf_doc->prepare = pdf_doc_prepare;
526     
527     return pdf_doc;
528
529 }
530     
531 void pdf_destroy(gfxsource_t*src)
532 {
533     if(!src->internal)
534         return;
535     gfxsource_internal_t*i = (gfxsource_internal_t*)src->internal;
536     
537     parameter_t*p = i->parameters.device_config;
538     while(p) {
539         parameter_t*next = p->next;
540         if(p->name) free((void*)p->name);p->name = 0;
541         if(p->value) free((void*)p->value);p->value =0;
542         p->next = 0;delete p;
543         p = next;
544     }
545     i->parameters.device_config=i->parameters.device_config_next=0;
546     
547     free(src->internal);src->internal=0;
548
549     delete globalParams;globalParams = 0;
550     free(src);
551 }
552
553 gfxsource_t*gfxsource_pdf_create()
554 {
555     gfxsource_t*src = (gfxsource_t*)malloc(sizeof(gfxsource_t));
556     memset(src, 0, sizeof(gfxsource_t));
557     src->set_parameter = pdf_set_parameter;
558     src->open = pdf_open;
559     src->destroy = pdf_destroy;
560     src->internal = malloc(sizeof(gfxsource_internal_t));
561     memset(src->internal, 0, sizeof(gfxsource_internal_t));
562
563     if(!globalParams) {
564         globalParams = new GFXGlobalParams();
565         //globalparams_count++;
566     }
567     
568
569     return src;
570 }