new memberinfo field subfunctions
[swftools.git] / lib / pdf / pdf.cc
1 #include "../gfxdevice.h"
2 #include "../gfxsource.h"
3 #include "../devices/rescale.h"
4 #include "../log.h"
5 #include "config.h"
6 #include "GlobalParams.h"
7 #include "InfoOutputDev.h"
8 #include "GFXOutputDev.h"
9 #include "FullBitmapOutputDev.h"
10 #include "BitmapOutputDev.h"
11 #include "../mem.h"
12 #include "pdf.h"
13 #define NO_ARGPARSER
14 #include "../args.h"
15
16 static double zoom = 72; /* xpdf: 86 */
17 static int jpeg_dpi = 0;
18 static int ppm_dpi = 0;
19 static int multiply = 1;
20 static char* global_page_range = 0;
21
22 static int globalparams_count=0;
23
24 typedef struct _parameter
25 {
26     struct _parameter *next;
27     const char*name;
28     const char*value;
29 } parameter_t;
30 typedef struct _parameterlist
31 {
32     parameter_t* device_config;
33     parameter_t* device_config_next;
34 } parameterlist_t;
35
36 typedef struct _pdf_page_info
37 {
38     int xMin, yMin, xMax, yMax;
39     int width,height;
40     int number_of_images;
41     int number_of_links;
42     int number_of_fonts;
43     char has_info;
44 } pdf_page_info_t;
45
46 typedef struct _pdf_doc_internal
47 {
48     int config_bitmap_optimizing;
49     int config_full_bitmap_optimizing;
50     parameterlist_t parameters;
51
52     int protect;
53     int nocopy;
54     
55     PDFDoc*doc;
56     Object docinfo;
57     InfoOutputDev*info;
58
59     pdf_page_info_t*pages;
60     gfxdevice_t* middev;
61     char*filename;
62
63     /* page map */
64     int*pagemap;
65     int pagemap_size;
66     int pagemap_pos;
67
68     gfxsource_t*parent;
69 } pdf_doc_internal_t;
70
71 typedef struct _pdf_page_internal
72 {
73 } pdf_page_internal_t;
74
75 typedef struct _dev_output_internal
76 {
77     CommonOutputDev*outputDev;
78 } dev_output_internal_t;
79
80
81 typedef struct _gfxsource_internal
82 {
83     parameterlist_t parameters;
84 } gfxsource_internal_t;
85
86
87 static const char* dirseparator()
88 {
89 #ifdef WIN32
90     return "\\";
91 #else
92     return "/";
93 #endif
94 }
95
96 static void storeDeviceParameter(parameterlist_t*i, const char*name, const char*value)
97 {
98     parameter_t*o = i->device_config;
99     while(o) {
100         if(!strcmp(name, o->name)) {
101             /* overwrite old value */
102             free((void*)o->value);
103             o->value = strdup(value);
104             return;
105         }
106         o = o->next;
107     }
108     parameter_t*p = new parameter_t();
109     p->name = strdup(name);
110     p->value = strdup(value);
111     p->next = 0;
112
113     if(i->device_config_next) {
114         i->device_config_next->next = p;
115         i->device_config_next = p;
116     } else {
117         i->device_config = p;
118         i->device_config_next = p;
119     }
120 }
121
122
123
124 void pdfpage_destroy(gfxpage_t*pdf_page)
125 {
126     pdf_page_internal_t*i= (pdf_page_internal_t*)pdf_page->internal;
127     free(pdf_page->internal);pdf_page->internal = 0;
128     free(pdf_page);pdf_page=0;
129 }
130
131 static void render2(gfxpage_t*page, gfxdevice_t*dev, int x,int y, int x1,int y1,int x2,int y2)
132 {
133     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
134     gfxsource_internal_t*i = (gfxsource_internal_t*)pi->parent->internal;
135
136     if(pi->nocopy) {
137         msg("<fatal> PDF disallows copying");
138         exit(0);
139     }
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 = pi->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, /*doLinks*/(int)1);
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 {
291         storeDeviceParameter(&i->parameters, name, value);
292     }
293 }
294
295 gfxpage_t* pdf_doc_getpage(gfxdocument_t*doc, int page)
296 {
297     pdf_doc_internal_t*di= (pdf_doc_internal_t*)doc->internal;
298
299     if(page < 1 || page > doc->num_pages)
300         return 0;
301     
302     gfxpage_t* pdf_page = (gfxpage_t*)malloc(sizeof(gfxpage_t));
303     pdf_page_internal_t*pi= (pdf_page_internal_t*)malloc(sizeof(pdf_page_internal_t));
304     memset(pi, 0, sizeof(pdf_page_internal_t));
305     pdf_page->internal = pi;
306
307     pdf_page->destroy = pdfpage_destroy;
308     pdf_page->render = pdfpage_render;
309     pdf_page->rendersection = pdfpage_rendersection;
310     pdf_page->width = di->pages[page-1].width;
311     pdf_page->height = di->pages[page-1].height;
312
313     pdf_page->parent = doc;
314     pdf_page->nr = page;
315     return pdf_page;
316 }
317
318 static char*getInfoString(Dict *infoDict, const char *key)
319 {
320     Object obj;
321     GString *s1, *s2;
322     int i;
323
324     if (infoDict && infoDict->lookup((char*)key, &obj)->isString()) {
325         s1 = obj.getString();
326         if ((s1->getChar(0) & 0xff) == 0xfe &&
327             (s1->getChar(1) & 0xff) == 0xff) {
328             s2 = new GString();
329             for (i = 2; i < obj.getString()->getLength(); i += 2) {
330               if (s1->getChar(i) == '\0') {
331                 s2->append(s1->getChar(i+1));
332               } else {
333                 delete s2;
334                 s2 = new GString("<unicode>");
335                 break;
336               }
337             }
338             char*ret = strdup(s2->getCString());
339             delete s2;
340             obj.free();
341             return ret;
342         } else {
343             char*ret = strdup(s1->getCString());
344             obj.free();
345             return ret;
346         }
347     }
348     return strdup("");
349 }
350
351 static char*getInfoDate(Dict *infoDict, const char *key) 
352 {
353     Object obj;
354     char *s;
355
356     if (infoDict && infoDict->lookup((char*)key, &obj)->isString()) {
357         s = obj.getString()->getCString();
358         if (s[0] == 'D' && s[1] == ':') {
359           s += 2;
360         }
361         char*ret = strdup(s);
362         obj.free();
363         return ret;
364     }
365     return strdup("");
366 }
367
368 char* pdf_doc_getinfo(gfxdocument_t*doc, const char*name)
369 {
370     pdf_doc_internal_t*i= (pdf_doc_internal_t*)doc->internal;
371     if(!strcmp(name, "title")) return getInfoString(i->docinfo.getDict(), "Title");
372     else if(!strcmp(name, "subject")) return getInfoString(i->docinfo.getDict(), "Subject");
373     else if(!strcmp(name, "keywords")) return getInfoString(i->docinfo.getDict(), "Keywords");
374     else if(!strcmp(name, "author")) return getInfoString(i->docinfo.getDict(), "Author");
375     else if(!strcmp(name, "creator")) return getInfoString(i->docinfo.getDict(), "Creator");
376     else if(!strcmp(name, "producer")) return getInfoString(i->docinfo.getDict(), "Producer");
377     else if(!strcmp(name, "creationdate")) return getInfoDate(i->docinfo.getDict(), "CreationDate");
378     else if(!strcmp(name, "moddate")) return getInfoDate(i->docinfo.getDict(), "ModDate");
379     else if(!strcmp(name, "linearized")) return strdup(i->doc->isLinearized() ? "yes" : "no");
380     else if(!strcmp(name, "tagged")) return strdup(i->doc->getStructTreeRoot()->isDict() ? "yes" : "no");
381     else if(!strcmp(name, "encrypted")) return strdup(i->doc->isEncrypted() ? "yes" : "no");
382     else if(!strcmp(name, "oktoprint")) return strdup(i->doc->okToPrint() ? "yes" : "no");
383     else if(!strcmp(name, "oktocopy")) return strdup(i->doc->okToCopy() ? "yes" : "no");
384     else if(!strcmp(name, "oktochange")) return strdup(i->doc->okToChange() ? "yes" : "no");
385     else if(!strcmp(name, "oktoaddnotes")) return strdup(i->doc->okToAddNotes() ? "yes" : "no");
386     else if(!strcmp(name, "version")) { 
387         char buf[32];
388         sprintf(buf, "%.1f", i->doc->getPDFVersion());
389         return strdup(buf);
390     }
391     return 0;
392 }
393
394
395 static void pdf_set_parameter(gfxsource_t*src, const char*name, const char*value)
396 {
397     gfxsource_internal_t*i = (gfxsource_internal_t*)src->internal;
398     parameterlist_t*p = &i->parameters;
399     msg("<verbose> setting parameter %s to \"%s\"", name, value);
400     if(!strncmp(name, "fontdir", strlen("fontdir"))) {
401         addGlobalFontDir(value);
402     } else if(!strcmp(name, "pages")) {
403         global_page_range = strdup(value);
404     } else if(!strncmp(name, "font", strlen("font")) && name[4]!='q') {
405         addGlobalFont(value);
406     } else if(!strncmp(name, "languagedir", strlen("languagedir"))) {
407         addGlobalLanguageDir(value);
408     } else if(!strcmp(name, "zoom")) {
409         char buf[80];
410         zoom = atof(value);
411         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
412         storeDeviceParameter(p, "jpegsubpixels", buf);
413         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
414         storeDeviceParameter(p, "ppmsubpixels", buf);
415     } else if(!strcmp(name, "jpegdpi")) {
416         char buf[80];
417         jpeg_dpi = atoi(value);
418         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
419         storeDeviceParameter(p, "jpegsubpixels", buf);
420     } else if(!strcmp(name, "ppmdpi")) {
421         char buf[80];
422         ppm_dpi = atoi(value);
423         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
424         storeDeviceParameter(p, "ppmsubpixels", buf);
425     } else if(!strcmp(name, "multiply")) {
426         multiply = atoi(value);
427     } else if(!strcmp(name, "help")) {
428         printf("\nPDF device global parameters:\n");
429         printf("fontdir=<dir>     a directory with additional fonts\n");
430         printf("font=<filename>   an additional font filename\n");
431         printf("pages=<range>     the range of pages to convert (example: pages=1-100,210-)\n");
432         printf("zoom=<dpi>        the resultion (default: 72)\n");
433         printf("languagedir=<dir> Add an xpdf language directory\n");
434         printf("multiply=<times>  Render everything at <times> the resolution\n");
435         printf("poly2bitmap       Convert graphics to bitmaps\n");
436         printf("bitmap            Convert everything to bitmaps\n");
437     }   
438 }
439
440 void pdf_doc_prepare(gfxdocument_t*doc, gfxdevice_t*dev)
441 {
442     pdf_doc_internal_t*i= (pdf_doc_internal_t*)doc->internal;
443     i->info->dumpfonts(dev);
444 }
445
446 static gfxdocument_t*pdf_open(gfxsource_t*src, const char*filename)
447 {
448     gfxsource_internal_t*isrc = (gfxsource_internal_t*)src->internal;
449     gfxdocument_t*pdf_doc = (gfxdocument_t*)malloc(sizeof(gfxdocument_t));
450     memset(pdf_doc, 0, sizeof(gfxdocument_t));
451     pdf_doc_internal_t*i= (pdf_doc_internal_t*)malloc(sizeof(pdf_doc_internal_t));
452     memset(i, 0, sizeof(pdf_doc_internal_t));
453     i->parent = src;
454     pdf_doc->internal = i;
455     char*userPassword=0;
456     
457     i->filename = strdup(filename);
458
459     char*x = 0;
460     if((x = strchr(filename, '|'))) {
461         *x = 0;
462         userPassword = x+1;
463     }
464     
465     GString *fileName = new GString(filename);
466     GString *userPW;
467
468     // open PDF file
469     if (userPassword && userPassword[0]) {
470       userPW = new GString(userPassword);
471     } else {
472       userPW = NULL;
473     }
474     i->doc = new PDFDoc(fileName, userPW);
475     if (userPW) {
476       delete userPW;
477     }
478     if (!i->doc->isOk()) {
479         printf("xpdf reports document as broken.\n");
480         return 0;
481     }
482
483     // get doc info
484     i->doc->getDocInfo(&i->docinfo);
485     
486     pdf_doc->num_pages = i->doc->getNumPages();
487     i->protect = 0;
488     if (i->doc->isEncrypted()) {
489           if(!i->doc->okToCopy()) {
490               i->nocopy = 1;
491           }
492           if(!i->doc->okToChange() || !i->doc->okToAddNotes())
493               i->protect = 1;
494     }
495
496     i->info = new InfoOutputDev(i->doc->getXRef());
497     int t;
498     i->pages = (pdf_page_info_t*)malloc(sizeof(pdf_page_info_t)*pdf_doc->num_pages);
499     memset(i->pages,0,sizeof(pdf_page_info_t)*pdf_doc->num_pages);
500     for(t=1;t<=pdf_doc->num_pages;t++) {
501         if(!global_page_range || is_in_range(t, global_page_range)) {
502             i->doc->displayPage((OutputDev*)i->info, t, zoom, zoom, /*rotate*/0, /*usemediabox*/true, /*crop*/true, /*doLinks*/(int)1);
503             i->doc->processLinks((OutputDev*)i->info, t);
504             i->pages[t-1].xMin = i->info->x1;
505             i->pages[t-1].yMin = i->info->y1;
506             i->pages[t-1].xMax = i->info->x2;
507             i->pages[t-1].yMax = i->info->y2;
508             i->pages[t-1].width = i->info->x2 - i->info->x1;
509             i->pages[t-1].height = i->info->y2 - i->info->y1;
510             i->pages[t-1].number_of_images = i->info->num_ppm_images + i->info->num_jpeg_images;
511             i->pages[t-1].number_of_links = i->info->num_links;
512             i->pages[t-1].number_of_fonts = i->info->num_fonts;
513             i->pages[t-1].has_info = 1;
514         }
515     }
516
517     pdf_doc->get = 0;
518     pdf_doc->destroy = pdf_doc_destroy;
519     pdf_doc->set_parameter = pdf_doc_set_parameter;
520     pdf_doc->getinfo = pdf_doc_getinfo;
521     pdf_doc->getpage = pdf_doc_getpage;
522     pdf_doc->prepare = pdf_doc_prepare;
523     
524     return pdf_doc;
525
526 }
527     
528 void pdf_destroy(gfxsource_t*src)
529 {
530     if(!src->internal)
531         return;
532     gfxsource_internal_t*i = (gfxsource_internal_t*)src->internal;
533     
534     parameter_t*p = i->parameters.device_config;
535     while(p) {
536         parameter_t*next = p->next;
537         if(p->name) free((void*)p->name);p->name = 0;
538         if(p->value) free((void*)p->value);p->value =0;
539         p->next = 0;delete p;
540         p = next;
541     }
542     i->parameters.device_config=i->parameters.device_config_next=0;
543     
544     free(src->internal);src->internal=0;
545
546     delete globalParams;globalParams = 0;
547     free(src);
548 }
549
550 gfxsource_t*gfxsource_pdf_create()
551 {
552     gfxsource_t*src = (gfxsource_t*)malloc(sizeof(gfxsource_t));
553     memset(src, 0, sizeof(gfxsource_t));
554     src->set_parameter = pdf_set_parameter;
555     src->open = pdf_open;
556     src->destroy = pdf_destroy;
557     src->internal = malloc(sizeof(gfxsource_internal_t));
558     memset(src->internal, 0, sizeof(gfxsource_internal_t));
559
560     if(!globalParams) {
561         globalParams = new GFXGlobalParams();
562         //globalparams_count++;
563     }
564     
565
566     return src;
567 }