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 }