Print Preview: Add option to rasterize PDFs and add JPEG compression.

pdf/pdfium/pdfium_engine.cc

 // Copyright (c) 2012 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 "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 39 matching lines @@
 #include "third_party/pdfium/public/fpdf_edit.h"
 #include "third_party/pdfium/public/fpdf_ext.h"
 #include "third_party/pdfium/public/fpdf_flatten.h"
 #include "third_party/pdfium/public/fpdf_ppo.h"
 #include "third_party/pdfium/public/fpdf_save.h"
 #include "third_party/pdfium/public/fpdf_searchex.h"
 #include "third_party/pdfium/public/fpdf_sysfontinfo.h"
 #include "third_party/pdfium/public/fpdf_transformpage.h"
 #include "third_party/pdfium/public/fpdfview.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/geometry/rect.h"
 #include "v8/include/v8.h"
 
 using printing::ConvertUnit;
 using printing::ConvertUnitDouble;
 using printing::kPointsPerInch;
 using printing::kPixelsPerInch;
 
 namespace chrome_pdf {
 
@@ skipping 1173 matching lines @@
   else
     OnDocumentComplete();
 }
 
 void PDFiumEngine::CancelBrowserDownload() {
   client_->CancelBrowserDownload();
 }
 
 void PDFiumEngine::FinishLoadingDocument() {
   DCHECK(doc_loader_->IsDocumentComplete() && doc_);
-
   if (!form_) {
     int form_status =
         FPDFAvail_IsFormAvail(fpdf_availability_, &download_hints_);
     if (form_status != PDF_FORM_NOTAVAIL) {
       form_ = FPDFDOC_InitFormFillEnvironment(
           doc_, static_cast<FPDF_FORMFILLINFO*>(this));
 #if defined(PDF_ENABLE_XFA)
       FPDF_LoadXFA(doc_);
 #endif
 
@@ skipping 119 matching lines @@
   defer_page_unload_ = false;
   for (int page_index : deferred_page_unloads_)
     pages_[page_index]->Unload();
   deferred_page_unloads_.clear();
   return rv;
 }
 
 uint32_t PDFiumEngine::QuerySupportedPrintOutputFormats() {
   if (!HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return 0;
-  return PP_PRINTOUTPUTFORMAT_PDF;
+  if (!HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))
+    return PP_PRINTOUTPUTFORMAT_RASTER;
+  return PP_PRINTOUTPUTFORMAT_PDF | PP_PRINTOUTPUTFORMAT_RASTER;
 }
 
 void PDFiumEngine::PrintBegin() {
   FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WP);
 }
 
 pp::Resource PDFiumEngine::PrintPages(
     const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
   ScopedSubstFont scoped_subst_font(this);
-  if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))
+  if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY) &&
+      (print_settings.format & PP_PRINTOUTPUTFORMAT_PDF)) {
     return PrintPagesAsPDF(page_ranges, page_range_count, print_settings);
-  else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
+  } else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY)) {
     return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings);
+  }
+
   return pp::Resource();
 }
 
