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 <sstream>
12 #include <string>
13 #include <utility>
14 #include <vector>
15
16 #include "image_diff_png.h"
17 #include "public/fpdf_dataavail.h"
18 #include "public/fpdf_edit.h"
19 #include "public/fpdf_ext.h"
20 #include "public/fpdf_formfill.h"
21 #include "public/fpdf_text.h"
22 #include "public/fpdfview.h"
23 #include "testing/test_support.h"
24
25 #ifdef PDF_ENABLE_V8
26 #include "v8/include/libplatform/libplatform.h"
27 #include "v8/include/v8.h"
28 #endif // PDF_ENABLE_V8
29
30 #ifdef _WIN32
31 #define snprintf _snprintf
32 #endif
33
34 enum OutputFormat {
35 OUTPUT_NONE,
36 OUTPUT_PPM,
37 OUTPUT_PNG,
38 #ifdef _WIN32
39 OUTPUT_BMP,
40 OUTPUT_EMF,
41 #endif
42 };
43
44 struct Options {
OptionsOptions45 Options() : output_format(OUTPUT_NONE) { }
46
47 OutputFormat output_format;
48 std::string scale_factor_as_string;
49 std::string exe_path;
50 std::string bin_directory;
51 std::string font_directory;
52 };
53
CheckDimensions(int stride,int width,int height)54 static bool CheckDimensions(int stride, int width, int height) {
55 if (stride < 0 || width < 0 || height < 0)
56 return false;
57 if (height > 0 && width > INT_MAX / height)
58 return false;
59 return true;
60 }
61
WritePpm(const char * pdf_name,int num,const void * buffer_void,int stride,int width,int height)62 static void WritePpm(const char* pdf_name, int num, const void* buffer_void,
63 int stride, int width, int height) {
64 const char* buffer = reinterpret_cast<const char*>(buffer_void);
65
66 if (!CheckDimensions(stride, width, height))
67 return;
68
69 int out_len = width * height;
70 if (out_len > INT_MAX / 3)
71 return;
72 out_len *= 3;
73
74 char filename[256];
75 snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num);
76 FILE* fp = fopen(filename, "wb");
77 if (!fp)
78 return;
79 fprintf(fp, "P6\n# PDF test render\n%d %d\n255\n", width, height);
80 // Source data is B, G, R, unused.
81 // Dest data is R, G, B.
82 char* result = new char[out_len];
83 for (int h = 0; h < height; ++h) {
84 const char* src_line = buffer + (stride * h);
85 char* dest_line = result + (width * h * 3);
86 for (int w = 0; w < width; ++w) {
87 // R
88 dest_line[w * 3] = src_line[(w * 4) + 2];
89 // G
90 dest_line[(w * 3) + 1] = src_line[(w * 4) + 1];
91 // B
92 dest_line[(w * 3) + 2] = src_line[w * 4];
93 }
94 }
95 fwrite(result, out_len, 1, fp);
96 delete[] result;
97 fclose(fp);
98 }
99
WritePng(const char * pdf_name,int num,const void * buffer_void,int stride,int width,int height)100 static void WritePng(const char* pdf_name, int num, const void* buffer_void,
101 int stride, int width, int height) {
102 if (!CheckDimensions(stride, width, height))
103 return;
104
105 std::vector<unsigned char> png_encoding;
106 const unsigned char* buffer = static_cast<const unsigned char*>(buffer_void);
107 if (!image_diff_png::EncodeBGRAPNG(
108 buffer, width, height, stride, false, &png_encoding)) {
109 fprintf(stderr, "Failed to convert bitmap to PNG\n");
110 return;
111 }
112
113 char filename[256];
114 int chars_formatted = snprintf(
115 filename, sizeof(filename), "%s.%d.png", pdf_name, num);
116 if (chars_formatted < 0 ||
117 static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
118 fprintf(stderr, "Filname %s is too long\n", filename);
119 return;
120 }
121
122 FILE* fp = fopen(filename, "wb");
123 if (!fp) {
124 fprintf(stderr, "Failed to open %s for output\n", filename);
125 return;
126 }
127
128 size_t bytes_written = fwrite(
129 &png_encoding.front(), 1, png_encoding.size(), fp);
130 if (bytes_written != png_encoding.size())
131 fprintf(stderr, "Failed to write to %s\n", filename);
132
133 (void)fclose(fp);
134 }
135
136 #ifdef _WIN32
WriteBmp(const char * pdf_name,int num,const void * buffer,int stride,int width,int height)137 static void WriteBmp(const char* pdf_name, int num, const void* buffer,
138 int stride, int width, int height) {
139 if (!CheckDimensions(stride, width, height))
140 return;
141
142 int out_len = stride * height;
143 if (out_len > INT_MAX / 3)
144 return;
145
146 char filename[256];
147 snprintf(filename, sizeof(filename), "%s.%d.bmp", pdf_name, num);
148 FILE* fp = fopen(filename, "wb");
149 if (!fp)
150 return;
151
152 BITMAPINFO bmi = {};
153 bmi.bmiHeader.biSize = sizeof(bmi) - sizeof(RGBQUAD);
154 bmi.bmiHeader.biWidth = width;
155 bmi.bmiHeader.biHeight = -height; // top-down image
156 bmi.bmiHeader.biPlanes = 1;
157 bmi.bmiHeader.biBitCount = 32;
158 bmi.bmiHeader.biCompression = BI_RGB;
159 bmi.bmiHeader.biSizeImage = 0;
160
161 BITMAPFILEHEADER file_header = {};
162 file_header.bfType = 0x4d42;
163 file_header.bfSize = sizeof(file_header) + bmi.bmiHeader.biSize + out_len;
164 file_header.bfOffBits = file_header.bfSize - out_len;
165
166 fwrite(&file_header, sizeof(file_header), 1, fp);
167 fwrite(&bmi, bmi.bmiHeader.biSize, 1, fp);
168 fwrite(buffer, out_len, 1, fp);
169 fclose(fp);
170 }
171
WriteEmf(FPDF_PAGE page,const char * pdf_name,int num)172 void WriteEmf(FPDF_PAGE page, const char* pdf_name, int num) {
173 int width = static_cast<int>(FPDF_GetPageWidth(page));
174 int height = static_cast<int>(FPDF_GetPageHeight(page));
175
176 char filename[256];
177 snprintf(filename, sizeof(filename), "%s.%d.emf", pdf_name, num);
178
179 HDC dc = CreateEnhMetaFileA(nullptr, filename, nullptr, nullptr);
180
181 HRGN rgn = CreateRectRgn(0, 0, width, height);
182 SelectClipRgn(dc, rgn);
183 DeleteObject(rgn);
184
185 SelectObject(dc, GetStockObject(NULL_PEN));
186 SelectObject(dc, GetStockObject(WHITE_BRUSH));
187 // If a PS_NULL pen is used, the dimensions of the rectangle are 1 pixel less.
188 Rectangle(dc, 0, 0, width + 1, height + 1);
189
190 FPDF_RenderPage(dc, page, 0, 0, width, height, 0,
191 FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
192
193 DeleteEnhMetaFile(CloseEnhMetaFile(dc));
194 }
195 #endif
196
ExampleAppAlert(IPDF_JSPLATFORM *,FPDF_WIDESTRING msg,FPDF_WIDESTRING,int,int)197 int ExampleAppAlert(IPDF_JSPLATFORM*, FPDF_WIDESTRING msg, FPDF_WIDESTRING,
198 int, int) {
199 std::wstring platform_string = GetPlatformWString(msg);
200 printf("Alert: %ls\n", platform_string.c_str());
201 return 0;
202 }
203
ExampleDocGotoPage(IPDF_JSPLATFORM *,int pageNumber)204 void ExampleDocGotoPage(IPDF_JSPLATFORM*, int pageNumber) {
205 printf("Goto Page: %d\n", pageNumber);
206 }
207
ExampleUnsupportedHandler(UNSUPPORT_INFO *,int type)208 void ExampleUnsupportedHandler(UNSUPPORT_INFO*, int type) {
209 std::string feature = "Unknown";
210 switch (type) {
211 case FPDF_UNSP_DOC_XFAFORM:
212 feature = "XFA";
213 break;
214 case FPDF_UNSP_DOC_PORTABLECOLLECTION:
215 feature = "Portfolios_Packages";
216 break;
217 case FPDF_UNSP_DOC_ATTACHMENT:
218 case FPDF_UNSP_ANNOT_ATTACHMENT:
219 feature = "Attachment";
220 break;
221 case FPDF_UNSP_DOC_SECURITY:
222 feature = "Rights_Management";
223 break;
224 case FPDF_UNSP_DOC_SHAREDREVIEW:
225 feature = "Shared_Review";
226 break;
227 case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT:
228 case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM:
229 case FPDF_UNSP_DOC_SHAREDFORM_EMAIL:
230 feature = "Shared_Form";
231 break;
232 case FPDF_UNSP_ANNOT_3DANNOT:
233 feature = "3D";
234 break;
235 case FPDF_UNSP_ANNOT_MOVIE:
236 feature = "Movie";
237 break;
238 case FPDF_UNSP_ANNOT_SOUND:
239 feature = "Sound";
240 break;
241 case FPDF_UNSP_ANNOT_SCREEN_MEDIA:
242 case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
243 feature = "Screen";
244 break;
245 case FPDF_UNSP_ANNOT_SIG:
246 feature = "Digital_Signature";
247 break;
248 }
249 printf("Unsupported feature: %s.\n", feature.c_str());
250 }
251
ParseCommandLine(const std::vector<std::string> & args,Options * options,std::list<std::string> * files)252 bool ParseCommandLine(const std::vector<std::string>& args,
253 Options* options, std::list<std::string>* files) {
254 if (args.empty()) {
255 return false;
256 }
257 options->exe_path = args[0];
258 size_t cur_idx = 1;
259 for (; cur_idx < args.size(); ++cur_idx) {
260 const std::string& cur_arg = args[cur_idx];
261 if (cur_arg == "--ppm") {
262 if (options->output_format != OUTPUT_NONE) {
263 fprintf(stderr, "Duplicate or conflicting --ppm argument\n");
264 return false;
265 }
266 options->output_format = OUTPUT_PPM;
267 } else if (cur_arg == "--png") {
268 if (options->output_format != OUTPUT_NONE) {
269 fprintf(stderr, "Duplicate or conflicting --png argument\n");
270 return false;
271 }
272 options->output_format = OUTPUT_PNG;
273 } else if (cur_arg.size() > 11 &&
274 cur_arg.compare(0, 11, "--font-dir=") == 0) {
275 if (!options->font_directory.empty()) {
276 fprintf(stderr, "Duplicate --font-dir argument\n");
277 return false;
278 }
279 options->font_directory = cur_arg.substr(11);
280 }
281 #ifdef _WIN32
282 else if (cur_arg == "--emf") {
283 if (options->output_format != OUTPUT_NONE) {
284 fprintf(stderr, "Duplicate or conflicting --emf argument\n");
285 return false;
286 }
287 options->output_format = OUTPUT_EMF;
288 }
289 else if (cur_arg == "--bmp") {
290 if (options->output_format != OUTPUT_NONE) {
291 fprintf(stderr, "Duplicate or conflicting --bmp argument\n");
292 return false;
293 }
294 options->output_format = OUTPUT_BMP;
295 }
296 #endif // _WIN32
297 #ifdef PDF_ENABLE_V8
298 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
299 else if (cur_arg.size() > 10 && cur_arg.compare(0, 10, "--bin-dir=") == 0) {
300 if (!options->bin_directory.empty()) {
301 fprintf(stderr, "Duplicate --bin-dir argument\n");
302 return false;
303 }
304 options->bin_directory = cur_arg.substr(10);
305 }
306 #endif // V8_USE_EXTERNAL_STARTUP_DATA
307 #endif // PDF_ENABLE_V8
308 else if (cur_arg.size() > 8 && cur_arg.compare(0, 8, "--scale=") == 0) {
309 if (!options->scale_factor_as_string.empty()) {
310 fprintf(stderr, "Duplicate --scale argument\n");
311 return false;
312 }
313 options->scale_factor_as_string = cur_arg.substr(8);
314 }
315 else
316 break;
317 }
318 if (cur_idx >= args.size()) {
319 fprintf(stderr, "No input files.\n");
320 return false;
321 }
322 for (size_t i = cur_idx; i < args.size(); i++) {
323 files->push_back(args[i]);
324 }
325 return true;
326 }
327
Is_Data_Avail(FX_FILEAVAIL * pThis,size_t offset,size_t size)328 FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
329 return true;
330 }
331
Add_Segment(FX_DOWNLOADHINTS * pThis,size_t offset,size_t size)332 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
333 }
334
RenderPage(const std::string & name,const FPDF_DOCUMENT & doc,const FPDF_FORMHANDLE & form,const int page_index,const Options & options)335 bool RenderPage(const std::string& name,
336 const FPDF_DOCUMENT& doc,
337 const FPDF_FORMHANDLE& form,
338 const int page_index,
339 const Options& options) {
340 FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
341 if (!page) {
342 return false;
343 }
344 FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
345 FORM_OnAfterLoadPage(page, form);
346 FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
347
348 double scale = 1.0;
349 if (!options.scale_factor_as_string.empty()) {
350 std::stringstream(options.scale_factor_as_string) >> scale;
351 }
352 int width = static_cast<int>(FPDF_GetPageWidth(page) * scale);
353 int height = static_cast<int>(FPDF_GetPageHeight(page) * scale);
354 int alpha = FPDFPage_HasTransparency(page) ? 1 : 0;
355 FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, alpha);
356 if (!bitmap) {
357 fprintf(stderr, "Page was too large to be rendered.\n");
358 return false;
359 }
360 FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF;
361 FPDFBitmap_FillRect(bitmap, 0, 0, width, height, fill_color);
362 FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
363
364 FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
365 int stride = FPDFBitmap_GetStride(bitmap);
366 const char* buffer =
367 reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
368
369 switch (options.output_format) {
370 #ifdef _WIN32
371 case OUTPUT_BMP:
372 WriteBmp(name.c_str(), page_index, buffer, stride, width, height);
373 break;
374
375 case OUTPUT_EMF:
376 WriteEmf(page, name.c_str(), page_index);
377 break;
378 #endif
379 case OUTPUT_PNG:
380 WritePng(name.c_str(), page_index, buffer, stride, width, height);
381 break;
382
383 case OUTPUT_PPM:
384 WritePpm(name.c_str(), page_index, buffer, stride, width, height);
385 break;
386
387 default:
388 break;
389 }
390
391 FPDFBitmap_Destroy(bitmap);
392 FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
393 FORM_OnBeforeClosePage(page, form);
394 FPDFText_ClosePage(text_page);
395 FPDF_ClosePage(page);
396 return true;
397 }
398
RenderPdf(const std::string & name,const char * pBuf,size_t len,const Options & options)399 void RenderPdf(const std::string& name, const char* pBuf, size_t len,
400 const Options& options) {
401 fprintf(stderr, "Rendering PDF file %s.\n", name.c_str());
402
403 IPDF_JSPLATFORM platform_callbacks;
404 memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
405 platform_callbacks.version = 3;
406 platform_callbacks.app_alert = ExampleAppAlert;
407 platform_callbacks.Doc_gotoPage = ExampleDocGotoPage;
408
409 FPDF_FORMFILLINFO form_callbacks;
410 memset(&form_callbacks, '\0', sizeof(form_callbacks));
411 #ifdef PDF_ENABLE_XFA
412 form_callbacks.version = 2;
413 #else // PDF_ENABLE_XFA
414 form_callbacks.version = 1;
415 #endif // PDF_ENABLE_XFA
416 form_callbacks.m_pJsPlatform = &platform_callbacks;
417
418 TestLoader loader(pBuf, len);
419 FPDF_FILEACCESS file_access;
420 memset(&file_access, '\0', sizeof(file_access));
421 file_access.m_FileLen = static_cast<unsigned long>(len);
422 file_access.m_GetBlock = TestLoader::GetBlock;
423 file_access.m_Param = &loader;
424
425 FX_FILEAVAIL file_avail;
426 memset(&file_avail, '\0', sizeof(file_avail));
427 file_avail.version = 1;
428 file_avail.IsDataAvail = Is_Data_Avail;
429
430 FX_DOWNLOADHINTS hints;
431 memset(&hints, '\0', sizeof(hints));
432 hints.version = 1;
433 hints.AddSegment = Add_Segment;
434
435 FPDF_DOCUMENT doc;
436 int nRet = PDF_DATA_NOTAVAIL;
437 bool bIsLinearized = false;
438 FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
439
440 if (FPDFAvail_IsLinearized(pdf_avail) == PDF_LINEARIZED) {
441 fprintf(stderr, "Linearized path...\n");
442 doc = FPDFAvail_GetDocument(pdf_avail, nullptr);
443 if (doc) {
444 while (nRet == PDF_DATA_NOTAVAIL) {
445 nRet = FPDFAvail_IsDocAvail(pdf_avail, &hints);
446 }
447 if (nRet == PDF_DATA_ERROR) {
448 fprintf(stderr, "Unknown error in checking if doc was available.\n");
449 return;
450 }
451 nRet = FPDFAvail_IsFormAvail(pdf_avail, &hints);
452 if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) {
453 fprintf(stderr,
454 "Error %d was returned in checking if form was available.\n",
455 nRet);
456 return;
457 }
458 bIsLinearized = true;
459 }
460 } else {
461 fprintf(stderr, "Non-linearized path...\n");
462 doc = FPDF_LoadCustomDocument(&file_access, nullptr);
463 }
464
465 if (!doc) {
466 unsigned long err = FPDF_GetLastError();
467 fprintf(stderr, "Load pdf docs unsuccessful: ");
468 switch (err) {
469 case FPDF_ERR_SUCCESS:
470 fprintf(stderr, "Success");
471 break;
472 case FPDF_ERR_UNKNOWN:
473 fprintf(stderr, "Unknown error");
474 break;
475 case FPDF_ERR_FILE:
476 fprintf(stderr, "File not found or could not be opened");
477 break;
478 case FPDF_ERR_FORMAT:
479 fprintf(stderr, "File not in PDF format or corrupted");
480 break;
481 case FPDF_ERR_PASSWORD:
482 fprintf(stderr, "Password required or incorrect password");
483 break;
484 case FPDF_ERR_SECURITY:
485 fprintf(stderr, "Unsupported security scheme");
486 break;
487 case FPDF_ERR_PAGE:
488 fprintf(stderr, "Page not found or content error");
489 break;
490 default:
491 fprintf(stderr, "Unknown error %ld", err);
492 }
493 fprintf(stderr, ".\n");
494
495 FPDFAvail_Destroy(pdf_avail);
496 return;
497 }
498
499 (void)FPDF_GetDocPermissions(doc);
500
501 FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
502 #ifdef PDF_ENABLE_XFA
503 int docType = DOCTYPE_PDF;
504 if (FPDF_HasXFAField(doc, &docType) && docType != DOCTYPE_PDF &&
505 !FPDF_LoadXFA(doc)) {
506 fprintf(stderr, "LoadXFA unsuccessful, continuing anyway.\n");
507 }
508 #endif // PDF_ENABLE_XFA
509 FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
510 FPDF_SetFormFieldHighlightAlpha(form, 100);
511
512 FORM_DoDocumentJSAction(form);
513 FORM_DoDocumentOpenAction(form);
514
515 int page_count = FPDF_GetPageCount(doc);
516 int rendered_pages = 0;
517 int bad_pages = 0;
518 for (int i = 0; i < page_count; ++i) {
519 if (bIsLinearized) {
520 nRet = PDF_DATA_NOTAVAIL;
521 while (nRet == PDF_DATA_NOTAVAIL) {
522 nRet = FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
523 }
524 if (nRet == PDF_DATA_ERROR) {
525 fprintf(stderr, "Unknown error in checking if page %d is available.\n",
526 i);
527 return;
528 }
529 }
530 if (RenderPage(name, doc, form, i, options)) {
531 ++rendered_pages;
532 } else {
533 ++bad_pages;
534 }
535 }
536
537 FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
538
539 #ifdef PDF_ENABLE_XFA
540 // Note: The shut down order here is the reverse of the non-XFA branch order.
541 // Need to work out if this is required, and if it is, the lifetimes of
542 // objects owned by |doc| that |form| reference.
543 FPDF_CloseDocument(doc);
544 FPDFDOC_ExitFormFillEnvironment(form);
545 #else // PDF_ENABLE_XFA
546 FPDFDOC_ExitFormFillEnvironment(form);
547 FPDF_CloseDocument(doc);
548 #endif // PDF_ENABLE_XFA
549
550 FPDFAvail_Destroy(pdf_avail);
551
552 fprintf(stderr, "Rendered %d pages.\n", rendered_pages);
553 fprintf(stderr, "Skipped %d bad pages.\n", bad_pages);
554 }
555
556 static const char usage_string[] =
557 "Usage: pdfium_test [OPTION] [FILE]...\n"
558 " --bin-dir=<path> - override path to v8 external data\n"
559 " --font-dir=<path> - override path to external fonts\n"
560 " --scale=<number> - scale output size by number (e.g. 0.5)\n"
561 #ifdef _WIN32
562 " --bmp - write page images <pdf-name>.<page-number>.bmp\n"
563 " --emf - write page meta files <pdf-name>.<page-number>.emf\n"
564 #endif // _WIN32
565 " --png - write page images <pdf-name>.<page-number>.png\n"
566 " --ppm - write page images <pdf-name>.<page-number>.ppm\n";
567
main(int argc,const char * argv[])568 int main(int argc, const char* argv[]) {
569 std::vector<std::string> args(argv, argv + argc);
570 Options options;
571 std::list<std::string> files;
572 if (!ParseCommandLine(args, &options, &files)) {
573 fprintf(stderr, "%s", usage_string);
574 return 1;
575 }
576
577 #ifdef PDF_ENABLE_V8
578 v8::Platform* platform;
579 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
580 v8::StartupData natives;
581 v8::StartupData snapshot;
582 InitializeV8ForPDFium(options.exe_path, options.bin_directory, &natives,
583 &snapshot, &platform);
584 #else // V8_USE_EXTERNAL_STARTUP_DATA
585 InitializeV8ForPDFium(&platform);
586 #endif // V8_USE_EXTERNAL_STARTUP_DATA
587 #endif // PDF_ENABLE_V8
588
589 FPDF_LIBRARY_CONFIG config;
590 config.version = 2;
591 config.m_pUserFontPaths = nullptr;
592 config.m_pIsolate = nullptr;
593 config.m_v8EmbedderSlot = 0;
594
595 const char* path_array[2];
596 if (!options.font_directory.empty()) {
597 path_array[0] = options.font_directory.c_str();
598 path_array[1] = nullptr;
599 config.m_pUserFontPaths = path_array;
600 }
601 FPDF_InitLibraryWithConfig(&config);
602
603 UNSUPPORT_INFO unsuppored_info;
604 memset(&unsuppored_info, '\0', sizeof(unsuppored_info));
605 unsuppored_info.version = 1;
606 unsuppored_info.FSDK_UnSupport_Handler = ExampleUnsupportedHandler;
607
608 FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
609
610 while (!files.empty()) {
611 std::string filename = files.front();
612 files.pop_front();
613 size_t file_length = 0;
614 std::unique_ptr<char, pdfium::FreeDeleter> file_contents =
615 GetFileContents(filename.c_str(), &file_length);
616 if (file_contents)
617 RenderPdf(filename, file_contents.get(), file_length, options);
618 }
619
620 FPDF_DestroyLibrary();
621 #ifdef PDF_ENABLE_V8
622 v8::V8::ShutdownPlatform();
623 delete platform;
624 #endif // PDF_ENABLE_V8
625
626 return 0;
627 }
628