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 540 matching lines @@
       new gin::IsolateHolder(gin::IsolateHolder::kSingleThread);
   g_isolate_holder->isolate()->Enter();
 }
 
 void TearDownV8() {
   g_isolate_holder->isolate()->Exit();
   delete g_isolate_holder;
   g_isolate_holder = nullptr;
 }
 
+int GetBlockForJpeg(void* param,
+                    unsigned long pos,
+                    unsigned char* buf,
+                    unsigned long size) {
+  std::vector<uint8_t>* data_vector = static_cast<std::vector<uint8_t>*>(param);
+  if (pos + size < pos || pos + size > data_vector->size())
+    return 0;
+  memcpy(buf, data_vector->data() + pos, size);
+  return 1;
+}
+
 }  // namespace
 
 bool InitializeSDK() {
   SetUpV8();
 
   FPDF_LIBRARY_CONFIG config;
   config.version = 2;
   config.m_pUserFontPaths = nullptr;
   config.m_pIsolate = v8::Isolate::GetCurrent();
   config.m_v8EmbedderSlot = gin::kEmbedderPDFium;
@@ skipping 716 matching lines @@
 
   DCHECK(defer_page_unload_);
   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_PDF | PP_PRINTOUTPUTFORMAT_RASTER;
+  if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
+    return PP_PRINTOUTPUTFORMAT_RASTER;
+  return 0;
 }
 
 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();
 }
 
 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)
@@ skipping 22 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<uint8_t> compressed_bitmap_data;
+  int quality = 40;
+  if (!(print_settings.format & PP_PRINTOUTPUTFORMAT_PDF) &&
+      (gfx::JPEGCodec::Encode(
+          bitmap_data, gfx::JPEGCodec::FORMAT_BGRA, FPDFBitmap_GetWidth(bitmap),
+          FPDFBitmap_GetHeight(bitmap), FPDFBitmap_GetStride(bitmap), quality,
+          &compressed_bitmap_data))) {
+    FPDF_FILEACCESS file_access;

[Vitaly Buka (NO REVIEWS), 2016/12/16 00:54:38]

no need to do memset, just:
FPDF_FILEACCESS file_access = {};


even with memset: '\0' -> 0

[rbpotter, 2016/12/16 01:14:33]

Done.

+    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 = &compressed_bitmap_data;
+
+    FPDFImageObj_LoadJpegFileInline(&temp_page, 1, temp_img, &file_access);
+  } 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 2702 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf