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