Add output scale factor command line parameter to pdfium_test.

samples/pdfium_test.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <wchar.h>
 
 #include <list>
 #include <string>
+#include <sstream>

[Lei Zhang, 2015/01/29 22:15:18]

nit: alphabetical order

[Tom Sepez, 2015/01/29 23:37:32]

Done.

 #include <utility>
 #include <vector>
 
 #include "../fpdfsdk/include/fpdf_dataavail.h"
 #include "../fpdfsdk/include/fpdf_ext.h"
 #include "../fpdfsdk/include/fpdfformfill.h"
 #include "../fpdfsdk/include/fpdftext.h"
 #include "../fpdfsdk/include/fpdfview.h"
 #include "../core/include/fxcrt/fx_system.h"
 #include "v8/include/v8.h"
@@ skipping 11 matching lines @@
 #ifdef _WIN32
   OUTPUT_BMP,
   OUTPUT_EMF,
 #endif
 };
 
 struct Options {
   Options() : output_format(OUTPUT_NONE) { }
 
   OutputFormat output_format;
+  std::string scale_factor_as_string;
   std::string exe_path;
   std::string bin_directory;
 };
 
 // Reads the entire contents of a file into a newly malloc'd buffer.
 static char* GetFileContents(const char* filename, size_t* retlen) {
   FILE* file = fopen(filename, "rb");
   if (!file) {
     fprintf(stderr, "Failed to open: %s\n", filename);
     return NULL;
@@ skipping 256 matching lines @@
 #endif  // _WIN32
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
     else if (cur_arg.size() > 10 && cur_arg.compare(0, 10, "--bin-dir=") == 0) {
       if (!options->bin_directory.empty()) {
         fprintf(stderr, "Duplicate --bin-dir argument\n");
         return false;
       }
       options->bin_directory = cur_arg.substr(10);
     }
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
+    else if (cur_arg.size() > 8 && cur_arg.compare(0, 8, "--scale=") == 0) {
+      if (!options->scale_factor_as_string.empty()) {
+        fprintf(stderr, "Duplicate --scale argument\n");
+        return false;
+      }
+      options->scale_factor_as_string = cur_arg.substr(8);
+    }
     else
       break;
   }
   if (cur_idx >= args.size()) {
     fprintf(stderr, "No input files.\n");
     return false;
   }
   for (size_t i = cur_idx; i < args.size(); i++) {
     files->push_back(args[i]);
   }
@@ skipping 21 matching lines @@
 }
 
 bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
   return true;
 }
 
 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
 }
 
 void RenderPdf(const std::string& name, const char* pBuf, size_t len,
-               OutputFormat format) {
+               const Options& options) {
   printf("Rendering PDF file %s.\n", name.c_str());
 
   IPDF_JSPLATFORM platform_callbacks;
   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
   platform_callbacks.version = 1;
   platform_callbacks.app_alert = Form_Alert;
 
   FPDF_FORMFILLINFO form_callbacks;
   memset(&form_callbacks, '\0', sizeof(form_callbacks));
   form_callbacks.version = 2;
@@ skipping 58 matching lines @@
     if (!page) {
         bad_pages ++;
         continue;
     }
     FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
     FORM_OnAfterLoadPage(page, form);
     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
 
     int width = static_cast<int>(FPDF_GetPageWidth(page));
     int height = static_cast<int>(FPDF_GetPageHeight(page));
+    if (!options.scale_factor_as_string.empty()) {
+      double scale;
+      std::stringstream(options.scale_factor_as_string) >> scale;

[Lei Zhang, 2015/01/29 22:15:18]

Is this the preferred way to do StringToDouble() in the absense of
string_number_conversions.h? What happens when the input is invalid?

+      width *= scale;
+      height *= scale;
+    }
+
     FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
     FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
-
     FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
     rendered_pages ++;
 
     FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
     int stride = FPDFBitmap_GetStride(bitmap);
     const char* buffer =
         reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
 
-    switch (format) {
+    switch (options.output_format) {
 #ifdef _WIN32
       case OUTPUT_BMP:
         WriteBmp(name.c_str(), i, buffer, stride, width, height);
         break;
 
       case OUTPUT_EMF:
         WriteEmf(page, name.c_str(), i);
         break;
 #endif
       case OUTPUT_PPM:
@@ skipping 20 matching lines @@
   printf("Skipped %" PRIuS " bad pages.\n", bad_pages);
 }
 
 int main(int argc, const char* argv[]) {
   std::vector<std::string> args(argv, argv + argc);
   Options options;
   std::list<std::string> files;
   if (!ParseCommandLine(args, &options, &files)) {
     printf("Usage: pdfium_test [OPTION] [FILE]...\n");
     printf("--bin-dir=<path> - override path to v8 external data\n");
+    printf("--scale=<number> - scale output size by number (e.g. 0.5)\n");
     printf("--ppm - write page images <pdf-name>.<page-number>.ppm\n");
 #ifdef _WIN32
     printf("--bmp - write page images <pdf-name>.<page-number>.bmp\n");
     printf("--emf - write page meta files <pdf-name>.<page-number>.emf\n");
 #endif
     return 1;
   }
 
   v8::V8::InitializeICU();
 
@@ skipping 17 matching lines @@
 
   FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
 
   while (!files.empty()) {
     std::string filename = files.front();
     files.pop_front();
     size_t file_length = 0;
     char* file_contents = GetFileContents(filename.c_str(), &file_length);
     if (!file_contents)
       continue;
-    RenderPdf(filename, file_contents, file_length, options.output_format);
+    RenderPdf(filename, file_contents, file_length, options);
     free(file_contents);
   }
 
   FPDF_DestroyLibrary();
 
   return 0;
 }