e92d7a1250124be24345b55686f573b8493bb068
[pdfium.git] / samples / pdfium_test.cc
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <limits.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include <list>
11 #include <string>
12 #include <utility>
13
14 #include "../fpdfsdk/include/fpdf_dataavail.h"
15 #include "../fpdfsdk/include/fpdf_ext.h"
16 #include "../fpdfsdk/include/fpdfformfill.h"
17 #include "../fpdfsdk/include/fpdftext.h"
18 #include "../fpdfsdk/include/fpdfview.h"
19 #include "v8/include/v8.h"
20
21 #ifdef _WIN32
22   #define snprintf _snprintf
23 #endif
24
25 enum OutputFormat {
26   OUTPUT_NONE,
27   OUTPUT_PPM,
28 #ifdef _WIN32
29   OUTPUT_BMP,
30   OUTPUT_EMF,
31 #endif
32 };
33
34 static void WritePpm(const char* pdf_name, int num, const void* buffer_void,
35                      int stride, int width, int height) {
36   const char* buffer = reinterpret_cast<const char*>(buffer_void);
37
38   if (stride < 0 || width < 0 || height < 0)
39     return;
40   if (height > 0 && width > INT_MAX / height)
41     return;
42   int out_len = width * height;
43   if (out_len > INT_MAX / 3)
44     return;
45   out_len *= 3;
46
47   char filename[256];
48   snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num);
49   FILE* fp = fopen(filename, "wb");
50   if (!fp)
51     return;
52   fprintf(fp, "P6\n# PDF test render\n%d %d\n255\n", width, height);
53   // Source data is B, G, R, unused.
54   // Dest data is R, G, B.
55   char* result = new char[out_len];
56   if (result) {
57     for (int h = 0; h < height; ++h) {
58       const char* src_line = buffer + (stride * h);
59       char* dest_line = result + (width * h * 3);
60       for (int w = 0; w < width; ++w) {
61         // R
62         dest_line[w * 3] = src_line[(w * 4) + 2];
63         // G
64         dest_line[(w * 3) + 1] = src_line[(w * 4) + 1];
65         // B
66         dest_line[(w * 3) + 2] = src_line[w * 4];
67       }
68     }
69     fwrite(result, out_len, 1, fp);
70     delete [] result;
71   }
72   fclose(fp);
73 }
74
75 #ifdef _WIN32
76 static void WriteBmp(const char* pdf_name, int num, const void* buffer,
77                      int stride, int width, int height) {
78   if (stride < 0 || width < 0 || height < 0)
79     return;
80   if (height > 0 && width > INT_MAX / height)
81     return;
82   int out_len = stride * height;
83   if (out_len > INT_MAX / 3)
84     return;
85
86   char filename[256];
87   snprintf(filename, sizeof(filename), "%s.%d.bmp", pdf_name, num);
88   FILE* fp = fopen(filename, "wb");
89   if (!fp)
90     return;
91
92   BITMAPINFO bmi = {0};
93   bmi.bmiHeader.biSize = sizeof(bmi) - sizeof(RGBQUAD);
94   bmi.bmiHeader.biWidth = width;
95   bmi.bmiHeader.biHeight = -height;  // top-down image
96   bmi.bmiHeader.biPlanes = 1;
97   bmi.bmiHeader.biBitCount = 32;
98   bmi.bmiHeader.biCompression = BI_RGB;
99   bmi.bmiHeader.biSizeImage = 0;
100
101   BITMAPFILEHEADER file_header = {0};
102   file_header.bfType = 0x4d42;
103   file_header.bfSize = sizeof(file_header) + bmi.bmiHeader.biSize + out_len;
104   file_header.bfOffBits = file_header.bfSize - out_len;
105
106   fwrite(&file_header, sizeof(file_header), 1, fp);
107   fwrite(&bmi, bmi.bmiHeader.biSize, 1, fp);
108   fwrite(buffer, out_len, 1, fp);
109   fclose(fp);
110 }
111
112 void WriteEmf(FPDF_PAGE page, const char* pdf_name, int num) {
113   int width = static_cast<int>(FPDF_GetPageWidth(page));
114   int height = static_cast<int>(FPDF_GetPageHeight(page));
115
116   char filename[256];
117   snprintf(filename, sizeof(filename), "%s.%d.emf", pdf_name, num);
118
119   HDC dc = CreateEnhMetaFileA(NULL, filename, NULL, NULL);
120   
121   HRGN rgn = CreateRectRgn(0, 0, width, height); 
122   SelectClipRgn(dc, rgn); 
123   DeleteObject(rgn);
124
125   SelectObject(dc, GetStockObject(NULL_PEN));
126   SelectObject(dc, GetStockObject(WHITE_BRUSH));
127   // If a PS_NULL pen is used, the dimensions of the rectangle are 1 pixel less.
128   Rectangle(dc, 0, 0, width + 1, height + 1);
129
130   FPDF_RenderPage(dc, page, 0, 0, width, height, 0,
131                   FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
132
133   DeleteEnhMetaFile(CloseEnhMetaFile(dc));
134 }
135 #endif
136
137 int Form_Alert(IPDF_JSPLATFORM*, FPDF_WIDESTRING, FPDF_WIDESTRING, int, int) {
138   printf("Form_Alert called.\n");
139   return 0;
140 }
141
142 void Unsupported_Handler(UNSUPPORT_INFO*, int type) {
143   std::string feature = "Unknown";
144   switch (type) {
145     case FPDF_UNSP_DOC_XFAFORM:
146       feature = "XFA";
147       break;
148     case FPDF_UNSP_DOC_PORTABLECOLLECTION:
149       feature = "Portfolios_Packages";
150       break;
151     case FPDF_UNSP_DOC_ATTACHMENT:
152     case FPDF_UNSP_ANNOT_ATTACHMENT:
153       feature = "Attachment";
154       break;
155     case FPDF_UNSP_DOC_SECURITY:
156       feature = "Rights_Management";
157       break;
158     case FPDF_UNSP_DOC_SHAREDREVIEW:
159       feature = "Shared_Review";
160       break;
161     case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT:
162     case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM:
163     case FPDF_UNSP_DOC_SHAREDFORM_EMAIL:
164       feature = "Shared_Form";
165       break;
166     case FPDF_UNSP_ANNOT_3DANNOT:
167       feature = "3D";
168       break;
169     case FPDF_UNSP_ANNOT_MOVIE:
170       feature = "Movie";
171       break;
172     case FPDF_UNSP_ANNOT_SOUND:
173       feature = "Sound";
174       break;
175     case FPDF_UNSP_ANNOT_SCREEN_MEDIA:
176     case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
177       feature = "Screen";
178       break;
179     case FPDF_UNSP_ANNOT_SIG:
180       feature = "Digital_Signature";
181       break;
182   }
183   printf("Unsupported feature: %s.\n", feature.c_str());
184 }
185
186 bool ParseCommandLine(int argc, const char* argv[], OutputFormat* output_format,
187                       std::list<const char*>* files) {
188   *output_format = OUTPUT_NONE;
189   files->clear();
190
191   int cur_arg = 1;
192   if (cur_arg < argc) {
193     if (strcmp(argv[cur_arg], "--ppm") == 0)
194       *output_format = OUTPUT_PPM;
195 #ifdef _WIN32
196     if (strcmp(argv[cur_arg], "--emf") == 0)
197       *output_format = OUTPUT_EMF;
198     if (strcmp(argv[cur_arg], "--bmp") == 0)
199       *output_format = OUTPUT_BMP;
200 #endif
201     if (*output_format != OUTPUT_NONE)
202       cur_arg++;
203   }
204
205   if (cur_arg >= argc)
206     return false;
207
208   for (int i = cur_arg; i < argc; i++)
209     files->push_back(argv[i]);
210
211   return true;
212 }
213
214 class TestLoader {
215  public:
216   TestLoader(const char* pBuf, size_t len);
217
218   const char* m_pBuf;
219   size_t m_Len;
220 };
221
222 TestLoader::TestLoader(const char* pBuf, size_t len)
223     : m_pBuf(pBuf), m_Len(len) {
224 }
225
226 int Get_Block(void* param, unsigned long pos, unsigned char* pBuf,
227               unsigned long size) {
228   TestLoader* pLoader = (TestLoader*) param;
229   if (pos + size < pos || pos + size > pLoader->m_Len) return 0;
230   memcpy(pBuf, pLoader->m_pBuf + pos, size);
231   return 1;
232 }
233
234 bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
235   return true;
236 }
237
238 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
239 }
240
241 void RenderPdf(const char* name, const char* pBuf, size_t len,
242                OutputFormat format) {
243   printf("Rendering PDF file %s.\n", name);
244
245   IPDF_JSPLATFORM platform_callbacks;
246   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
247   platform_callbacks.version = 1;
248   platform_callbacks.app_alert = Form_Alert;
249
250   FPDF_FORMFILLINFO form_callbacks;
251   memset(&form_callbacks, '\0', sizeof(form_callbacks));
252   form_callbacks.version = 1;
253   form_callbacks.m_pJsPlatform = &platform_callbacks;
254
255   TestLoader loader(pBuf, len);
256
257   FPDF_FILEACCESS file_access;
258   memset(&file_access, '\0', sizeof(file_access));
259   file_access.m_FileLen = static_cast<unsigned long>(len);
260   file_access.m_GetBlock = Get_Block;
261   file_access.m_Param = &loader;
262
263   FX_FILEAVAIL file_avail;
264   memset(&file_avail, '\0', sizeof(file_avail));
265   file_avail.version = 1;
266   file_avail.IsDataAvail = Is_Data_Avail;
267
268   FX_DOWNLOADHINTS hints;
269   memset(&hints, '\0', sizeof(hints));
270   hints.version = 1;
271   hints.AddSegment = Add_Segment;
272
273   FPDF_DOCUMENT doc;
274   FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
275
276   (void) FPDFAvail_IsDocAvail(pdf_avail, &hints);
277
278   if (!FPDFAvail_IsLinearized(pdf_avail)) {
279     printf("Non-linearized path...\n");
280     doc = FPDF_LoadCustomDocument(&file_access, NULL);
281   } else {
282     printf("Linearized path...\n");
283     doc = FPDFAvail_GetDocument(pdf_avail, NULL);
284   }
285
286   (void) FPDF_GetDocPermissions(doc);
287   (void) FPDFAvail_IsFormAvail(pdf_avail, &hints);
288
289   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnviroument(doc, &form_callbacks);
290   FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
291   FPDF_SetFormFieldHighlightAlpha(form, 100);
292
293   int first_page = FPDFAvail_GetFirstPageNum(doc);
294   (void) FPDFAvail_IsPageAvail(pdf_avail, first_page, &hints);
295
296   int page_count = FPDF_GetPageCount(doc);
297   for (int i = 0; i < page_count; ++i) {
298     (void) FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
299   }
300
301   FORM_DoDocumentJSAction(form);
302   FORM_DoDocumentOpenAction(form);
303
304   for (int i = 0; i < page_count; ++i) {
305     FPDF_PAGE page = FPDF_LoadPage(doc, i);
306     FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
307     FORM_OnAfterLoadPage(page, form);
308     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
309
310     int width = static_cast<int>(FPDF_GetPageWidth(page));
311     int height = static_cast<int>(FPDF_GetPageHeight(page));
312     FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
313     FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
314
315     FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
316     FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
317     int stride = FPDFBitmap_GetStride(bitmap);
318     const char* buffer =
319         reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
320
321     switch (format) {
322 #ifdef _WIN32
323       case OUTPUT_BMP:
324         WriteBmp(name, i, buffer, stride, width, height);
325         break;
326
327       case OUTPUT_EMF:
328         WriteEmf(page, name, i);
329         break;
330 #endif
331       case OUTPUT_PPM:
332         WritePpm(name, i, buffer, stride, width, height);
333         break;
334       default:
335         break;
336     }
337
338     FPDFBitmap_Destroy(bitmap);
339
340     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
341     FORM_OnBeforeClosePage(page, form);
342     FPDFText_ClosePage(text_page);
343     FPDF_ClosePage(page);
344   }
345
346   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
347   FPDFDOC_ExitFormFillEnviroument(form);
348   FPDF_CloseDocument(doc);
349   FPDFAvail_Destroy(pdf_avail);
350
351   printf("Loaded, parsed and rendered %d pages.\n", page_count);
352 }
353
354 int main(int argc, const char* argv[]) {
355   v8::V8::InitializeICU();
356   OutputFormat format = OUTPUT_NONE;
357   std::list<const char*> files;
358   if (!ParseCommandLine(argc, argv, &format, &files)) {
359     printf("Usage: pdfium_test [OPTIONS] [FILE]\n");
360     printf("--ppm    write page images <pdf-name>.<page-number>.ppm\n");
361 #ifdef _WIN32
362     printf("--bmp    write page images <pdf-name>.<page-number>.bmp\n");
363     printf("--emf    write page meta files <pdf-name>.<page-number>.emf\n");
364 #endif
365     return 1;
366   }
367
368   FPDF_InitLibrary(NULL);
369
370   UNSUPPORT_INFO unsuppored_info;
371   memset(&unsuppored_info, '\0', sizeof(unsuppored_info));
372   unsuppored_info.version = 1;
373   unsuppored_info.FSDK_UnSupport_Handler = Unsupported_Handler;
374
375   FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
376
377   while (!files.empty()) {
378     const char* filename = files.front();
379     files.pop_front();
380     FILE* file = fopen(filename, "rb");
381     if (!file) {
382       fprintf(stderr, "Failed to open: %s\n", filename);
383       continue;
384     }
385     (void) fseek(file, 0, SEEK_END);
386     size_t len = ftell(file);
387     (void) fseek(file, 0, SEEK_SET);
388     char* pBuf = (char*) malloc(len);
389     size_t ret = fread(pBuf, 1, len, file);
390     (void) fclose(file);
391     if (ret != len) {
392       fprintf(stderr, "Failed to read: %s\n", filename);
393     } else {
394       RenderPdf(filename, pBuf, len, format);
395     }
396     free(pBuf);
397   }
398
399   FPDF_DestroyLibrary();
400
401   return 0;
402 }