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 static void WritePpm(const char* pdf_name, int num,
  26                      const char* buffer, int stride, int width, int height) {
  27   if (stride < 0 || width < 0 || height < 0)
  28     return;
  29   if (height > 0 && width > INT_MAX / height)
  30     return;
  31   int out_len = width * height;
  32   if (out_len > INT_MAX / 3)
  33     return;
  34   out_len *= 3;
  35
  36   char filename[256];
  37   snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num);
  38   FILE* fp = fopen(filename, "wb");
  39   if (!fp)
  40     return;
  41   fprintf(fp, "P6\n# PDF test render\n%d %d\n255\n", width, height);
  42   // Source data is B, G, R, unused.
  43   // Dest data is R, G, B.
  44   char* result = new char[out_len];
  45   if (result) {
  46     for (int h = 0; h < height; ++h) {
  47       const char* src_line = buffer + (stride * h);
  48       char* dest_line = result + (width * h * 3);
  49       for (int w = 0; w < width; ++w) {
  50         // R
  51         dest_line[w * 3] = src_line[(w * 4) + 2];
  52         // G
  53         dest_line[(w * 3) + 1] = src_line[(w * 4) + 1];
  54         // B
  55         dest_line[(w * 3) + 2] = src_line[w * 4];
  56       }
  57     }
  58     fwrite(result, out_len, 1, fp);
  59     delete [] result;
  60   }
  61   fclose(fp);
  62 }
  63
  64 int Form_Alert(IPDF_JSPLATFORM*, FPDF_WIDESTRING, FPDF_WIDESTRING, int, int) {
  65   printf("Form_Alert called.\n");
  66   return 0;
  67 }
  68
  69 void Unsupported_Handler(UNSUPPORT_INFO*, int type) {
  70   std::string feature = "Unknown";
  71   switch (type) {
  72     case FPDF_UNSP_DOC_XFAFORM:
  73       feature = "XFA";
  74       break;
  75     case FPDF_UNSP_DOC_PORTABLECOLLECTION:
  76       feature = "Portfolios_Packages";
  77       break;
  78     case FPDF_UNSP_DOC_ATTACHMENT:
  79     case FPDF_UNSP_ANNOT_ATTACHMENT:
  80       feature = "Attachment";
  81       break;
  82     case FPDF_UNSP_DOC_SECURITY:
  83       feature = "Rights_Management";
  84       break;
  85     case FPDF_UNSP_DOC_SHAREDREVIEW:
  86       feature = "Shared_Review";
  87       break;
  88     case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT:
  89     case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM:
  90     case FPDF_UNSP_DOC_SHAREDFORM_EMAIL:
  91       feature = "Shared_Form";
  92       break;
  93     case FPDF_UNSP_ANNOT_3DANNOT:
  94       feature = "3D";
  95       break;
  96     case FPDF_UNSP_ANNOT_MOVIE:
  97       feature = "Movie";
  98       break;
  99     case FPDF_UNSP_ANNOT_SOUND:
 100       feature = "Sound";
 101       break;
 102     case FPDF_UNSP_ANNOT_SCREEN_MEDIA:
 103     case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
 104       feature = "Screen";
 105       break;
 106     case FPDF_UNSP_ANNOT_SIG:
 107       feature = "Digital_Signature";
 108       break;
 109   }
 110   printf("Unsupported feature: %s.\n", feature.c_str());
 111 }
 112
 113 bool ParseCommandLine(int argc, const char* argv[], bool* write_images,
 114                       std::list<const char*>* files) {
 115   *write_images = false;
 116   files->clear();
 117
 118   int cur_arg = 1;
 119   if (cur_arg < argc &&
 120       strcmp(argv[cur_arg], "--write_images") == 0) {
 121     *write_images = true;
 122     cur_arg++;
 123   }
 124
 125   if (cur_arg >= argc)
 126     return false;
 127
 128   for (int i = cur_arg; i < argc; i++)
 129     files->push_back(argv[i]);
 130
 131   return true;
 132 }
 133
 134 class TestLoader {
 135  public:
 136   TestLoader(const char* pBuf, size_t len);
 137
 138   const char* m_pBuf;
 139   size_t m_Len;
 140 };
 141
 142 TestLoader::TestLoader(const char* pBuf, size_t len)
 143     : m_pBuf(pBuf), m_Len(len) {
 144 }
 145
 146 int Get_Block(void* param, unsigned long pos, unsigned char* pBuf,
 147               unsigned long size) {
 148   TestLoader* pLoader = (TestLoader*) param;
 149   if (pos + size < pos || pos + size > pLoader->m_Len) return 0;
 150   memcpy(pBuf, pLoader->m_pBuf + pos, size);
 151   return 1;
 152 }
 153
 154 bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
 155   return true;
 156 }
 157
 158 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
 159 }
 160
 161 void RenderPdf(const char* name, const char* pBuf, size_t len,
 162                bool write_images) {
 163   printf("Rendering PDF file %s.\n", name);
 164
 165   IPDF_JSPLATFORM platform_callbacks;
 166   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
 167   platform_callbacks.version = 1;
 168   platform_callbacks.app_alert = Form_Alert;
 169
 170   FPDF_FORMFILLINFO form_callbacks;
 171   memset(&form_callbacks, '\0', sizeof(form_callbacks));
 172   form_callbacks.version = 1;
 173   form_callbacks.m_pJsPlatform = &platform_callbacks;
 174
 175   TestLoader loader(pBuf, len);
 176
 177   FPDF_FILEACCESS file_access;
 178   memset(&file_access, '\0', sizeof(file_access));
 179   file_access.m_FileLen = static_cast<unsigned long>(len);
 180   file_access.m_GetBlock = Get_Block;
 181   file_access.m_Param = &loader;
 182
 183   FX_FILEAVAIL file_avail;
 184   memset(&file_avail, '\0', sizeof(file_avail));
 185   file_avail.version = 1;
 186   file_avail.IsDataAvail = Is_Data_Avail;
 187
 188   FX_DOWNLOADHINTS hints;
 189   memset(&hints, '\0', sizeof(hints));
 190   hints.version = 1;
 191   hints.AddSegment = Add_Segment;
 192
 193   FPDF_DOCUMENT doc;
 194   FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
 195
 196   (void) FPDFAvail_IsDocAvail(pdf_avail, &hints);
 197
 198   if (!FPDFAvail_IsLinearized(pdf_avail)) {
 199     printf("Non-linearized path...\n");
 200     doc = FPDF_LoadCustomDocument(&file_access, NULL);
 201   } else {
 202     printf("Linearized path...\n");
 203     doc = FPDFAvail_GetDocument(pdf_avail, NULL);
 204   }
 205
 206   (void) FPDF_GetDocPermissions(doc);
 207   (void) FPDFAvail_IsFormAvail(pdf_avail, &hints);
 208
 209   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnviroument(doc, &form_callbacks);
 210   FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
 211   FPDF_SetFormFieldHighlightAlpha(form, 100);
 212
 213   int first_page = FPDFAvail_GetFirstPageNum(doc);
 214   (void) FPDFAvail_IsPageAvail(pdf_avail, first_page, &hints);
 215
 216   int page_count = FPDF_GetPageCount(doc);
 217   for (int i = 0; i < page_count; ++i) {
 218     (void) FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
 219   }
 220
 221   FORM_DoDocumentJSAction(form);
 222   FORM_DoDocumentOpenAction(form);
 223
 224   for (int i = 0; i < page_count; ++i) {
 225     FPDF_PAGE page = FPDF_LoadPage(doc, i);
 226     FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
 227     FORM_OnAfterLoadPage(page, form);
 228     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
 229
 230     int width = static_cast<int>(FPDF_GetPageWidth(page));
 231     int height = static_cast<int>(FPDF_GetPageHeight(page));
 232     FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
 233     FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 255, 255, 255, 255);
 234
 235     FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
 236     FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
 237     if (write_images) {
 238       const char* buffer = reinterpret_cast<const char*>(
 239           FPDFBitmap_GetBuffer(bitmap));
 240       int stride = FPDFBitmap_GetStride(bitmap);
 241       WritePpm(name, i, buffer, stride, width, height);
 242     }
 243
 244     FPDFBitmap_Destroy(bitmap);
 245
 246     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
 247     FORM_OnBeforeClosePage(page, form);
 248     FPDFText_ClosePage(text_page);
 249     FPDF_ClosePage(page);
 250   }
 251
 252   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
 253   FPDFDOC_ExitFormFillEnviroument(form);
 254   FPDF_CloseDocument(doc);
 255   FPDFAvail_Destroy(pdf_avail);
 256
 257   printf("Loaded, parsed and rendered %d pages.\n", page_count);
 258 }
 259
 260 int main(int argc, const char* argv[]) {
 261   v8::V8::InitializeICU();
 262   bool write_images = false;
 263   std::list<const char*> files;
 264   if (!ParseCommandLine(argc, argv, &write_images, &files)) {
 265     printf("Usage is: test [--write_images] /path/to/pdf\n");
 266     printf("--write_images - to write page images <pdf-name>.<page-number>.ppm\n");
 267     return 1;
 268   }
 269
 270   FPDF_InitLibrary(NULL);
 271
 272   UNSUPPORT_INFO unsuppored_info;
 273   memset(&unsuppored_info, '\0', sizeof(unsuppored_info));
 274   unsuppored_info.version = 1;
 275   unsuppored_info.FSDK_UnSupport_Handler = Unsupported_Handler;
 276
 277   FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
 278
 279   while (!files.empty()) {
 280     const char* filename = files.front();
 281     files.pop_front();
 282     FILE* file = fopen(filename, "rb");
 283     if (!file) {
 284       fprintf(stderr, "Failed to open: %s\n", filename);
 285       continue;
 286     }
 287     (void) fseek(file, 0, SEEK_END);
 288     size_t len = ftell(file);
 289     (void) fseek(file, 0, SEEK_SET);
 290     char* pBuf = (char*) malloc(len);
 291     size_t ret = fread(pBuf, 1, len, file);
 292     (void) fclose(file);
 293     if (ret != len) {
 294       fprintf(stderr, "Failed to read: %s\n", filename);
 295     } else {
 296       RenderPdf(filename, pBuf, len, write_images);
 297     }
 298     free(pBuf);
 299   }
 300
 301   FPDF_DestroyLibrary();
 302
 303   return 0;
 304 }
 305