Cleanup: Remove unused CFX_PSRenderer and various encoders it used.

- Simplify remaining encoders.
- Hook up more of the encoding paths so failures get returned.
- Clean up code to not pass by non-const ref, use bools, etc.

R=ochang@chromium.org

Review URL: https://codereview.chromium.org/1545563003 .

5 files changed, 69 insertions, 717 deletions

diff --git a/core/src/fxcodec/codec/codec_int.h b/core/src/fxcodec/codec/codec_int.h
index 1495f9e680..c3daf3bdf2 100644
--- a/core/src/fxcodec/codec/codec_int.h
+++ b/core/src/fxcodec/codec/codec_int.h
@@ -22,14 +22,6 @@ class CFX_IccTransformCache;
 class CCodec_BasicModule : public ICodec_BasicModule {
  public:
   // ICodec_BasicModule:
-  FX_BOOL RunLengthEncode(const uint8_t* src_buf,
-                          FX_DWORD src_size,
-                          uint8_t*& dest_buf,
-                          FX_DWORD& dest_size) override;
-  FX_BOOL A85Encode(const uint8_t* src_buf,
-                    FX_DWORD src_size,
-                    uint8_t*& dest_buf,
-                    FX_DWORD& dest_size) override;
   ICodec_ScanlineDecoder* CreateRunLengthDecoder(const uint8_t* src_buf,
                                                  FX_DWORD src_size,
                                                  int width,
@@ -113,12 +105,6 @@ class CCodec_FaxModule : public ICodec_FaxModule {
                                         FX_BOOL BlackIs1,
                                         int Columns,
                                         int Rows) override;
-  FX_BOOL Encode(const uint8_t* src_buf,
-                 int width,
-                 int height,
-                 int pitch,
-                 uint8_t*& dest_buf,
-                 FX_DWORD& dest_size) override;
 };
 
 class CCodec_FlateModule : public ICodec_FlateModule {
@@ -144,18 +130,14 @@ class CCodec_FlateModule : public ICodec_FlateModule {
                                     FX_DWORD estimated_size,
                                     uint8_t*& dest_buf,
                                     FX_DWORD& dest_size);
-  virtual FX_BOOL Encode(const uint8_t* src_buf,
+  virtual bool Encode(const uint8_t* src_buf,
+                      FX_DWORD src_size,
+                      uint8_t** dest_buf,
+                      FX_DWORD* dest_size);
+  virtual bool PngEncode(const uint8_t* src_buf,
                          FX_DWORD src_size,
-                         int predictor,
-                         int Colors,
-                         int BitsPerComponent,
-                         int Columns,
-                         uint8_t*& dest_buf,
-                         FX_DWORD& dest_size);
-  virtual FX_BOOL Encode(const uint8_t* src_buf,
-                         FX_DWORD src_size,
-                         uint8_t*& dest_buf,
-                         FX_DWORD& dest_size);
+                         uint8_t** dest_buf,
+                         FX_DWORD* dest_size);
 };
 
 class CCodec_JpegModule : public ICodec_JpegModule {
@@ -167,21 +149,13 @@ class CCodec_JpegModule : public ICodec_JpegModule {
                                         int height,
                                         int nComps,
                                         FX_BOOL ColorTransform) override;
-  FX_BOOL 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) override;
-  FX_BOOL Encode(const CFX_DIBSource* pSource,
-                 uint8_t*& dest_buf,
-                 FX_STRSIZE& dest_size,
-                 int quality,
-                 const uint8_t* icc_buf,
-                 FX_DWORD icc_length) override;
+  bool LoadInfo(const uint8_t* src_buf,
+                FX_DWORD src_size,
+                int* width,
+                int* height,
+                int* num_components,
+                int* bits_per_components,
+                bool* color_transform) override;
   void* Start() override;
   void Finish(void* pContext) override;
   void Input(void* pContext,
diff --git a/core/src/fxcodec/codec/fx_codec.cpp b/core/src/fxcodec/codec/fx_codec.cpp
index 6998114f83..d7c7c4eeb4 100644
--- a/core/src/fxcodec/codec/fx_codec.cpp
+++ b/core/src/fxcodec/codec/fx_codec.cpp
@@ -142,121 +142,6 @@ void CCodec_ScanlineDecoder::DownScale(int dest_width, int dest_height) {
   m_pDataCache = nonstd::move(cache);
 }
 
-FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf,
-                                            FX_DWORD src_size,
-                                            uint8_t*& dest_buf,
-                                            FX_DWORD& dest_size) {
-  return FALSE;
-}
-
-#define EXPONENT_DETECT(ptr)                 \
-  for (;; ptr++) {                           \
-    if (!std::isdigit(*ptr)) {               \
-      if (endptr)                            \
-        *endptr = (char*)ptr;                \
-      break;                                 \
-    } else {                                 \
-      exp_ret *= 10;                         \
-      exp_ret += FXSYS_toDecimalDigit(*ptr); \
-      continue;                              \
-    }                                        \
-  }
-
-extern "C" double FXstrtod(const char* nptr, char** endptr) {
-  double ret = 0.0;
-  const char* ptr = nptr;
-  const char* exp_ptr = NULL;
-  int e_number = 0, e_signal = 0, e_point = 0, is_negative = 0;
-  int exp_ret = 0, exp_sig = 1, fra_ret = 0, fra_count = 0, fra_base = 1;
-  if (!nptr) {
-    return 0.0;
-  }
-  for (;; ptr++) {
-    if (!e_number && !e_point && (*ptr == '\t' || *ptr == ' '))
-      continue;
-
-    if (std::isdigit(*ptr)) {
-      if (!e_number)
-        e_number = 1;
-
-      if (!e_point) {
-        ret *= 10;
-        ret += FXSYS_toDecimalDigit(*ptr);
-      } else {
-        fra_count++;
-        fra_ret *= 10;
-        fra_ret += FXSYS_toDecimalDigit(*ptr);
-      }
-      continue;
-    }
-    if (!e_point && *ptr == '.') {
-      e_point = 1;
-      continue;
-    }
-    if (!e_number && !e_point && !e_signal) {
-      switch (*ptr) {
-        case '-':
-          is_negative = 1;
-        case '+':
-          e_signal = 1;
-          continue;
-      }
-    }
-    if (e_number && (*ptr == 'e' || *ptr == 'E')) {
-      exp_ptr = ptr++;
-      if (*ptr == '+' || *ptr == '-') {
-        exp_sig = (*ptr++ == '+') ? 1 : -1;
-        if (!std::isdigit(*ptr)) {
-          if (endptr) {
-            *endptr = (char*)exp_ptr;
-          }
-          break;
-        }
-        EXPONENT_DETECT(ptr);
-      } else if (std::isdigit(*ptr)) {
-        EXPONENT_DETECT(ptr);
-      } else {
-        if (endptr) {
-          *endptr = (char*)exp_ptr;
-        }
-        break;
-      }
-      break;
-    }
-    if (ptr != nptr && !e_number) {
-      if (endptr) {
-        *endptr = (char*)nptr;
-      }
-      break;
-    }
-    if (endptr) {
-      *endptr = (char*)ptr;
-    }
-    break;
-  }
-  while (fra_count--) {
-    fra_base *= 10;
-  }
-  ret += (double)fra_ret / (double)fra_base;
-  if (exp_sig == 1) {
-    while (exp_ret--) {
-      ret *= 10.0;
-    }
-  } else {
-    while (exp_ret--) {
-      ret /= 10.0;
-    }
-  }
-  return is_negative ? -ret : ret;
-}
-#undef EXPONENT_DETECT
-
-FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf,
-                                      FX_DWORD src_size,
-                                      uint8_t*& dest_buf,
-                                      FX_DWORD& dest_size) {
-  return FALSE;
-}
 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_RLScanlineDecoder();
