fs_optimization.h

Go to the documentation of this file.

#ifndef FS_PDFOPTIMIZATION_H_
#define FS_PDFOPTIMIZATION_H_

#include "common/fs_common.h"
#include "pdf/fs_pdfdoc.h"
#include "pdf/fs_pdfpage.h"

namespace foxit {
namespace addon {
namespace optimization {
class ImageSettings;
class MonoImageSettings;
class OptimizerSettings;
class OptimizeScannedPDFSettings;

class AuditSpaceSize FS_FINAL : public Object{
 public:
  AuditSpaceSize()
    : content_streams(0)
    , images(0)
    , fonts(0)
    , bookmarks(0)
    , x_object_forms(0)
    , structure_infos(0)
    , acroforms(0)
    , link_annots(0)
    , named_destnations(0)
    , color_space(0)
    , pattern_infos(0)
    , piece_infos(0)
    , comments_and_3d_contents(0)
    , shading_pattern_infos(0)
    , extend_graphics_states(0)
    , cross_ref_tables(0)
    , thumbs(0)
    , embed_files(0)
    , web_infos(0) { }

  AuditSpaceSize & operator = (const AuditSpaceSize & data) {
    content_streams = data.content_streams;
    images = data.images;
    fonts = data.fonts;
    bookmarks = data.bookmarks;
    x_object_forms = data.x_object_forms;
    named_destnations = data.named_destnations;
    structure_infos = data.structure_infos;
    acroforms = data.acroforms;
    link_annots = data.link_annots;
    color_space = data.color_space;
    pattern_infos = data.pattern_infos;
    piece_infos = data.piece_infos;
    comments_and_3d_contents = data.comments_and_3d_contents;
    shading_pattern_infos = data.shading_pattern_infos;
    extend_graphics_states = data.extend_graphics_states;
    cross_ref_tables = data.cross_ref_tables;
    thumbs = data.thumbs;
    embed_files = data.embed_files;
    web_infos = data.web_infos;
    return (*this);
  }

  uint32 content_streams;

  uint32 images;

  uint32 fonts;

  uint32 bookmarks;

  uint32 x_object_forms;

  uint32 structure_infos;

  uint32 acroforms;

  uint32 link_annots;

  uint32 named_destnations;

  uint32 color_space;

  uint32 pattern_infos;

  uint32 piece_infos;

  uint32 comments_and_3d_contents;

  uint32 shading_pattern_infos;

  uint32 extend_graphics_states;

  uint32 cross_ref_tables;

  uint32 thumbs;

  uint32 embed_files;

  uint32 web_infos;
};

class ImageCompressionCallback {
 public:
  virtual void Release() = 0;

  virtual common::file::StreamCallback* GetTemporaryFileStream(const common::Bitmap& bitmap) = 0;

 protected:
  ~ImageCompressionCallback() {}
};

class Optimizer FS_FINAL : public Base {
 public:
  typedef foxit::addon::optimization::OptimizerSettings OptimizerSettings;
  typedef foxit::addon::optimization::OptimizeScannedPDFSettings OptimizeScannedPDFSettings;
  static common::Progressive Optimize(const pdf::PDFDoc& doc,const OptimizerSettings& settings,common::PauseCallback* pause);
    
  static common::Progressive StartSubsetEmbedFont(const pdf::PDFDoc& doc, common::PauseCallback* pause);
  
  static common::Progressive OptimizeScannedPDF(const pdf::PDFDoc& doc, const OptimizeScannedPDFSettings& settings, ImageCompressionCallback* image_compress_callback, common::PauseCallback* pause);

  static AuditSpaceSize ComputeAuditSpace(const pdf::PDFDoc& doc);
};

class ImageSettings FS_FINAL : public Base {
 public:
  typedef enum _ImageCompressMode {
    e_ImageCompressHigh = 10003,
    e_ImageCompressjpeg = 10005,
    e_ImageCompressjpeg2000 = 10006,
    e_ImageCompressRetain  = 10007,
    e_ImageCompressZip = 10009
  } ImageCompressMode;
  
  typedef enum _ImageCompressQuality {
    e_ImageCompressQualityMinimum = 1,
    e_ImageCompressQualityLow = 2,
    e_ImageCompressQualityMedium = 3,
    e_ImageCompressQualityHigh  = 4,
    e_ImageCompressQualityMaximum  = 5,
    e_ImageCompressQualityLossless = 6
  } ImageCompressQuality;
  
