Cleanup: Remove unused CFX_PSRenderer and various encoders it used.

core/src/fxcodec/codec/fx_codec_jpeg.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <setjmp.h>
 
 #include "codec_int.h"
 #include "core/include/fxcodec/fx_codec.h"
@@ skipping 56 matching lines @@
 };
 extern "C" {
 static void _error_do_nothing(j_common_ptr cinfo) {}
 };
 extern "C" {
 static void _error_do_nothing1(j_common_ptr cinfo, int) {}
 };
 extern "C" {
 static void _error_do_nothing2(j_common_ptr cinfo, char*) {}
 };
-#define JPEG_MARKER_EXIF (JPEG_APP0 + 1)
+
 #define JPEG_MARKER_ICC (JPEG_APP0 + 2)
-#define JPEG_MARKER_AUTHORTIME (JPEG_APP0 + 3)
 #define JPEG_MARKER_MAXSIZE 0xFFFF
-#define JPEG_OVERHEAD_LEN 14
-static FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo,
-                                    const uint8_t* icc_buf_ptr,
-                                    FX_DWORD icc_length) {
-  if (!icc_buf_ptr || icc_length == 0) {
-    return FALSE;
-  }
-  FX_DWORD icc_segment_size = (JPEG_MARKER_MAXSIZE - 2 - JPEG_OVERHEAD_LEN);
-  FX_DWORD icc_segment_num = (icc_length / icc_segment_size) + 1;
-  if (icc_segment_num > 255) {
-    return FALSE;
-  }
-  FX_DWORD icc_data_length =
-      JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);
-  uint8_t* icc_data = FX_Alloc(uint8_t, icc_data_length);
-  FXSYS_memcpy(icc_data, "\x49\x43\x43\x5f\x50\x52\x4f\x46\x49\x4c\x45\x00",
-               12);
-  icc_data[13] = (uint8_t)icc_segment_num;
-  for (uint8_t i = 0; i < (icc_segment_num - 1); i++) {
-    icc_data[12] = i + 1;
-    FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN,
-                 icc_buf_ptr + i * icc_segment_size, icc_segment_size);
-    jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, icc_data_length);
-  }
-  icc_data[12] = (uint8_t)icc_segment_num;
-  FX_DWORD icc_size = (icc_segment_num - 1) * icc_segment_size;
-  FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size,
-               icc_length - icc_size);
-  jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data,
-                    JPEG_OVERHEAD_LEN + icc_length - icc_size);
-  FX_Free(icc_data);
-  return TRUE;
-}
-extern "C" {
-static void _dest_do_nothing(j_compress_ptr cinfo) {}
-};
-extern "C" {
-static boolean _dest_empty(j_compress_ptr cinfo) {
-  return FALSE;
-}
-};
-#define JPEG_BLOCK_SIZE 1048576
-static void _JpegEncode(const CFX_DIBSource* pSource,
-                        uint8_t*& dest_buf,
-                        FX_STRSIZE& dest_size,
-                        int quality,
-                        const uint8_t* icc_buf,
-                        FX_DWORD icc_length) {
-  struct jpeg_error_mgr jerr;
-  jerr.error_exit = _error_do_nothing;
-  jerr.emit_message = _error_do_nothing1;
-  jerr.output_message = _error_do_nothing;
-  jerr.format_message = _error_do_nothing2;
-  jerr.reset_error_mgr = _error_do_nothing;
 
-  struct jpeg_compress_struct cinfo;
-  memset(&cinfo, 0, sizeof(cinfo));
-  cinfo.err = &jerr;
-  jpeg_create_compress(&cinfo);
-  int Bpp = pSource->GetBPP() / 8;
-  FX_DWORD nComponents = Bpp >= 3 ? (pSource->IsCmykImage() ? 4 : 3) : 1;
-  FX_DWORD pitch = pSource->GetPitch();
-  FX_DWORD width = pdfium::base::checked_cast<FX_DWORD>(pSource->GetWidth());
-  FX_DWORD height = pdfium::base::checked_cast<FX_DWORD>(pSource->GetHeight());
-  FX_SAFE_DWORD safe_buf_len = width;
-  safe_buf_len *= height;
-  safe_buf_len *= nComponents;
-  safe_buf_len += 1024;
-  if (icc_length) {
-    safe_buf_len += 255 * 18;
-    safe_buf_len += icc_length;
-  }
-  FX_DWORD dest_buf_length = 0;
-  if (!safe_buf_len.IsValid()) {
-    dest_buf = nullptr;
-  } else {
-    dest_buf_length = safe_buf_len.ValueOrDie();
-    dest_buf = FX_TryAlloc(uint8_t, dest_buf_length);
-    const int MIN_TRY_BUF_LEN = 1024;
-    while (!dest_buf && dest_buf_length > MIN_TRY_BUF_LEN) {
-      dest_buf_length >>= 1;
-      dest_buf = FX_TryAlloc(uint8_t, dest_buf_length);
-    }
-  }
-  if (!dest_buf) {
-    FX_OutOfMemoryTerminate();
-  }
-  struct jpeg_destination_mgr dest;
-  dest.init_destination = _dest_do_nothing;
-  dest.term_destination = _dest_do_nothing;
-  dest.empty_output_buffer = _dest_empty;
-  dest.next_output_byte = dest_buf;
-  dest.free_in_buffer = dest_buf_length;
-  cinfo.dest = &dest;
-  cinfo.image_width = width;
-  cinfo.image_height = height;
-  cinfo.input_components = nComponents;
-  if (nComponents == 1) {
-    cinfo.in_color_space = JCS_GRAYSCALE;
-  } else if (nComponents == 3) {
-    cinfo.in_color_space = JCS_RGB;
-  } else {
-    cinfo.in_color_space = JCS_CMYK;
-  }
-  uint8_t* line_buf = NULL;
-  if (nComponents > 1) {
-    line_buf = FX_Alloc2D(uint8_t, width, nComponents);
-  }
-  jpeg_set_defaults(&cinfo);
-  if (quality != 75) {
-    jpeg_set_quality(&cinfo, quality, TRUE);
-  }
-  jpeg_start_compress(&cinfo, TRUE);
-  _JpegEmbedIccProfile(&cinfo, icc_buf, icc_length);
-  JSAMPROW row_pointer[1];
-  JDIMENSION row;
-  while (cinfo.next_scanline < cinfo.image_height) {
-    const uint8_t* src_scan = pSource->GetScanline(cinfo.next_scanline);
-    if (nComponents > 1) {
-      uint8_t* dest_scan = line_buf;
-      if (nComponents == 3) {
-        for (FX_DWORD i = 0; i < width; i++) {
-          dest_scan[0] = src_scan[2];
-          dest_scan[1] = src_scan[1];
-          dest_scan[2] = src_scan[0];
-          dest_scan += 3;
-          src_scan += Bpp;
-        }
-      } else {
-        for (FX_DWORD i = 0; i < pitch; i++) {
-          *dest_scan++ = ~*src_scan++;
-        }
-      }
-      row_pointer[0] = line_buf;
-    } else {
-      row_pointer[0] = (uint8_t*)src_scan;
-    }
-    row = cinfo.next_scanline;
-    jpeg_write_scanlines(&cinfo, row_pointer, 1);
-    if (cinfo.next_scanline == row) {
-      dest_buf =
-          FX_Realloc(uint8_t, dest_buf, dest_buf_length + JPEG_BLOCK_SIZE);
-      dest.next_output_byte = dest_buf + dest_buf_length - dest.free_in_buffer;
-      dest_buf_length += JPEG_BLOCK_SIZE;
-      dest.free_in_buffer += JPEG_BLOCK_SIZE;
-    }
-  }
-  jpeg_finish_compress(&cinfo);
-  jpeg_destroy_compress(&cinfo);
-  FX_Free(line_buf);
-  dest_size = dest_buf_length - (FX_STRSIZE)dest.free_in_buffer;
-}
-static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf,
-                             FX_DWORD src_size,
-                             int& width,
-                             int& height,
-                             int& num_components,
-                             int& bits_per_components,
-                             FX_BOOL& color_transform,
-                             uint8_t** icc_buf_ptr,
-                             FX_DWORD* icc_length) {
+static bool JpegLoadInfo(const uint8_t* src_buf,
+                         FX_DWORD src_size,
+                         int* width,
+                         int* height,
+                         int* num_components,
+                         int* bits_per_components,
+                         bool* color_transform) {
   _JpegScanSOI(src_buf, src_size);
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   jerr.error_exit = _error_fatal;
   jerr.emit_message = _error_do_nothing1;
   jerr.output_message = _error_do_nothing;
   jerr.format_message = _error_do_nothing2;
   jerr.reset_error_mgr = _error_do_nothing;
   jerr.trace_level = 0;
   cinfo.err = &jerr;
   jmp_buf mark;
   cinfo.client_data = &mark;
   if (setjmp(mark) == -1) {
     return FALSE;
   }
   jpeg_create_decompress(&cinfo);
   struct jpeg_source_mgr src;
   src.init_source = _src_do_nothing;
   src.term_source = _src_do_nothing;
   src.skip_input_data = _src_skip_data;
   src.fill_input_buffer = _src_fill_buffer;
   src.resync_to_restart = _src_resync;
   src.bytes_in_buffer = src_size;
   src.next_input_byte = src_buf;
   cinfo.src = &src;
   if (setjmp(mark) == -1) {
     jpeg_destroy_decompress(&cinfo);
     return FALSE;

[Oliver Chang, 2015/12/22 17:35:47]

since this returns bool now, change FALSE/TRUE to false/true

[Lei Zhang, 2015/12/22 22:16:42]

Done.

   }
-  if (icc_buf_ptr && icc_length) {
-    jpeg_save_markers(&cinfo, JPEG_MARKER_ICC, JPEG_MARKER_MAXSIZE);
-  }
   int ret = jpeg_read_header(&cinfo, TRUE);
   if (ret != JPEG_HEADER_OK) {
     jpeg_destroy_decompress(&cinfo);
     return FALSE;

[Oliver Chang, 2015/12/22 17:35:47]

ditto

[Lei Zhang, 2015/12/22 22:16:42]

Done.

   }
-  width = cinfo.image_width;
-  height = cinfo.image_height;
-  num_components = cinfo.num_components;
-  color_transform =
+  *width = cinfo.image_width;
+  *height = cinfo.image_height;
+  *num_components = cinfo.num_components;
+  *color_transform =
       cinfo.jpeg_color_space == JCS_YCbCr || cinfo.jpeg_color_space == JCS_YCCK;
-  bits_per_components = cinfo.data_precision;
-  if (icc_buf_ptr) {
-    *icc_buf_ptr = NULL;
-  }
-  if (icc_length) {
-    *icc_length = 0;
-  }
+  *bits_per_components = cinfo.data_precision;
   jpeg_destroy_decompress(&cinfo);
   return TRUE;
 }
 
 class CCodec_JpegDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_JpegDecoder();
   ~CCodec_JpegDecoder() override;
 
   FX_BOOL Create(const uint8_t* src_buf,
@@ skipping 204 matching lines @@
     return NULL;
   }
   CCodec_JpegDecoder* pDecoder = new CCodec_JpegDecoder;
   if (!pDecoder->Create(src_buf, src_size, width, height, nComps,
                         ColorTransform)) {
     delete pDecoder;
     return NULL;
   }
   return pDecoder;
 }