diff --git a/core/src/fxcodec/codec/fx_codec_fax.cpp b/core/src/fxcodec/codec/fx_codec_fax.cpp
index b198e74784..686fc08b61 100644
--- a/core/src/fxcodec/codec/fx_codec_fax.cpp
+++ b/core/src/fxcodec/codec/fx_codec_fax.cpp
@@ -466,134 +466,6 @@ FX_BOOL FaxGet1DLine(const uint8_t* src_buf,
   return TRUE;
 }
 
-const uint8_t BlackRunTerminator[128] = {
-    0x37, 10, 0x02, 3,  0x03, 2,  0x02, 2,  0x03, 3,  0x03, 4,  0x02, 4,
-    0x03, 5,  0x05, 6,  0x04, 6,  0x04, 7,  0x05, 7,  0x07, 7,  0x04, 8,
-    0x07, 8,  0x18, 9,  0x17, 10, 0x18, 10, 0x08, 10, 0x67, 11, 0x68, 11,
-    0x6c, 11, 0x37, 11, 0x28, 11, 0x17, 11, 0x18, 11, 0xca, 12, 0xcb, 12,
-    0xcc, 12, 0xcd, 12, 0x68, 12, 0x69, 12, 0x6a, 12, 0x6b, 12, 0xd2, 12,
-    0xd3, 12, 0xd4, 12, 0xd5, 12, 0xd6, 12, 0xd7, 12, 0x6c, 12, 0x6d, 12,
-    0xda, 12, 0xdb, 12, 0x54, 12, 0x55, 12, 0x56, 12, 0x57, 12, 0x64, 12,
-    0x65, 12, 0x52, 12, 0x53, 12, 0x24, 12, 0x37, 12, 0x38, 12, 0x27, 12,
-    0x28, 12, 0x58, 12, 0x59, 12, 0x2b, 12, 0x2c, 12, 0x5a, 12, 0x66, 12,
-    0x67, 12,
-};
-
-const uint8_t BlackRunMarkup[80] = {
-    0x0f, 10, 0xc8, 12, 0xc9, 12, 0x5b, 12, 0x33, 12, 0x34, 12, 0x35, 12,
-    0x6c, 13, 0x6d, 13, 0x4a, 13, 0x4b, 13, 0x4c, 13, 0x4d, 13, 0x72, 13,
-    0x73, 13, 0x74, 13, 0x75, 13, 0x76, 13, 0x77, 13, 0x52, 13, 0x53, 13,
-    0x54, 13, 0x55, 13, 0x5a, 13, 0x5b, 13, 0x64, 13, 0x65, 13, 0x08, 11,
-    0x0c, 11, 0x0d, 11, 0x12, 12, 0x13, 12, 0x14, 12, 0x15, 12, 0x16, 12,
-    0x17, 12, 0x1c, 12, 0x1d, 12, 0x1e, 12, 0x1f, 12,
-};
-
-const uint8_t WhiteRunTerminator[128] = {
-    0x35, 8, 0x07, 6, 0x07, 4, 0x08, 4, 0x0B, 4, 0x0C, 4, 0x0E, 4, 0x0F, 4,
-    0x13, 5, 0x14, 5, 0x07, 5, 0x08, 5, 0x08, 6, 0x03, 6, 0x34, 6, 0x35, 6,
-    0x2a, 6, 0x2B, 6, 0x27, 7, 0x0c, 7, 0x08, 7, 0x17, 7, 0x03, 7, 0x04, 7,
-    0x28, 7, 0x2B, 7, 0x13, 7, 0x24, 7, 0x18, 7, 0x02, 8, 0x03, 8, 0x1a, 8,
-    0x1b, 8, 0x12, 8, 0x13, 8, 0x14, 8, 0x15, 8, 0x16, 8, 0x17, 8, 0x28, 8,
-    0x29, 8, 0x2a, 8, 0x2b, 8, 0x2c, 8, 0x2d, 8, 0x04, 8, 0x05, 8, 0x0a, 8,
-    0x0b, 8, 0x52, 8, 0x53, 8, 0x54, 8, 0x55, 8, 0x24, 8, 0x25, 8, 0x58, 8,
-    0x59, 8, 0x5a, 8, 0x5b, 8, 0x4a, 8, 0x4b, 8, 0x32, 8, 0x33, 8, 0x34, 8,
-};
-
-const uint8_t WhiteRunMarkup[80] = {
-    0x1b, 5,  0x12, 5,  0x17, 6,  0x37, 7,  0x36, 8,  0x37, 8,  0x64, 8,
-    0x65, 8,  0x68, 8,  0x67, 8,  0xcc, 9,  0xcd, 9,  0xd2, 9,  0xd3, 9,
-    0xd4, 9,  0xd5, 9,  0xd6, 9,  0xd7, 9,  0xd8, 9,  0xd9, 9,  0xda, 9,
-    0xdb, 9,  0x98, 9,  0x99, 9,  0x9a, 9,  0x18, 6,  0x9b, 9,  0x08, 11,
-    0x0c, 11, 0x0d, 11, 0x12, 12, 0x13, 12, 0x14, 12, 0x15, 12, 0x16, 12,
-    0x17, 12, 0x1c, 12, 0x1d, 12, 0x1e, 12, 0x1f, 12,
-};
-
-void AddBitStream(uint8_t* dest_buf, int& dest_bitpos, int data, int bitlen) {
-  for (int i = bitlen - 1; i >= 0; i--) {
-    if (data & (1 << i)) {
-      dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-    }
-    dest_bitpos++;
-  }
-}
-
-void FaxEncodeRun(uint8_t* dest_buf, int& dest_bitpos, int run, bool bWhite) {
-  while (run >= 2560) {
-    AddBitStream(dest_buf, dest_bitpos, 0x1f, 12);
-    run -= 2560;
-  }
-  if (run >= 64) {
-    int markup = run - run % 64;
-    const uint8_t* p = bWhite ? WhiteRunMarkup : BlackRunMarkup;
-    p += (markup / 64 - 1) * 2;
-    AddBitStream(dest_buf, dest_bitpos, *p, p[1]);
-  }
-  run %= 64;
-  const uint8_t* p = bWhite ? WhiteRunTerminator : BlackRunTerminator;
-  p += run * 2;
-  AddBitStream(dest_buf, dest_bitpos, *p, p[1]);
-}
-
-void FaxEncode2DLine(uint8_t* dest_buf,
-                     int& dest_bitpos,
-                     const uint8_t* src_buf,
-                     const uint8_t* ref_buf,
-                     int cols) {
-  int a0 = -1;
-  bool a0color = true;
-  while (1) {
-    int a1 = FindBit(src_buf, cols, a0 + 1, !a0color);
-    int b1, b2;
-    FaxG4FindB1B2(ref_buf, cols, a0, a0color, b1, b2);
-    if (b2 < a1) {
-      dest_bitpos += 3;
-      dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-      dest_bitpos++;
-      a0 = b2;
-    } else if (a1 - b1 <= 3 && b1 - a1 <= 3) {
-      int delta = a1 - b1;
-      switch (delta) {
-        case 0:
-          dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-          break;
-        case 1:
-        case 2:
-        case 3:
-          dest_bitpos += delta == 1 ? 1 : delta + 2;
-          dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-          dest_bitpos++;
-          dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-          break;
-        case -1:
-        case -2:
-        case -3:
-          dest_bitpos += delta == -1 ? 1 : -delta + 2;
-          dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-          dest_bitpos++;
-          break;
-      }
-      dest_bitpos++;
-      a0 = a1;
-      a0color = !a0color;
-    } else {
-      int a2 = FindBit(src_buf, cols, a1 + 1, a0color);
-      dest_bitpos++;
-      dest_bitpos++;
-      dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
-      dest_bitpos++;
-      if (a0 < 0) {
-        a0 = 0;
-      }
-      FaxEncodeRun(dest_buf, dest_bitpos, a1 - a0, a0color);
-      FaxEncodeRun(dest_buf, dest_bitpos, a2 - a1, !a0color);
-      a0 = a2;
-    }
-    if (a0 >= cols) {
-      return;
-    }
-  }
-}
-
 }  // namespace
 
 class CCodec_FaxDecoder : public CCodec_ScanlineDecoder {
@@ -754,65 +626,6 @@ void FaxG4Decode(const uint8_t* src_buf,
   *pbitpos = bitpos;
 }
 
-class CCodec_FaxEncoder {
- public:
-  CCodec_FaxEncoder(const uint8_t* src_buf, int width, int height, int pitch);
-  ~CCodec_FaxEncoder();
-  void Encode(uint8_t*& dest_buf, FX_DWORD& dest_size);
-  void Encode2DLine(const uint8_t* scan_line);
-  CFX_BinaryBuf m_DestBuf;
-  uint8_t* m_pRefLine;
-  uint8_t* m_pLineBuf;
-  int m_Cols, m_Rows, m_Pitch;
-  const uint8_t* m_pSrcBuf;
-};
-CCodec_FaxEncoder::CCodec_FaxEncoder(const uint8_t* src_buf,
-                                     int width,
-                                     int height,
-                                     int pitch) {
-  m_pSrcBuf = src_buf;
-  m_Cols = width;
-  m_Rows = height;
-  m_Pitch = pitch;
-  m_pRefLine = FX_Alloc(uint8_t, m_Pitch);
-  FXSYS_memset(m_pRefLine, 0xff, m_Pitch);
-  m_pLineBuf = FX_Alloc2D(uint8_t, m_Pitch, 8);
-  m_DestBuf.EstimateSize(0, 10240);
-}
-CCodec_FaxEncoder::~CCodec_FaxEncoder() {
-  FX_Free(m_pRefLine);
-  FX_Free(m_pLineBuf);
-}
-void CCodec_FaxEncoder::Encode(uint8_t*& dest_buf, FX_DWORD& dest_size) {
-  int dest_bitpos = 0;
-  uint8_t last_byte = 0;
-  for (int i = 0; i < m_Rows; i++) {
-    const uint8_t* scan_line = m_pSrcBuf + i * m_Pitch;
-    FXSYS_memset(m_pLineBuf, 0, m_Pitch * 8);
-    m_pLineBuf[0] = last_byte;
-    FaxEncode2DLine(m_pLineBuf, dest_bitpos, scan_line, m_pRefLine, m_Cols);
-    m_DestBuf.AppendBlock(m_pLineBuf, dest_bitpos / 8);
-    last_byte = m_pLineBuf[dest_bitpos / 8];
-    dest_bitpos %= 8;
-    FXSYS_memcpy(m_pRefLine, scan_line, m_Pitch);
-  }
-  if (dest_bitpos) {
-    m_DestBuf.AppendByte(last_byte);
-  }
-  dest_buf = m_DestBuf.GetBuffer();
-  dest_size = m_DestBuf.GetSize();
-  m_DestBuf.DetachBuffer();
-}
-FX_BOOL CCodec_FaxModule::Encode(const uint8_t* src_buf,
-                                 int width,
-                                 int height,
-                                 int pitch,
-                                 uint8_t*& dest_buf,
-                                 FX_DWORD& dest_size) {
-  CCodec_FaxEncoder encoder(src_buf, width, height, pitch);
-  encoder.Encode(dest_buf, dest_size);
-  return TRUE;
-}
 ICodec_ScanlineDecoder* CCodec_FaxModule::CreateDecoder(
     const uint8_t* src_buf,
     FX_DWORD src_size,
diff --git a/core/src/fxcodec/codec/fx_codec_flate.cpp b/core/src/fxcodec/codec/fx_codec_flate.cpp
index b293781318..844a17e282 100644
--- a/core/src/fxcodec/codec/fx_codec_flate.cpp
+++ b/core/src/fxcodec/codec/fx_codec_flate.cpp
@@ -25,11 +25,11 @@ static int FPDFAPI_FlateGetTotalOut(void* context) {
 static int FPDFAPI_FlateGetTotalIn(void* context) {
   return ((z_stream*)context)->total_in;
 }
-static void FPDFAPI_FlateCompress(unsigned char* dest_buf,
+static bool FPDFAPI_FlateCompress(unsigned char* dest_buf,
                                   unsigned long* dest_size,
                                   const unsigned char* src_buf,
                                   unsigned long src_size) {
-  compress(dest_buf, dest_size, src_buf, src_size);
+  return compress(dest_buf, dest_size, src_buf, src_size) == Z_OK;
 }
 void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int),
                         void (*free_func)(void*, void*)) {
@@ -225,7 +225,7 @@ int CLZWDecoder::Decode(uint8_t* dest_buf,
   return 0;
 }
 
-uint8_t PaethPredictor(int a, int b, int c) {
+uint8_t PathPredictor(int a, int b, int c) {
   int p = a + b - c;
   int pa = FXSYS_abs(p - a);
   int pb = FXSYS_abs(p - b);
@@ -239,16 +239,8 @@ uint8_t PaethPredictor(int a, int b, int c) {
   return (uint8_t)c;
 }
 
-FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf,
-                            FX_DWORD& data_size,
-                            int predictor,
-                            int Colors,
-                            int BitsPerComponent,
-                            int Columns) {
-  const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
-  const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
-  if (row_size <= 0)
-    return FALSE;
+void PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size) {
+  const int row_size = 7;
   const int row_count = (data_size + row_size - 1) / row_size;
   const int last_row_size = data_size % row_size;
   uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count);
@@ -256,67 +248,12 @@ FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf,
   uint8_t* pSrcData = data_buf;
   uint8_t* pDestData = dest_buf;
   for (int row = 0; row < row_count; row++) {
-    if (predictor == 10) {
-      pDestData[0] = 0;
-      int move_size = row_size;
-      if (move_size * (row + 1) > (int)data_size) {
-        move_size = data_size - (move_size * row);
-      }
-      FXSYS_memmove(pDestData + 1, pSrcData, move_size);
-      pDestData += (move_size + 1);
-      pSrcData += move_size;
-      byte_cnt += move_size;
-      continue;
-    }
     for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) {
-      switch (predictor) {
-        case 11: {
-          pDestData[0] = 1;
-          uint8_t left = 0;
-          if (byte >= BytesPerPixel) {
-            left = pSrcData[byte - BytesPerPixel];
-          }
-          pDestData[byte + 1] = pSrcData[byte] - left;
-        } break;
-        case 12: {
           pDestData[0] = 2;
           uint8_t up = 0;
-          if (row) {
+          if (row)
             up = pSrcData[byte - row_size];
-          }
           pDestData[byte + 1] = pSrcData[byte] - up;
-        } break;
-        case 13: {
-          pDestData[0] = 3;
-          uint8_t left = 0;
-          if (byte >= BytesPerPixel) {
-            left = pSrcData[byte - BytesPerPixel];
-          }
-          uint8_t up = 0;
-          if (row) {
-            up = pSrcData[byte - row_size];
-          }
-          pDestData[byte + 1] = pSrcData[byte] - (left + up) / 2;
-        } break;
-        case 14: {
-          pDestData[0] = 4;
-          uint8_t left = 0;
-          if (byte >= BytesPerPixel) {
-            left = pSrcData[byte - BytesPerPixel];
-          }
-          uint8_t up = 0;
-          if (row) {
-            up = pSrcData[byte - row_size];
-          }
-          uint8_t upper_left = 0;
-          if (byte >= BytesPerPixel && row) {
-            upper_left = pSrcData[byte - row_size - BytesPerPixel];
-          }
-          pDestData[byte + 1] =
-              pSrcData[byte] - PaethPredictor(left, up, upper_left);
-        } break;
-        default: { pDestData[byte + 1] = pSrcData[byte]; } break;
-      }
       byte_cnt++;
     }
     pDestData += (row_size + 1);
@@ -326,7 +263,6 @@ FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf,
   data_buf = dest_buf;
   data_size = (row_size + 1) * row_count -
               (last_row_size > 0 ? (row_size - last_row_size) : 0);
-  return TRUE;
 }
 
 void PNG_PredictLine(uint8_t* pDestData,
@@ -386,7 +322,7 @@ void PNG_PredictLine(uint8_t* pDestData,
         if (byte >= BytesPerPixel && pLastLine) {
           upper_left = pLastLine[byte - BytesPerPixel];
         }
-        pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
+        pDestData[byte] = raw_byte + PathPredictor(left, up, upper_left);
         break;
       }
       default:
@@ -471,7 +407,7 @@ FX_BOOL PNG_Predictor(uint8_t*& data_buf,
           if (byte >= BytesPerPixel && row) {
             upper_left = pDestData[byte - row_size - BytesPerPixel];
           }
-          pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
+          pDestData[byte] = raw_byte + PathPredictor(left, up, upper_left);
           break;
         }
         default:
@@ -490,73 +426,6 @@ FX_BOOL PNG_Predictor(uint8_t*& data_buf,
   return TRUE;
 }
 
-void TIFF_PredictorEncodeLine(uint8_t* dest_buf,
-                              int row_size,
-                              int BitsPerComponent,
-                              int Colors,
-                              int Columns) {
-  int BytesPerPixel = BitsPerComponent * Colors / 8;
-  if (BitsPerComponent < 8) {
-    uint8_t mask = 0x01;
-    if (BitsPerComponent == 2) {
-      mask = 0x03;
-    } else if (BitsPerComponent == 4) {
-      mask = 0x0F;
-    }
-    int row_bits = Colors * BitsPerComponent * Columns;
-    for (int i = row_bits - BitsPerComponent; i >= BitsPerComponent;
-         i -= BitsPerComponent) {
-      int col = i % 8;
-      int index = i / 8;
-      int col_pre =
-          (col == 0) ? (8 - BitsPerComponent) : (col - BitsPerComponent);
-      int index_pre = (col == 0) ? (index - 1) : index;
-      uint8_t cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask;
-      uint8_t left =
-          (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask;
-      cur -= left;
-      cur &= mask;
-      cur <<= (8 - col - BitsPerComponent);
-      dest_buf[index] &= ~(mask << ((8 - col - BitsPerComponent)));
-      dest_buf[index] |= cur;
-    }
-  } else if (BitsPerComponent == 8) {
-    for (int i = row_size - 1; i >= BytesPerPixel; i--) {
-      dest_buf[i] -= dest_buf[i - BytesPerPixel];
-    }
-  } else {
-    for (int i = row_size - BytesPerPixel; i >= BytesPerPixel;
-         i -= BytesPerPixel) {
-      FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1];
-      pixel -=
-          (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
-      dest_buf[i] = pixel >> 8;
-      dest_buf[i + 1] = (uint8_t)pixel;
-    }
-  }
-}
-
-FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf,
-                             FX_DWORD& data_size,
-                             int Colors,
-                             int BitsPerComponent,
-                             int Columns) {
-  int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
-  if (row_size == 0)
-    return FALSE;
-  const int row_count = (data_size + row_size - 1) / row_size;
-  const int last_row_size = data_size % row_size;
-  for (int row = 0; row < row_count; row++) {
-    uint8_t* scan_line = data_buf + row * row_size;
-    if ((row + 1) * row_size > (int)data_size) {
-      row_size = last_row_size;
-    }
-    TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors,
-                             Columns);
-  }
-  return TRUE;
-}
-
 void TIFF_PredictLine(uint8_t* dest_buf,
                       FX_DWORD row_size,
                       int BitsPerComponent,
@@ -963,41 +832,29 @@ FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW,
   }
   return ret ? offset : -1;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
+
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf,
+                                FX_DWORD src_size,
+                                uint8_t** dest_buf,
+                                FX_DWORD* dest_size) {
+  *dest_size = src_size + src_size / 1000 + 12;
+  *dest_buf = FX_Alloc(uint8_t, *dest_size);
+  unsigned long temp_size = *dest_size;
+  if (!FPDFAPI_FlateCompress(*dest_buf, &temp_size, src_buf, src_size))
+    return false;
+
+  *dest_size = (FX_DWORD)temp_size;
+  return true;
+}
+
+bool CCodec_FlateModule::PngEncode(const uint8_t* src_buf,
                                    FX_DWORD src_size,
-                                   int predictor,
-                                   int Colors,
-                                   int BitsPerComponent,
-                                   int Columns,
-                                   uint8_t*& dest_buf,
-                                   FX_DWORD& dest_size) {
-  if (predictor != 2 && predictor < 10) {
-    return Encode(src_buf, src_size, dest_buf, dest_size);
-  }
-  uint8_t* pSrcBuf = NULL;
-  pSrcBuf = FX_Alloc(uint8_t, src_size);
+                                   uint8_t** dest_buf,
+                                   FX_DWORD* dest_size) {
+  uint8_t* pSrcBuf = FX_Alloc(uint8_t, src_size);
   FXSYS_memcpy(pSrcBuf, src_buf, src_size);
-  FX_BOOL ret = TRUE;
-  if (predictor == 2) {
-    ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
-                               Columns);
-  } else if (predictor >= 10) {
-    ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
-                              BitsPerComponent, Columns);
-  }
-  if (ret)
-    ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
+  PNG_PredictorEncode(pSrcBuf, src_size);
+  FX_BOOL ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
   FX_Free(pSrcBuf);
   return ret;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
-                                   FX_DWORD src_size,
-                                   uint8_t*& dest_buf,
-                                   FX_DWORD& dest_size) {
-  dest_size = src_size + src_size / 1000 + 12;
-  dest_buf = FX_Alloc(uint8_t, dest_size);
-  unsigned long temp_size = dest_size;
-  FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
-  dest_size = (FX_DWORD)temp_size;
-  return TRUE;
-}
diff --git a/core/src/fxcodec/codec/fx_codec_jpeg.cpp b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
index 043964f254..820a5c7004 100644
--- a/core/src/fxcodec/codec/fx_codec_jpeg.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
@@ -74,171 +74,17 @@ 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;
@@ -252,7 +98,7 @@ static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf,
   jmp_buf mark;
   cinfo.client_data = &mark;
   if (setjmp(mark) == -1) {
-    return FALSE;
+    return false;
   }
   jpeg_create_decompress(&cinfo);
   struct jpeg_source_mgr src;
@@ -266,30 +112,21 @@ static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf,
   cinfo.src = &src;
   if (setjmp(mark) == -1) {
     jpeg_destroy_decompress(&cinfo);
-    return FALSE;
-  }
-  if (icc_buf_ptr && icc_length) {
-    jpeg_save_markers(&cinfo, JPEG_MARKER_ICC, JPEG_MARKER_MAXSIZE);
+    return false;
   }
   int ret = jpeg_read_header(&cinfo, TRUE);
   if (ret != JPEG_HEADER_OK) {
     jpeg_destroy_decompress(&cinfo);
-    return FALSE;
+    return false;
   }
-  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;
+  return true;
 }
 
 class CCodec_JpegDecoder : public CCodec_ScanlineDecoder {
@@ -512,31 +349,17 @@ ICodec_ScanlineDecoder* CCodec_JpegModule::CreateDecoder(
   }
   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;