  typedef enum _StretchMode {
    e_StretchDefault = -1,
    e_StretchOff = 0x00,
    e_StretchInterpol = 0x20,
    e_StretchDownsample = 0x04,
    e_StretchBicubic = 0x80,
    e_StretchNoSmooth = 0x100
  } StretchMode;
  
  ImageSettings();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit ImageSettings(FS_HANDLE handle);

  ~ImageSettings();

  ImageSettings(const ImageSettings& other);

  ImageSettings& operator = (const ImageSettings& other);
  bool operator == (const ImageSettings& other) const;

  bool operator != (const ImageSettings& other) const;

  bool IsEmpty() const;

   void SetStretchMode(StretchMode mode);

  void SetImageDPI(int32 dpi);

  void SetImageDPILimit(int dpi_limit);

  void SetCompressionMode(ImageCompressMode mode);

  void SetQuality(ImageCompressQuality quality);
  
  void SetBackgroundDownScale(int32 down_scale);
  
  void SetForegroundDownScale(int32 down_scale);

  void SetTextSensitivity(int32 text_sensitivity);
  
  void SetTileSize(int size);
};

class MonoImageSettings FS_FINAL : public Base {
 public:
  typedef enum _MonoImageCompressMode {
    e_ImageCompressCCITT3 = 10001,
    e_ImageCompressCCITT4 = 10002,
    e_ImageCompressHigh = 10003,
    e_ImageCompressjbig2 = 10004,
    e_ImageCompressRetain  = 10007,
    e_ImageCompressRunLength = 10008,
    e_ImageCompressZip = 10009
  } MonoImageCompressMode;
  
  typedef enum _MonoImageCompressQuality {
    e_ImageCompressQualityLossless = 1,
    e_ImageCompressQualityLossy = 2,
    e_ImageCompressQualityMinimum = 3,
    e_ImageCompressQualityLow = 4,
    e_ImageCompressQualityMedium = 5,
    e_ImageCompressQualityHigh = 6,
    e_ImageCompressQualityMaximum = 7
  } MonoImageCompressQuality;
  
  typedef enum _StretchMode {
    e_StretchDefault = -1,
    e_StretchOff = 0x00,
    e_StretchInterpol = 0x20,
    e_StretchDownsample = 0x04,
    e_StretchBicubic = 0x80,
    e_StretchNoSmooth = 0x100
  } StretchMode;
  
  MonoImageSettings();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit MonoImageSettings(FS_HANDLE handle);

  ~MonoImageSettings();

  MonoImageSettings(const MonoImageSettings& other);

  MonoImageSettings& operator = (const MonoImageSettings& other);
  bool operator == (const MonoImageSettings& other) const;

  bool operator != (const MonoImageSettings& other) const;

  bool IsEmpty() const;

  void SetImageDPI(int32 dpi);

  void SetImageDPILimit(int dpi_limit);

  void SetCompressionMode(MonoImageCompressMode mode);

  void SetStretchMode(StretchMode mode) ;

   void SetQuality(MonoImageCompressQuality quality);
};

class UnembeddedFontSettings FS_FINAL : public Base {
 public:
  UnembeddedFontSettings();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit UnembeddedFontSettings(FS_HANDLE handle);

  ~UnembeddedFontSettings();

  UnembeddedFontSettings(const UnembeddedFontSettings& other);

  UnembeddedFontSettings& operator=(const UnembeddedFontSettings& other);

  bool operator==(const UnembeddedFontSettings& other) const;

  bool operator!=(const UnembeddedFontSettings& other) const;

  bool IsEmpty() const;

  void SetSubsetAllEmFonts(bool is_subset_all_emb_fonts);

  void SetUnembeddedFontNameArray(const WStringArray& font_name_array);
};

class OptimizerSettings FS_FINAL : public Base {
 public:
  typedef enum _OptimizerOptions {
    e_OptimizerCompressImages  = 0x01,
    e_OptimizerCleanUp = 0x02,
    e_OptimizerDiscardObjects = 0x04,
    e_OptimizerUnembeddedFonts = 0x08,
    e_OptimizerDiscardUserData = 0x10,
    e_OptimizerTransparency = 0x20
  } OptimizerOptions;
  
  typedef enum _CleanUpOptions {
    e_CleanUpUseFlateForNonEncodedStream  = 0x01,
    e_CleanUpUseFlateInsteadOfLZW = 0x02,
    e_CleanUpRemoveInvalidBookmarks = 0x04,
    e_CleanUpRemoveInvalidLinks = 0x08,
    e_CleanUpDiscardUnreferencedNamedDes = 0x10,
    e_CleanUpOptPageContent = 0x20
  } CleanUpOptions;
  