+struct simple_buf {
+  uint32_t size;
+  uint8_t *data;
+};
+
+int GetBlockForJpeg(void *param,
+             unsigned long pos,
+             unsigned char* pBuf,
+             unsigned long size) {
+  simple_buf * buf_p = static_cast<simple_buf *>(param);
+  if (pos + size < pos || pos + size > buf_p->size)
+    return 0;
+  memcpy(pBuf, buf_p->data, size);
+  return size;
+}
+
 FPDF_DOCUMENT PDFiumEngine::CreateSinglePageRasterPdf(
     double source_page_width,
     double source_page_height,
     const PP_PrintSettings_Dev& print_settings,
     PDFiumPage* page_to_print) {
   FPDF_DOCUMENT temp_doc = FPDF_CreateNewDocument();
   if (!temp_doc)
     return temp_doc;
 
   const pp::Size& bitmap_size(page_to_print->rect().size());
@@ skipping 19 matching lines @@
   pp::Rect page_rect = page_to_print->rect();
   FPDF_RenderPageBitmap(bitmap,
                         page_to_print->GetPrintPage(),
                         page_rect.x(),
                         page_rect.y(),
                         page_rect.width(),
                         page_rect.height(),
                         print_settings.orientation,
                         FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
+  unsigned char * bitmap_data =
+      static_cast<unsigned char *>(FPDFBitmap_GetBuffer(bitmap));
   double ratio_x = ConvertUnitDouble(bitmap_size.width(),
                                      print_settings.dpi,
                                      kPointsPerInch);
   double ratio_y = ConvertUnitDouble(bitmap_size.height(),
                                      print_settings.dpi,
                                      kPointsPerInch);
 
   // Add the bitmap to an image object and add the image object to the output
   // page.
   FPDF_PAGEOBJECT temp_img = FPDFPageObj_NewImgeObj(temp_doc);
-  FPDFImageObj_SetBitmap(&temp_page, 1, temp_img, bitmap);
+
+  std::vector <unsigned char> compressed_bitmap_data;
+  int quality = 40;
+  bool encode_success = gfx::JPEGCodec::Encode(bitmap_data,
+                                              gfx::JPEGCodec::FORMAT_BGRA,
+                                              FPDFBitmap_GetWidth(bitmap),
+                                              FPDFBitmap_GetHeight(bitmap),
+                                              FPDFBitmap_GetStride(bitmap),
+                                              quality,
+                                              &compressed_bitmap_data);
+
+//  encode_success = false;

[Vitaly Buka (NO REVIEWS), 2016/12/15 08:27:34]

please remove

[rbpotter, 2016/12/16 00:06:30]

This is already removed in the latest patchset.

+  if (encode_success) {
+    simple_buf buffer;
+    buffer.size = compressed_bitmap_data.size();
+    buffer.data = new uint8_t[buffer.size];
+    memcpy(buffer.data, &(compressed_bitmap_data[0]), buffer.size);
+
+    FPDF_FILEACCESS file_access;
+    memset(&file_access, '\0', sizeof(file_access));
+    file_access.m_FileLen =
+        static_cast<unsigned long>(compressed_bitmap_data.size());
+    file_access.m_GetBlock = &GetBlockForJpeg;
+    file_access.m_Param = &buffer;
+
+    FPDFImageObj_LoadJpegFile(&temp_page, 1, temp_img, &file_access);
+    delete buffer.data;
+  } else {
+    FPDFImageObj_SetBitmap(&temp_page, 1, temp_img, bitmap);
+  }
+
   FPDFImageObj_SetMatrix(temp_img, ratio_x, 0, 0, ratio_y, 0, 0);
   FPDFPage_InsertObject(temp_page, temp_img);
   FPDFPage_GenerateContent(temp_page);
   FPDF_ClosePage(temp_page);
 
   page_to_print->ClosePrintPage();
   FPDFBitmap_Destroy(bitmap);
 
   return temp_doc;
 }
@@ skipping 18 matching lines @@
   // width and height of source PDF pages.
   std::vector<std::pair<double, double> > source_page_sizes;
   // Collect pages to print and sizes of source pages.
   std::vector<uint32_t> page_numbers =
       GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count);
   for (uint32_t page_number : page_numbers) {
     FPDF_PAGE pdf_page = FPDF_LoadPage(doc_, page_number);
     double source_page_width = FPDF_GetPageWidth(pdf_page);
     double source_page_height = FPDF_GetPageHeight(pdf_page);
     source_page_sizes.push_back(std::make_pair(source_page_width,
-                                               source_page_height));
+                                              source_page_height));
 
     int width_in_pixels = ConvertUnit(source_page_width,
                                       kPointsPerInch,
                                       print_settings.dpi);
     int height_in_pixels = ConvertUnit(source_page_height,
                                        kPointsPerInch,
                                        print_settings.dpi);
 
     pp::Rect rect(width_in_pixels, height_in_pixels);
     pages_to_print.push_back(PDFiumPage(this, page_number, rect, true));
     FPDF_ClosePage(pdf_page);
   }
 
 #if defined(OS_LINUX)
   g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
 
   size_t i = 0;
+  unsigned long total_doc_size = 0;
   for (; i < pages_to_print.size(); ++i) {

[Vitaly Buka (NO REVIEWS), 2016/12/15 08:27:34]

Seems total_doc_size is not used.

[rbpotter, 2016/12/16 00:06:30]

This is already removed in the latest patchset.

     double source_page_width = source_page_sizes[i].first;
     double source_page_height = source_page_sizes[i].second;
 
     // Use temp_doc to compress image by saving PDF to buffer.
     FPDF_DOCUMENT temp_doc = CreateSinglePageRasterPdf(source_page_width,
-                                                       source_page_height,
-                                                       print_settings,
-                                                       &pages_to_print[i]);
-
+                                           source_page_height,
+                                           print_settings,
+                                           &pages_to_print[i]);
     if (!temp_doc)
       break;
 
     pp::Buffer_Dev buffer = GetFlattenedPrintData(temp_doc);
+    total_doc_size += buffer.size();
     FPDF_CloseDocument(temp_doc);
 
     PDFiumMemBufferFileRead file_read(buffer.data(), buffer.size());
     temp_doc = FPDF_LoadCustomDocument(&file_read, nullptr);
-
     FPDF_BOOL imported = FPDF_ImportPages(output_doc, temp_doc, "1", i);
     FPDF_CloseDocument(temp_doc);
     if (!imported)
       break;
   }
 
   pp::Buffer_Dev buffer;
   if (i == pages_to_print.size()) {
     FPDF_CopyViewerPreferences(output_doc, doc_);
     FitContentsToPrintableAreaIfRequired(output_doc, print_settings);
@@ skipping 2606 matching lines @@
 
 bool PDFiumEngineExports::GetPDFPageSizeByIndex(void* pdf_handle,
                                                 int page_number,
                                                 double* width,
                                                 double* height) {
   FPDF_DOCUMENT doc = pdf_handle;
   return doc && FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
 }
 
 }  // namespace chrome_pdf