-FX_BOOL CCodec_JpegModule::LoadInfo(const uint8_t* src_buf,
-                                    FX_DWORD src_size,
-                                    int& width,
-                                    int& height,
-                                    int& num_components,
-                                    int& bits_per_components,
-                                    FX_BOOL& color_transform,
-                                    uint8_t** icc_buf_ptr,
-                                    FX_DWORD* icc_length) {
-  return _JpegLoadInfo(src_buf, src_size, width, height, num_components,
-                       bits_per_components, color_transform, icc_buf_ptr,
-                       icc_length);
+bool CCodec_JpegModule::LoadInfo(const uint8_t* src_buf,
+                                 FX_DWORD src_size,
+                                 int* width,
+                                 int* height,
+                                 int* num_components,
+                                 int* bits_per_components,
+                                 bool* color_transform) {
+  return JpegLoadInfo(src_buf, src_size, width, height, num_components,
+                      bits_per_components, color_transform);
 }
-FX_BOOL CCodec_JpegModule::Encode(const CFX_DIBSource* pSource,
-                                  uint8_t*& dest_buf,
-                                  FX_STRSIZE& dest_size,
-                                  int quality,
-                                  const uint8_t* icc_buf,
-                                  FX_DWORD icc_length) {
-  if (pSource->GetBPP() < 8 || pSource->GetPalette())
-    return FALSE;
 
-  _JpegEncode(pSource, dest_buf, dest_size, quality, icc_buf, icc_length);
-  return TRUE;
-}
 struct FXJPEG_Context {
   jmp_buf m_JumpMark;
   jpeg_decompress_struct m_Info;
   jpeg_error_mgr m_ErrMgr;
   jpeg_source_mgr m_SrcMgr;
   unsigned int m_SkipSize;
   void* (*m_AllocFunc)(unsigned int);
   void (*m_FreeFunc)(void*);
 };
 extern "C" {
@@ skipping 106 matching lines @@
                                           uint8_t** avail_buf_ptr) {
   if (avail_buf_ptr) {
     *avail_buf_ptr = NULL;
     if (((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer > 0) {
       *avail_buf_ptr =
           (uint8_t*)((FXJPEG_Context*)pContext)->m_SrcMgr.next_input_byte;
     }
   }
   return (FX_DWORD)((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer;
 }