  typedef enum _DiscardObjectsOptions {
    e_DiscardObjectsFormActions  = 0x01,
    e_DiscardObjectsFlattenFormFields = 0x02,
    e_DiscardObjectsJavaScriptActions = 0x04,
    e_DiscardObjectsEmbeddedPageThumbnails = 0x08,
    e_DiscardObjectsEmbeddedPrintSettings = 0x10,
    e_DiscardObjectsBookmarks = 0x20,
    e_DiscardObjectsAlternateImages = 0x40,
    e_DiscardObjectsDocumentTags = 0x80,
    e_DiscardObjectsEmbeddedSearchIndex = 0x100,
    e_DiscardObjectsDetectAndMergeImageFragment = 0x200,
    e_DiscardObjectsSmoothlinestocurves = 0x400
  } DiscardObjectsOptions;
  
  typedef enum _DiscardUserDataOptions {
    e_DiscardUserDataAllAnnotsFormsAndMultimedia  = 0x01,
    e_DiscardUserDataExternalCrossReferences = 0x02,
    e_DiscardUserDataDocumentInfoAndMetaData = 0x04,
    e_DiscardUserDataFileAttchments = 0x08,
    e_DiscardUserDataPrivateDataOfOtherApp = 0x10,
    e_DiscardUserDataLayer = 0x20,
    e_DiscardUserAllData = 0x40
  } DiscardUserDataOptions;
  
  typedef enum _TransparencyMode {
    e_TransparencyModeLowResolution = 0,
    e_TransparencyModeMediumResolution = 1,
    e_TransparencyModeHighResolution = 2
  } TransparencyMode;
  

  OptimizerSettings(); 

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit OptimizerSettings(FS_HANDLE handle);

  ~OptimizerSettings();

  OptimizerSettings(const OptimizerSettings& other);

  OptimizerSettings& operator = (const OptimizerSettings& other);

  bool operator == (const OptimizerSettings& other) const;

  bool operator != (const OptimizerSettings& other) const;

  bool IsEmpty() const;

  void SetOptimizerOptions(uint32 optimize_options);

  void SetColorGrayImageSettings(const ImageSettings& settings);

  void SetColorImageSettings(const ImageSettings& settings);

  void SetGrayscaleImageSettings(const ImageSettings& settings);
    
  void SetMonoImageSettings(const MonoImageSettings& settings);

  void SetUnembeddedFontSettings(const UnembeddedFontSettings& settings);

  void SetCleanUpOptions(foxit::uint32 clean_up_options);

  void SetDiscardObjectsOptions(foxit::uint32 discard_objects_options);

  void SetDiscardUserDataOptions(foxit::uint32 discard_userdata_options);

  void SetTransparencyMode(TransparencyMode transparency_mode);
};

class OptimizeScannedPDFSettings FS_FINAL : public Base{
 public:
  typedef enum _ScannedImageCompressMode {
    e_ScannedImageCompressHigh = 1,
    e_ScannedImageCompressjpeg = 2,
    e_ScannedImageCompressjpeg2000LossLess = 3,
    e_ScannedImageCompressjpeg2000Lossy = 4
  } ScannedImageCompressMode;
  
  typedef enum _ScannedMonoImageCompressMode {
    e_ScannedMonoImageCompressjbig2Lossy = 1,
    e_ScannedMonoImageCompressjbig2LossLess = 2,
    e_ScannedMonoImageCompressCCITT4 = 3,
    e_ScannedMonoImageCompressHigh = 4
  } ScannedMonoImageCompressMode;
  

  OptimizeScannedPDFSettings();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit OptimizeScannedPDFSettings(FS_HANDLE handle);

  ~OptimizeScannedPDFSettings();

  OptimizeScannedPDFSettings(const OptimizeScannedPDFSettings& other);

  OptimizeScannedPDFSettings& operator = (const OptimizeScannedPDFSettings& other);
  bool operator == (const OptimizeScannedPDFSettings& other) const;

  bool operator != (const OptimizeScannedPDFSettings& other) const;

  bool IsEmpty() const;

  void SetOptimizedPages(const common::Range& pages);

  void SetColorGrayImageCompressionMode(ScannedImageCompressMode mode);

  void SetColorGrayImageCompressionQuality(foxit::uint32 quality);

  void SetMonoImageCompressionMode(ScannedMonoImageCompressMode mode);
};

}  // namespace optimization 
}  // namespace addon
}  // namespace foxit

#endif