XFA: Support PNG format in pdfium_test and add image diffing

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 <sstream>
 #include <string>
 #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"
+#include "image_diff_png.h"
 
 #ifdef _WIN32
 #define snprintf _snprintf
 #define PATH_SEPARATOR '\\'
 #else
 #define PATH_SEPARATOR '/'
 #endif
 
 enum OutputFormat {
   OUTPUT_NONE,
   OUTPUT_PPM,
+  OUTPUT_PNG,
 #ifdef _WIN32
   OUTPUT_BMP,
   OUTPUT_EMF,
 #endif
 };
 
 struct Options {
   Options() : output_format(OUTPUT_NONE) { }
 
   OutputFormat output_format;
@@ skipping 61 matching lines @@
   char* data_buffer = GetFileContents(full_path.c_str(), &data_length);
   if (!data_buffer) {
     return false;
   }
   result_data->data = const_cast<const char*>(data_buffer);
   result_data->raw_size = data_length;
   return true;
 }
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 
+static bool CheckDimensions(int stride, int width, int height) {
+  if (stride < 0 || width < 0 || height < 0)
+    return false;
+  if (height > 0 && width > INT_MAX / height)
+    return false;
+  return true;
+}
+
 static void WritePpm(const char* pdf_name, int num, const void* buffer_void,
                      int stride, int width, int height) {
   const char* buffer = reinterpret_cast<const char*>(buffer_void);
 
-  if (stride < 0 || width < 0 || height < 0)
+  if (!CheckDimensions(stride, width, height))
     return;
-  if (height > 0 && width > INT_MAX / height)
-    return;
+
   int out_len = width * height;
   if (out_len > INT_MAX / 3)
     return;
   out_len *= 3;
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num);
   FILE* fp = fopen(filename, "wb");
   if (!fp)
     return;
@@ skipping 13 matching lines @@
         // B
         dest_line[(w * 3) + 2] = src_line[w * 4];
       }
     }
     fwrite(result, out_len, 1, fp);
     delete [] result;
   }
   fclose(fp);
 }
 
+static void WritePng(const char* pdf_name, int num, const void* buffer_void,
+                     int stride, int width, int height) {
+  if (!CheckDimensions(stride, width, height))
+    return;
+
+  std::vector<unsigned char> png_encoding;
+  const unsigned char* buffer = static_cast<const unsigned char*>(buffer_void);
+  if (!image_diff_png::EncodeBGRAPNG(
+          buffer, width, height, stride, false, &png_encoding)) {
+    fprintf(stderr, "Failed to convert bitmap to PNG\n");
+    return;
+  }
+
+  char filename[256];
+  int chars_formatted = snprintf(
+      filename, sizeof(filename), "%s.%d.png", pdf_name, num);
+  if (chars_formatted < 0 ||
+      static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
+    fprintf(stderr, "Filname %s is too long\n", filename);
+    return;
+  }
+
+  FILE* fp = fopen(filename, "wb");
+  if (!fp) {
+    fprintf(stderr, "Failed to open %s for output\n", filename);
+    return;
+  }
+
+  size_t bytes_written = fwrite(
+      &png_encoding.front(), 1, png_encoding.size(), fp);
+  if (bytes_written != png_encoding.size())
+    fprintf(stderr, "Failed to write to  %s\n", filename);
+
+  (void) fclose(fp);
+}
+
 #ifdef _WIN32
 static void WriteBmp(const char* pdf_name, int num, const void* buffer,
                      int stride, int width, int height) {
-  if (stride < 0 || width < 0 || height < 0)
+  if (!CheckDimensions(stride, width, height))
     return;
-  if (height > 0 && width > INT_MAX / height)
-    return;
+
   int out_len = stride * height;
   if (out_len > INT_MAX / 3)
     return;
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.bmp", pdf_name, num);
   FILE* fp = fopen(filename, "wb");
   if (!fp)
     return;
 
@@ skipping 18 matching lines @@
 }
 
 void WriteEmf(FPDF_PAGE page, const char* pdf_name, int num) {
   int width = static_cast<int>(FPDF_GetPageWidth(page));
   int height = static_cast<int>(FPDF_GetPageHeight(page));
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.emf", pdf_name, num);
 
   HDC dc = CreateEnhMetaFileA(NULL, filename, NULL, NULL);
-  
-  HRGN rgn = CreateRectRgn(0, 0, width, height); 
-  SelectClipRgn(dc, rgn); 
+
+  HRGN rgn = CreateRectRgn(0, 0, width, height);
+  SelectClipRgn(dc, rgn);
   DeleteObject(rgn);
 
   SelectObject(dc, GetStockObject(NULL_PEN));
   SelectObject(dc, GetStockObject(WHITE_BRUSH));
   // If a PS_NULL pen is used, the dimensions of the rectangle are 1 pixel less.
   Rectangle(dc, 0, 0, width + 1, height + 1);
 
   FPDF_RenderPage(dc, page, 0, 0, width, height, 0,
                   FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
@@ skipping 71 matching lines @@
   options->exe_path = args[0];
   size_t cur_idx = 1;
   for (; cur_idx < args.size(); ++cur_idx) {
     const std::string& cur_arg = args[cur_idx];
     if (cur_arg == "--ppm") {
       if (options->output_format != OUTPUT_NONE) {
         fprintf(stderr, "Duplicate or conflicting --ppm argument\n");
         return false;
       }
       options->output_format = OUTPUT_PPM;
+    } else if (cur_arg == "--png") {
+      if (options->output_format != OUTPUT_NONE) {
+        fprintf(stderr, "Duplicate or conflicting --png argument\n");
+        return false;
+      }
+      options->output_format = OUTPUT_PNG;
     }
 #ifdef _WIN32
     else if (cur_arg == "--emf") {
       if (options->output_format != OUTPUT_NONE) {
         fprintf(stderr, "Duplicate or conflicting --emf argument\n");
         return false;
       }
       options->output_format = OUTPUT_EMF;
     }
     else if (cur_arg == "--bmp") {
@@ skipping 163 matching lines @@
         WriteBmp(name.c_str(), i, buffer, stride, width, height);
         break;
 
       case OUTPUT_EMF:
         WriteEmf(page, name.c_str(), i);
         break;
 #endif
       case OUTPUT_PPM:
         WritePpm(name.c_str(), i, buffer, stride, width, height);
         break;
+
+      case OUTPUT_PNG:
+        WritePng(name.c_str(), i, buffer, stride, width, height);
+        break;
+
       default:
         break;
     }
 
     FPDFBitmap_Destroy(bitmap);
 
     FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
     FORM_OnBeforeClosePage(page, form);
     FPDFText_ClosePage(text_page);
     FPDF_ClosePage(page);
   }
 
   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
   FPDF_CloseDocument(doc);
   FPDFDOC_ExitFormFillEnvironment(form);
   FPDFAvail_Destroy(pdf_avail);
 
   printf("Loaded, parsed and rendered %" PRIuS " pages.\n", rendered_pages);
   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("--png - write page images <pdf-name>.<page-number>.png\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 25 matching lines @@
     if (!file_contents)
       continue;
     RenderPdf(filename, file_contents, file_length, options);
     free(file_contents);
   }
 
   FPDF_DestroyLibrary();
 
   return 0;
 }