Check if user provided more than one option for pdfium_test.
[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   for (; cur_arg < argc; ++cur_arg) {
193     if (strcmp(argv[cur_arg], "--ppm") == 0)
194       *output_format = OUTPUT_PPM;
195 #ifdef _WIN32
196     else if (strcmp(argv[cur_arg], "--emf") == 0)
197       *output_format = OUTPUT_EMF;
198     else if (strcmp(argv[cur_arg], "--bmp") == 0)
199       *output_format = OUTPUT_BMP;
200 #endif
201     else
202       break;
203   }
204
205   if (cur_arg > 2)  // Multiple options.
206     return false;
207
208   if (cur_arg >= argc)  // No input files.
209     return false;
210
211   for (int i = cur_arg; i < argc; i++)
212     files->push_back(argv[i]);
213
214   return true;
215 }
216
217 class TestLoader {
218  public:
219   TestLoader(const char* pBuf, size_t len);
220
221   const char* m_pBuf;
222   size_t m_Len;
223 };
224
225 TestLoader::TestLoader(const char* pBuf, size_t len)
226     : m_pBuf(pBuf), m_Len(len) {
227 }
228
229 int Get_Block(void* param, unsigned long pos, unsigned char* pBuf,
230               unsigned long size) {
231   TestLoader* pLoader = (TestLoader*) param;
232   if (pos + size < pos || pos + size > pLoader->m_Len) return 0;
233   memcpy(pBuf, pLoader->m_pBuf + pos, size);
234   return 1;
235 }
236
237 bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
238   return true;
239 }
240
241 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
242 }
243
244 void RenderPdf(const char* name, const char* pBuf, size_t len,
245                OutputFormat format) {
246   printf("Rendering PDF file %s.\n", name);
247
248   IPDF_JSPLATFORM platform_callbacks;
249   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
250   platform_callbacks.version = 1;
251   platform_callbacks.app_alert = Form_Alert;
252
253   FPDF_FORMFILLINFO form_callbacks;
254   memset(&form_callbacks, '\0', sizeof(form_callbacks));
255   form_callbacks.version = 1;
256   form_callbacks.m_pJsPlatform = &platform_callbacks;
257
258   TestLoader loader(pBuf, len);
259
260   FPDF_FILEACCESS file_access;
261   memset(&file_access, '\0', sizeof(file_access));
262   file_access.m_FileLen = static_cast<unsigned long>(len);
263   file_access.m_GetBlock = Get_Block;
264   file_access.m_Param = &loader;
265
266   FX_FILEAVAIL file_avail;
267   memset(&file_avail, '\0', sizeof(file_avail));
268   file_avail.version = 1;
269   file_avail.IsDataAvail = Is_Data_Avail;
270
271   FX_DOWNLOADHINTS hints;
272   memset(&hints, '\0', sizeof(hints));
273   hints.version = 1;
274   hints.AddSegment = Add_Segment;
275
276   FPDF_DOCUMENT doc;
277   FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
278
279   (void) FPDFAvail_IsDocAvail(pdf_avail, &hints);
280
281   if (!FPDFAvail_IsLinearized(pdf_avail)) {
282     printf("Non-linearized path...\n");
283     doc = FPDF_LoadCustomDocument(&file_access, NULL);
284   } else {
285     printf("Linearized path...\n");
286     doc = FPDFAvail_GetDocument(pdf_avail, NULL);
287   }
288
289   (void) FPDF_GetDocPermissions(doc);
290   (void) FPDFAvail_IsFormAvail(pdf_avail, &hints);
291
292   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnviroument(doc, &form_callbacks);
293   FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
294   FPDF_SetFormFieldHighlightAlpha(form, 100);
295
296   int first_page = FPDFAvail_GetFirstPageNum(doc);
297   (void) FPDFAvail_IsPageAvail(pdf_avail, first_page, &hints);
298
299   int page_count = FPDF_GetPageCount(doc);
300   for (int i = 0; i < page_count; ++i) {
301     (void) FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
302   }
303
304   FORM_DoDocumentJSAction(form);
305   FORM_DoDocumentOpenAction(form);
306
307   for (int i = 0; i < page_count; ++i) {
308     FPDF_PAGE page = FPDF_LoadPage(doc, i);
309     FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
310     FORM_OnAfterLoadPage(page, form);
311     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
312
313     int width = static_cast<int>(FPDF_GetPageWidth(page));
314     int height = static_cast<int>(FPDF_GetPageHeight(page));
315     FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
316     FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
317
318     FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
319     FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
320     int stride = FPDFBitmap_GetStride(bitmap);
321     const char* buffer =
322         reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
323
324     switch (format) {
325 #ifdef _WIN32
326       case OUTPUT_BMP:
327         WriteBmp(name, i, buffer, stride, width, height);
328         break;
329
330       case OUTPUT_EMF:
331         WriteEmf(page, name, i);
332         break;
333 #endif
334       case OUTPUT_PPM:
335         WritePpm(name, i, buffer, stride, width, height);
336         break;
337       default:
338         break;
339     }
340
341     FPDFBitmap_Destroy(bitmap);
342
343     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
344     FORM_OnBeforeClosePage(page, form);
345     FPDFText_ClosePage(text_page);
346     FPDF_ClosePage(page);
347   }
348
349   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
350   FPDFDOC_ExitFormFillEnviroument(form);
351   FPDF_CloseDocument(doc);
352   FPDFAvail_Destroy(pdf_avail);
353
354   printf("Loaded, parsed and rendered %d pages.\n", page_count);
355 }
356
357 int main(int argc, const char* argv[]) {
358   v8::V8::InitializeICU();
359   OutputFormat format = OUTPUT_NONE;
360   std::list<const char*> files;
361   if (!ParseCommandLine(argc, argv, &format, &files)) {
362     printf("Usage: pdfium_test [OPTION] [FILE]...\n");
363     printf("--ppm    write page images <pdf-name>.<page-number>.ppm\n");
364 #ifdef _WIN32
365     printf("--bmp    write page images <pdf-name>.<page-number>.bmp\n");
366     printf("--emf    write page meta files <pdf-name>.<page-number>.emf\n");
367 #endif
368     return 1;
369   }
370
371   FPDF_InitLibrary(NULL);
372
373   UNSUPPORT_INFO unsuppored_info;
374   memset(&unsuppored_info, '\0', sizeof(unsuppored_info));
375   unsuppored_info.version = 1;
376   unsuppored_info.FSDK_UnSupport_Handler = Unsupported_Handler;
377
378   FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
379
380   while (!files.empty()) {
381     const char* filename = files.front();
382     files.pop_front();
383     FILE* file = fopen(filename, "rb");
384     if (!file) {
385       fprintf(stderr, "Failed to open: %s\n", filename);
386       continue;
387     }
388     (void) fseek(file, 0, SEEK_END);
389     size_t len = ftell(file);
390     (void) fseek(file, 0, SEEK_SET);
391     char* pBuf = (char*) malloc(len);
392     size_t ret = fread(pBuf, 1, len, file);
393     (void) fclose(file);
394     if (ret != len) {
395       fprintf(stderr, "Failed to read: %s\n", filename);
396     } else {
397       RenderPdf(filename, pBuf, len, format);
398     }
399     free(pBuf);
400   }
401
402   FPDF_DestroyLibrary();
403
404   return 0;
405 }