clang-format all code

core/src/fxge/dib/fx_dib_main.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 "../../../include/fxge/fx_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 #include <limits.h>
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
-                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& pal, void* pIccTransform);
-void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k)
-{
-    c = FXSYS_GetCValue(cmyk);
-    m = FXSYS_GetMValue(cmyk);
-    y = FXSYS_GetYValue(cmyk);
-    k = FXSYS_GetKValue(cmyk);
-}
-void ArgbDecode(FX_DWORD argb, int& a, int& r, int& g, int& b)
-{
-    a = FXARGB_A(argb);
-    r = FXARGB_R(argb);
-    g = FXARGB_G(argb);
-    b = FXARGB_B(argb);
-}
-void ArgbDecode(FX_DWORD argb, int& a, FX_COLORREF& rgb)
-{
-    a = FXARGB_A(argb);
-    rgb = FXSYS_RGB(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
-}
-FX_DWORD ArgbEncode(int a, FX_COLORREF rgb)
-{
-    return FXARGB_MAKE(a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb), FXSYS_GetBValue(rgb));
-}
-CFX_DIBSource::CFX_DIBSource()
-{
-    m_bpp = 0;
-    m_AlphaFlag = 0;
-    m_Width = m_Height = 0;
-    m_Pitch = 0;
+FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
+                      FX_LPBYTE dest_buf,
+                      int dest_pitch,
+                      int width,
+                      int height,
+                      const CFX_DIBSource* pSrcBitmap,
+                      int src_left,
+                      int src_top,
+                      FX_DWORD*& pal,
+                      void* pIccTransform);
+void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k) {
+  c = FXSYS_GetCValue(cmyk);
+  m = FXSYS_GetMValue(cmyk);
+  y = FXSYS_GetYValue(cmyk);
+  k = FXSYS_GetKValue(cmyk);
+}
+void ArgbDecode(FX_DWORD argb, int& a, int& r, int& g, int& b) {
+  a = FXARGB_A(argb);
+  r = FXARGB_R(argb);
+  g = FXARGB_G(argb);
+  b = FXARGB_B(argb);
+}
+void ArgbDecode(FX_DWORD argb, int& a, FX_COLORREF& rgb) {
+  a = FXARGB_A(argb);
+  rgb = FXSYS_RGB(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
+}
+FX_DWORD ArgbEncode(int a, FX_COLORREF rgb) {
+  return FXARGB_MAKE(
+      a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb), FXSYS_GetBValue(rgb));
+}
+CFX_DIBSource::CFX_DIBSource() {
+  m_bpp = 0;
+  m_AlphaFlag = 0;
+  m_Width = m_Height = 0;
+  m_Pitch = 0;
+  m_pPalette = NULL;
+  m_pAlphaMask = NULL;
+}
+CFX_DIBSource::~CFX_DIBSource() {
+  if (m_pPalette) {
+    FX_Free(m_pPalette);
+  }
+  if (m_pAlphaMask) {
+    delete m_pAlphaMask;
+  }
+}
+CFX_DIBitmap::CFX_DIBitmap() {
+  m_bExtBuf = FALSE;
+  m_pBuffer = NULL;
+  m_pPalette = NULL;
+}
+#define _MAX_OOM_LIMIT_ 12000000
+FX_BOOL CFX_DIBitmap::Create(int width,
+                             int height,
+                             FXDIB_Format format,
+                             FX_LPBYTE pBuffer,
+                             int pitch) {
+  m_pBuffer = NULL;
+  m_bpp = (FX_BYTE)format;
+  m_AlphaFlag = (FX_BYTE)(format >> 8);
+  m_Width = m_Height = m_Pitch = 0;
+  if (width <= 0 || height <= 0 || pitch < 0) {
+    return FALSE;
+  }
+  if ((INT_MAX - 31) / width < (format & 0xff)) {
+    return FALSE;
+  }
+  if (!pitch) {
+    pitch = (width * (format & 0xff) + 31) / 32 * 4;
+  }
+  if ((1 << 30) / pitch < height) {
+    return FALSE;
+  }
+  if (pBuffer) {
+    m_pBuffer = pBuffer;
+    m_bExtBuf = TRUE;
+  } else {
+    int size = pitch * height + 4;
+    int oomlimit = _MAX_OOM_LIMIT_;
+    if (oomlimit >= 0 && size >= oomlimit) {
+      m_pBuffer = FX_AllocNL(FX_BYTE, size);
+    } else {
+      m_pBuffer = FX_Alloc(FX_BYTE, size);
+    }
+    if (m_pBuffer == NULL) {
+      return FALSE;
+    }
+  }
+  m_Width = width;
+  m_Height = height;
+  m_Pitch = pitch;
+  if (HasAlpha() && format != FXDIB_Argb) {
+    FX_BOOL ret = TRUE;
+    ret = BuildAlphaMask();
+    if (!ret) {
+      if (!m_bExtBuf && m_pBuffer) {
+        FX_Free(m_pBuffer);
+        m_pBuffer = NULL;
+        m_Width = m_Height = m_Pitch = 0;
+        return FALSE;
+      }
+    }
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc) {
+  if (m_pBuffer) {
+    return FALSE;
+  }
+  if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
+    return FALSE;
+  }
+  CopyPalette(pSrc->GetPalette());
+  CopyAlphaMask(pSrc->m_pAlphaMask);
+  for (int row = 0; row < pSrc->GetHeight(); row++) {
+    FXSYS_memcpy32(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
+  }
+  return TRUE;
+}
+CFX_DIBitmap::~CFX_DIBitmap() {
+  if (m_pBuffer && !m_bExtBuf) {
+    FX_Free(m_pBuffer);
+  }
+  m_pBuffer = NULL;
+}
+void CFX_DIBitmap::TakeOver(CFX_DIBitmap* pSrcBitmap) {
+  if (m_pBuffer && !m_bExtBuf) {
+    FX_Free(m_pBuffer);
+  }
+  if (m_pPalette) {
+    FX_Free(m_pPalette);
+  }
+  if (m_pAlphaMask) {
+    delete m_pAlphaMask;
+  }
+  m_pBuffer = pSrcBitmap->m_pBuffer;
+  m_pPalette = pSrcBitmap->m_pPalette;
+  m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
+  pSrcBitmap->m_pBuffer = NULL;
+  pSrcBitmap->m_pPalette = NULL;
+  pSrcBitmap->m_pAlphaMask = NULL;
+  m_bpp = pSrcBitmap->m_bpp;
+  m_bExtBuf = pSrcBitmap->m_bExtBuf;
+  m_AlphaFlag = pSrcBitmap->m_AlphaFlag;
+  m_Width = pSrcBitmap->m_Width;
+  m_Height = pSrcBitmap->m_Height;
+  m_Pitch = pSrcBitmap->m_Pitch;
+}
+CFX_DIBitmap* CFX_DIBSource::Clone(const FX_RECT* pClip) const {
+  FX_RECT rect(0, 0, m_Width, m_Height);
+  if (pClip) {
+    rect.Intersect(*pClip);
+    if (rect.IsEmpty()) {
+      return NULL;
+    }
+  }
+  CFX_DIBitmap* pNewBitmap = FX_NEW CFX_DIBitmap;
+  if (!pNewBitmap) {
+    return NULL;
+  }
+  if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) {
+    delete pNewBitmap;
+    return NULL;
+  }
+  pNewBitmap->CopyPalette(m_pPalette);
+  pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
+  if (GetBPP() == 1 && rect.left % 8 != 0) {
+    int left_shift = rect.left % 32;
+    int right_shift = 32 - left_shift;
+    int dword_count = pNewBitmap->m_Pitch / 4;
+    for (int row = rect.top; row < rect.bottom; row++) {
+      FX_DWORD* src_scan = (FX_DWORD*)GetScanline(row) + rect.left / 32;
+      FX_DWORD* dest_scan = (FX_DWORD*)pNewBitmap->GetScanline(row - rect.top);
+      for (int i = 0; i < dword_count; i++) {
+        dest_scan[i] =
+            (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
+      }
+    }
+  } else {
+    int copy_len = (pNewBitmap->GetWidth() * pNewBitmap->GetBPP() + 7) / 8;
+    if (m_Pitch < (FX_DWORD)copy_len) {
+      copy_len = m_Pitch;
+    }
+    for (int row = rect.top; row < rect.bottom; row++) {
+      FX_LPCBYTE src_scan = GetScanline(row) + rect.left * m_bpp / 8;
+      FX_LPBYTE dest_scan = (FX_LPBYTE)pNewBitmap->GetScanline(row - rect.top);
+      FXSYS_memcpy32(dest_scan, src_scan, copy_len);
+    }
+  }
+  return pNewBitmap;
+}
+void CFX_DIBSource::BuildPalette() {
+  if (m_pPalette) {
+    return;
+  }
+  if (GetBPP() == 1) {
+    m_pPalette = FX_Alloc(FX_DWORD, 2);
+    if (!m_pPalette) {
+      return;
+    }
+    if (IsCmykImage()) {
+      m_pPalette[0] = 0xff;
+      m_pPalette[1] = 0;
+    } else {
+      m_pPalette[0] = 0xff000000;
+      m_pPalette[1] = 0xffffffff;
+    }
+  } else if (GetBPP() == 8) {
+    m_pPalette = FX_Alloc(FX_DWORD, 256);
+    if (!m_pPalette) {
+      return;
+    }
+    if (IsCmykImage()) {
+      for (int i = 0; i < 256; i++) {
+        m_pPalette[i] = 0xff - i;
+      }
+    } else {
+      for (int i = 0; i < 256; i++) {
+        m_pPalette[i] = 0xff000000 | (i * 0x10101);
+      }
+    }
+  }
+}
+FX_BOOL CFX_DIBSource::BuildAlphaMask() {
+  if (m_pAlphaMask) {
+    return TRUE;
+  }
+  m_pAlphaMask = FX_NEW CFX_DIBitmap;
+  if (!m_pAlphaMask) {
+    return FALSE;
+  }
+  if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+    delete m_pAlphaMask;
+    m_pAlphaMask = NULL;
+    return FALSE;
+  }
+  FXSYS_memset8(m_pAlphaMask->GetBuffer(),
+                0xff,
+                m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
+  return TRUE;
+}
+FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const {
+  ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
+  if (m_pPalette) {
+    return m_pPalette[index];
+  }
+  if (IsCmykImage()) {
+    if (GetBPP() == 1) {
+      return index ? 0 : 0xff;
+    }
+    return 0xff - index;
+  }
+  if (GetBPP() == 1) {
+    return index ? 0xffffffff : 0xff000000;
+  }
+  return index * 0x10101 | 0xff000000;
+}
+void CFX_DIBSource::SetPaletteEntry(int index, FX_DWORD color) {
+  ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
+  if (m_pPalette == NULL) {
+    BuildPalette();
+  }
+  m_pPalette[index] = color;
+}
+int CFX_DIBSource::FindPalette(FX_DWORD color) const {
+  ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
+  if (m_pPalette == NULL) {
+    if (IsCmykImage()) {
+      if (GetBPP() == 1) {
+        return ((FX_BYTE)color == 0xff) ? 0 : 1;
+      }
+      return 0xff - (FX_BYTE)color;
+    }
+    if (GetBPP() == 1) {
+      return ((FX_BYTE)color == 0xff) ? 1 : 0;
+    }
+    return (FX_BYTE)color;
+  }
+  int palsize = (1 << GetBPP());
+  for (int i = 0; i < palsize; i++)
+    if (m_pPalette[i] == color) {
+      return i;
+    }
+  return -1;
+}
+void CFX_DIBitmap::Clear(FX_DWORD color) {
+  if (m_pBuffer == NULL) {
+    return;
+  }
+  switch (GetFormat()) {
+    case FXDIB_1bppMask:
+      FXSYS_memset8(
+          m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
+      break;
+    case FXDIB_1bppRgb: {
+      int index = FindPalette(color);
+      FXSYS_memset8(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
+      break;
+    }
+    case FXDIB_8bppMask:
+      FXSYS_memset8(m_pBuffer, color >> 24, m_Pitch * m_Height);
+      break;
+    case FXDIB_8bppRgb: {
+      int index = FindPalette(color);
+      FXSYS_memset8(m_pBuffer, index, m_Pitch * m_Height);
+      break;
+    }
+    case FXDIB_Rgb:
+    case FXDIB_Rgba: {
+      int a, r, g, b;
+      ArgbDecode(color, a, r, g, b);
+      if (r == g && g == b) {
+        FXSYS_memset8(m_pBuffer, r, m_Pitch * m_Height);
+      } else {
+        int byte_pos = 0;
+        for (int col = 0; col < m_Width; col++) {
+          m_pBuffer[byte_pos++] = b;
+          m_pBuffer[byte_pos++] = g;
+          m_pBuffer[byte_pos++] = r;
+        }
+        for (int row = 1; row < m_Height; row++) {
+          FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+        }
+      }
+      break;
+    }
+    case FXDIB_Rgb32:
+    case FXDIB_Argb: {
+      color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
+      for (int i = 0; i < m_Width; i++) {
+        ((FX_DWORD*)m_pBuffer)[i] = color;
+      }
+      for (int row = 1; row < m_Height; row++) {
+        FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+void CFX_DIBSource::GetOverlapRect(int& dest_left,
+                                   int& dest_top,
+                                   int& width,
+                                   int& height,
+                                   int src_width,
+                                   int src_height,
+                                   int& src_left,
+                                   int& src_top,
+                                   const CFX_ClipRgn* pClipRgn) {
+  if (width == 0 || height == 0) {
+    return;
+  }
+  ASSERT(width > 0 && height > 0);
+  if (dest_left > m_Width || dest_top > m_Height) {
+    width = 0;
+    height = 0;
+    return;
+  }
+  int x_offset = dest_left - src_left;
+  int y_offset = dest_top - src_top;
+  FX_RECT src_rect(src_left, src_top, src_left + width, src_top + height);
+  FX_RECT src_bound(0, 0, src_width, src_height);
+  src_rect.Intersect(src_bound);
+  FX_RECT dest_rect(src_rect.left + x_offset,
+                    src_rect.top + y_offset,
+                    src_rect.right + x_offset,
+                    src_rect.bottom + y_offset);
+  FX_RECT dest_bound(0, 0, m_Width, m_Height);
+  dest_rect.Intersect(dest_bound);
+  if (pClipRgn) {
+    dest_rect.Intersect(pClipRgn->GetBox());
+  }
+  dest_left = dest_rect.left;
+  dest_top = dest_rect.top;
+  src_left = dest_left - x_offset;
+  src_top = dest_top - y_offset;
+  width = dest_rect.right - dest_rect.left;
+  height = dest_rect.bottom - dest_rect.top;
+}
+FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left,
+                                     int dest_top,
+                                     int width,
+                                     int height,
+                                     const CFX_DIBSource* pSrcBitmap,
+                                     int src_left,
+                                     int src_top,
+                                     void* pIccTransform) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  GetOverlapRect(dest_left,
+                 dest_top,
+                 width,
+                 height,
+                 pSrcBitmap->GetWidth(),
+                 pSrcBitmap->GetHeight(),
+                 src_left,
+                 src_top,
+                 NULL);
+  if (width == 0 || height == 0) {
+    return TRUE;
+  }
+  FXDIB_Format dest_format = GetFormat();
+  FXDIB_Format src_format = pSrcBitmap->GetFormat();
+  if (dest_format == src_format && pIccTransform == NULL) {
+    if (GetBPP() == 1) {
+      for (int row = 0; row < height; row++) {
+        FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
+        FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
+        for (int col = 0; col < width; col++) {
+          if (src_scan[(src_left + col) / 8] &
+              (1 << (7 - (src_left + col) % 8))) {
+            dest_scan[(dest_left + col) / 8] |= 1
+                                                << (7 - (dest_left + col) % 8);
+          } else {
+            dest_scan[(dest_left + col) / 8] &=
+                ~(1 << (7 - (dest_left + col) % 8));
+          }
+        }
+      }
+    } else {
+      int Bpp = GetBPP() / 8;
+      for (int row = 0; row < height; row++) {
+        FX_LPBYTE dest_scan =
+            m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
+        FX_LPCBYTE src_scan =
+            pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
+        FXSYS_memcpy32(dest_scan, src_scan, width * Bpp);
+      }
+    }
+  } else {
+    if (m_pPalette) {
+      return FALSE;
+    }
+    if (m_bpp == 8) {
+      dest_format = FXDIB_8bppMask;
+    }
+    FX_LPBYTE dest_buf =
+        m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
+    FX_DWORD* d_plt = NULL;
+    if (!ConvertBuffer(dest_format,
+                       dest_buf,
+                       m_Pitch,
+                       width,
+                       height,
+                       pSrcBitmap,
+                       src_left,
+                       src_top,
+                       d_plt,
+                       pIccTransform)) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+#ifndef _FPDFAPI_MINI_
+FX_BOOL CFX_DIBitmap::TransferMask(int dest_left,
+                                   int dest_top,
+                                   int width,
+                                   int height,
+                                   const CFX_DIBSource* pMask,
+                                   FX_DWORD color,
+                                   int src_left,
+                                   int src_top,
+                                   int alpha_flag,
+                                   void* pIccTransform) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  ASSERT(HasAlpha() && (m_bpp >= 24));
+  ASSERT(pMask->IsAlphaMask());
+  if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
+    return FALSE;
+  }
+  GetOverlapRect(dest_left,
+                 dest_top,
+                 width,
+                 height,
+                 pMask->GetWidth(),
+                 pMask->GetHeight(),
+                 src_left,
+                 src_top,
+                 NULL);
+  if (width == 0 || height == 0) {
+    return TRUE;
+  }
+  int src_bpp = pMask->GetBPP();
+  int alpha;
+  FX_DWORD dst_color;
+  if (alpha_flag >> 8) {
+    alpha = alpha_flag & 0xff;
+    dst_color = FXCMYK_TODIB(color);
+  } else {
+    alpha = FXARGB_A(color);
+    dst_color = FXARGB_TODIB(color);
+  }
+  FX_LPBYTE color_p = (FX_LPBYTE)&dst_color;
+  if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
+    ICodec_IccModule* pIccModule =
+        CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+    pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
+  } else {
+    if (alpha_flag >> 8 && !IsCmykImage())
+      AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color),
+                         FXSYS_GetMValue(color),
+                         FXSYS_GetYValue(color),
+                         FXSYS_GetKValue(color),
+                         color_p[2],
+                         color_p[1],
+                         color_p[0]);
+    else if (!(alpha_flag >> 8) && IsCmykImage()) {
+      return FALSE;
+    }
+  }
+  if (!IsCmykImage()) {
+    color_p[3] = (FX_BYTE)alpha;
+  }
+  if (GetFormat() == FXDIB_Argb) {
+    for (int row = 0; row < height; row++) {
+      FX_DWORD* dest_pos =
+          (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
+      FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
+      if (src_bpp == 1) {
+        for (int col = 0; col < width; col++) {
+          int src_bitpos = src_left + col;
+          if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
+            *dest_pos = dst_color;
+          } else {
+            *dest_pos = 0;
+          }
+          dest_pos++;
+        }
+      } else {
+        src_scan += src_left;
+        dst_color = FXARGB_TODIB(dst_color);
+        dst_color &= 0xffffff;
+        for (int col = 0; col < width; col++) {
+          FXARGB_SETDIB(dest_pos++,
+                        dst_color | ((alpha * (*src_scan++) / 255) << 24));
+        }
+      }
+    }
+  } else {
+    int comps = m_bpp / 8;
+    for (int row = 0; row < height; row++) {
+      FX_LPBYTE dest_color_pos =
+          m_pBuffer + (dest_top + row) * m_Pitch + dest_left * comps;
+      FX_LPBYTE dest_alpha_pos =
+          (FX_LPBYTE)m_pAlphaMask->GetScanline(dest_top + row) + dest_left;
+      FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
+      if (src_bpp == 1) {
+        for (int col = 0; col < width; col++) {
+          int src_bitpos = src_left + col;
+          if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
+            FXSYS_memcpy32(dest_color_pos, color_p, comps);
+            *dest_alpha_pos = 0xff;
+          } else {
+            FXSYS_memset32(dest_color_pos, 0, comps);
+            *dest_alpha_pos = 0;
+          }
+          dest_color_pos += comps;
+          dest_alpha_pos++;
+        }
+      } else {
+        src_scan += src_left;
+        for (int col = 0; col < width; col++) {
+          FXSYS_memcpy32(dest_color_pos, color_p, comps);
+          dest_color_pos += comps;
+          *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
+        }
+      }
+    }
+  }
+  return TRUE;
+}
+#endif
+void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size) {
+  if (pSrc == NULL || GetBPP() > 8) {
+    if (m_pPalette) {
+      FX_Free(m_pPalette);
+    }
     m_pPalette = NULL;
-    m_pAlphaMask = NULL;
-}
-CFX_DIBSource::~CFX_DIBSource()
-{
-    if (m_pPalette) {
-        FX_Free(m_pPalette);
-    }
-    if (m_pAlphaMask) {
-        delete m_pAlphaMask;
-    }
-}
-CFX_DIBitmap::CFX_DIBitmap()
-{
-    m_bExtBuf = FALSE;
-    m_pBuffer = NULL;
-    m_pPalette = NULL;
-}
-#define _MAX_OOM_LIMIT_ 12000000
-FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, FX_LPBYTE pBuffer, int pitch)
-{
-    m_pBuffer = NULL;
-    m_bpp = (FX_BYTE)format;
-    m_AlphaFlag = (FX_BYTE)(format >> 8);
-    m_Width = m_Height = m_Pitch = 0;
-    if (width <= 0 || height <= 0 || pitch < 0) {
-        return FALSE;
-    }
-    if ((INT_MAX - 31) / width < (format & 0xff)) {
-        return FALSE;
-    }
-    if (!pitch) {
-        pitch = (width * (format & 0xff) + 31) / 32 * 4;
-    }
-    if ((1 << 30) / pitch < height) {
-        return FALSE;
-    }
-    if (pBuffer) {
-        m_pBuffer = pBuffer;
-        m_bExtBuf = TRUE;
+  } else {
+    FX_DWORD pal_size = 1 << GetBPP();
+    if (m_pPalette == NULL) {
+      m_pPalette = FX_Alloc(FX_DWORD, pal_size);
+    }
+    if (!m_pPalette) {
+      return;
+    }
+    if (pal_size > size) {
+      pal_size = size;
+    }
+    FXSYS_memcpy32(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
+  }
+}
+void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const {
+  ASSERT(GetBPP() <= 8 && !IsCmykImage());
+  if (GetBPP() == 1) {
+    pal[0] =
+        ((m_pPalette ? m_pPalette[0] : 0xff000000) & 0xffffff) | (alpha << 24);
+    pal[1] =
+        ((m_pPalette ? m_pPalette[1] : 0xffffffff) & 0xffffff) | (alpha << 24);
+    return;
+  }
+  if (m_pPalette) {
+    for (int i = 0; i < 256; i++) {
+      pal[i] = (m_pPalette[i] & 0x00ffffff) | (alpha << 24);
+    }
+  } else {
+    for (int i = 0; i < 256; i++) {
+      pal[i] = (i * 0x10101) | (alpha << 24);
+    }
+  }
+}
+CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const {
+  ASSERT(GetFormat() == FXDIB_Argb);
+  FX_RECT rect(0, 0, m_Width, m_Height);
+  if (pClip) {
+    rect.Intersect(*pClip);
+    if (rect.IsEmpty()) {
+      return NULL;
+    }
+  }
+  CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
+  if (!pMask) {
+    return NULL;
+  }
+  if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
+    delete pMask;
+    return NULL;
+  }
+  for (int row = rect.top; row < rect.bottom; row++) {
+    FX_LPCBYTE src_scan = GetScanline(row) + rect.left * 4 + 3;
+    FX_LPBYTE dest_scan = (FX_LPBYTE)pMask->GetScanline(row - rect.top);
+    for (int col = rect.left; col < rect.right; col++) {
+      *dest_scan++ = *src_scan;
+      src_scan += 4;
+    }
+  }
+  return pMask;
+}
+FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
+                                     const FX_RECT* pClip) {
+  if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
+    return FALSE;
+  }
+  if (pAlphaMask) {
+    FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
+    if (pClip) {
+      rect.Intersect(*pClip);
+      if (rect.IsEmpty() || rect.Width() != m_Width ||
+          rect.Height() != m_Height) {
+        return FALSE;
+      }
     } else {
-        int size = pitch * height + 4;
-        int oomlimit = _MAX_OOM_LIMIT_;
-        if (oomlimit >= 0 && size >= oomlimit) {
-            m_pBuffer = FX_AllocNL(FX_BYTE, size);
+      if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
+        return FALSE;
+      }
+    }
+    for (int row = 0; row < m_Height; row++)
+      FXSYS_memcpy32((void*)m_pAlphaMask->GetScanline(row),
+                     pAlphaMask->GetScanline(row + rect.top) + rect.left,
+                     m_pAlphaMask->m_Pitch);
+  } else {
+    m_pAlphaMask->Clear(0xff000000);
+  }
+  return TRUE;
+}
+const int g_ChannelOffset[] = { 0, 2, 1, 0, 0, 1, 2, 3, 3 };
+FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  FXDIB_Channel srcChannel) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
+  CFX_DIBitmap* pDst = this;
+  int destOffset, srcOffset;
+  if (srcChannel == FXDIB_Alpha) {
+    if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
+      return FALSE;
+    }
+    if (pSrcBitmap->GetBPP() == 1) {
+      pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
+      if (pSrcClone == NULL) {
+        return FALSE;
+      }
+    }
+    if (pSrcBitmap->GetFormat() == FXDIB_Argb) {
+      srcOffset = 3;
+    } else {
+      srcOffset = 0;
+    }
+  } else {
+    if (pSrcBitmap->IsAlphaMask()) {
+      return FALSE;
+    }
+    if (pSrcBitmap->GetBPP() < 24) {
+      if (pSrcBitmap->IsCmykImage()) {
+        pSrcClone = pSrcBitmap->CloneConvert(
+            (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
+      } else {
+        pSrcClone = pSrcBitmap->CloneConvert(
+            (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
+      }
+      if (pSrcClone == NULL) {
+        return FALSE;
+      }
+    }
+    srcOffset = g_ChannelOffset[srcChannel];
+  }
+  if (destChannel == FXDIB_Alpha) {
+    if (IsAlphaMask()) {
+      if (!ConvertFormat(FXDIB_8bppMask)) {
+        if (pSrcClone != pSrcBitmap) {
+          delete pSrcClone;
+        }
+        return FALSE;
+      }
+      destOffset = 0;
+    } else {
+      destOffset = 0;
+      if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+        if (pSrcClone != pSrcBitmap) {
+          delete pSrcClone;
+        }
+        return FALSE;
+      }
+      if (GetFormat() == FXDIB_Argb) {
+        destOffset = 3;
+      }
+    }
+  } else {
+    if (IsAlphaMask()) {
+      if (pSrcClone != pSrcBitmap) {
+        delete pSrcClone;
+      }
+      return FALSE;
+    }
+    if (GetBPP() < 24) {
+      if (HasAlpha()) {
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+          if (pSrcClone != pSrcBitmap) {
+            delete pSrcClone;
+          }
+          return FALSE;
+        }
+      } else
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+          if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
+#else
+          if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
+#endif
+        if (pSrcClone != pSrcBitmap) {
+          delete pSrcClone;
+        }
+        return FALSE;
+      }
+    }
+    destOffset = g_ChannelOffset[destChannel];
+  }
+  if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
+    CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
+    if (pSrcClone->GetWidth() != m_Width ||
+        pSrcClone->GetHeight() != m_Height) {
+      if (pAlphaMask) {
+        pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
+        if (pAlphaMask == NULL) {
+          if (pSrcClone != pSrcBitmap) {
+            delete pSrcClone;
+          }
+          return FALSE;
+        }
+      }
+    }
+    if (pSrcClone != pSrcBitmap) {
+      pSrcClone->m_pAlphaMask = NULL;
+      delete pSrcClone;
+    }
+    pSrcClone = pAlphaMask;
+    srcOffset = 0;
+  } else if (pSrcClone->GetWidth() != m_Width ||
+             pSrcClone->GetHeight() != m_Height) {
+    CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
+    if (pSrcClone != pSrcBitmap) {
+      delete pSrcClone;
+    }
+    if (pSrcMatched == NULL) {
+      return FALSE;
+    }
+    pSrcClone = pSrcMatched;
+  }
+  if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
+    pDst = m_pAlphaMask;
+    destOffset = 0;
+  }
+  int srcBytes = pSrcClone->GetBPP() / 8;
+  int destBytes = pDst->GetBPP() / 8;
+  for (int row = 0; row < m_Height; row++) {
+    FX_LPBYTE dest_pos = (FX_LPBYTE)pDst->GetScanline(row) + destOffset;
+    FX_LPCBYTE src_pos = pSrcClone->GetScanline(row) + srcOffset;
+    for (int col = 0; col < m_Width; col++) {
+      *dest_pos = *src_pos;
+      dest_pos += destBytes;
+      src_pos += srcBytes;
+    }
+  }
+  if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
+    delete pSrcClone;
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  int destOffset;
+  if (destChannel == FXDIB_Alpha) {
+    if (IsAlphaMask()) {
+      if (!ConvertFormat(FXDIB_8bppMask)) {
+        return FALSE;
+      }
+      destOffset = 0;
+    } else {
+      destOffset = 0;
+      if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+        return FALSE;
+      }
+      if (GetFormat() == FXDIB_Argb) {
+        destOffset = 3;
+      }
+    }
+  } else {
+    if (IsAlphaMask()) {
+      return FALSE;
+    }
+    if (GetBPP() < 24) {
+      if (HasAlpha()) {
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+          return FALSE;
+        }
+      } else
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+          if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
+        return FALSE;
+      }
+#else
+          if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
+        return FALSE;
+      }
+#endif
+    }
+    destOffset = g_ChannelOffset[destChannel];
+  }
+  int Bpp = GetBPP() / 8;
+  if (Bpp == 1) {
+    FXSYS_memset8(m_pBuffer, value, m_Height * m_Pitch);
+    return TRUE;
+  }
+  if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
+    FXSYS_memset8(m_pAlphaMask->GetBuffer(),
+                  value,
+                  m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
+    return TRUE;
+  }
+  for (int row = 0; row < m_Height; row++) {
+    FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + destOffset;
+    for (int col = 0; col < m_Width; col++) {
+      *scan_line = value;
+      scan_line += Bpp;
+    }
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  ASSERT(pSrcBitmap->IsAlphaMask());
+  if (!pSrcBitmap->IsAlphaMask()) {
+    return FALSE;
+  }
+  if (!IsAlphaMask() && !HasAlpha()) {
+    return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
+  }
+  CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
+  if (pSrcBitmap->GetWidth() != m_Width ||
+      pSrcBitmap->GetHeight() != m_Height) {
+    pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
+    ASSERT(pSrcClone != NULL);
+    if (pSrcClone == NULL) {
+      return FALSE;
+    }
+  }
+  if (IsAlphaMask()) {
+    if (!ConvertFormat(FXDIB_8bppMask)) {
+      if (pSrcClone != pSrcBitmap) {
+        delete pSrcClone;
+      }
+      return FALSE;
+    }
+    for (int row = 0; row < m_Height; row++) {
+      FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row;
+      FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
+      if (pSrcClone->GetBPP() == 1) {
+        for (int col = 0; col < m_Width; col++) {
+          if (!((1 << (7 - col % 8)) & src_scan[col / 8])) {
+            dest_scan[col] = 0;
+          }
+        }
+      } else {
+        for (int col = 0; col < m_Width; col++) {
+          *dest_scan = (*dest_scan) * src_scan[col] / 255;
+          dest_scan++;
+        }
+      }
+    }
+  } else {
+    if (GetFormat() == FXDIB_Argb) {
+      if (pSrcClone->GetBPP() == 1) {
+        if (pSrcClone != pSrcBitmap) {
+          delete pSrcClone;
+        }
+        return FALSE;
+      }
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row + 3;
+        FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
+        for (int col = 0; col < m_Width; col++) {
+          *dest_scan = (*dest_scan) * src_scan[col] / 255;
+          dest_scan += 4;
+        }
+      }
+    } else {
+      m_pAlphaMask->MultiplyAlpha(pSrcClone);
+    }
+  }
+  if (pSrcClone != pSrcBitmap) {
+    delete pSrcClone;
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  switch (GetFormat()) {
+    case FXDIB_1bppRgb: {
+      if (m_pPalette == NULL) {
+        return FALSE;
+      }
+      FX_BYTE gray[2];
+      for (int i = 0; i < 2; i++) {
+        int r = (FX_BYTE)(m_pPalette[i] >> 16);
+        int g = (FX_BYTE)(m_pPalette[i] >> 8);
+        int b = (FX_BYTE)m_pPalette[i];
+        gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
+      }
+      CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
+      if (!pMask) {
+        return FALSE;
+      }
+      if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+        delete pMask;
+        return FALSE;
+      }
+      FXSYS_memset8(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
+        FX_LPBYTE dest_pos = (FX_LPBYTE)pMask->GetScanline(row);
+        for (int col = 0; col < m_Width; col++) {
+          if (src_pos[col / 8] & (1 << (7 - col % 8))) {
+            *dest_pos = gray[1];
+          }
+          dest_pos++;
+        }
+      }
+      TakeOver(pMask);
+      delete pMask;
+      break;
+    }
+    case FXDIB_8bppRgb: {
+      if (m_pPalette == NULL) {
+        return FALSE;
+      }
+      FX_BYTE gray[256];
+      for (int i = 0; i < 256; i++) {
+        int r = (FX_BYTE)(m_pPalette[i] >> 16);
+        int g = (FX_BYTE)(m_pPalette[i] >> 8);
+        int b = (FX_BYTE)m_pPalette[i];
+        gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
+      }
+      CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
+      if (!pMask) {
+        return FALSE;
+      }
+      if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+        delete pMask;
+        return FALSE;
+      }
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
+        FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
+        for (int col = 0; col < m_Width; col++) {
+          *dest_pos++ = gray[*src_pos++];
+        }
+      }
+      TakeOver(pMask);
+      delete pMask;
+      break;
+    }
+    case FXDIB_Rgb: {
+      CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
+      if (!pMask) {
+        return FALSE;
+      }
+      if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+        delete pMask;
+        return FALSE;
+      }
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
+        FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
+        for (int col = 0; col < m_Width; col++) {
+          *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
+          src_pos += 3;
+        }
+      }
+      TakeOver(pMask);
+      delete pMask;
+      break;
+    }
+    case FXDIB_Rgb32: {
+      CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
+      if (!pMask) {
+        return FALSE;
+      }
+      if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+        delete pMask;
+        return FALSE;
+      }
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
+        FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
+        for (int col = 0; col < m_Width; col++) {
+          *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
+          src_pos += 4;
+        }
+      }
+      TakeOver(pMask);
+      delete pMask;
+      break;
+    }
+    default:
+      return FALSE;
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  switch (GetFormat()) {
+    case FXDIB_1bppMask:
+      if (!ConvertFormat(FXDIB_8bppMask)) {
+        return FALSE;
+      }
+      MultiplyAlpha(alpha);
+      break;
+    case FXDIB_8bppMask: {
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch;
+        for (int col = 0; col < m_Width; col++) {
+          scan_line[col] = scan_line[col] * alpha / 255;
+        }
+      }
+      break;
+    }
+    case FXDIB_Argb: {
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + 3;
+        for (int col = 0; col < m_Width; col++) {
+          *scan_line = (*scan_line) * alpha / 255;
+          scan_line += 4;
+        }
+      }
+      break;
+    }
+    default:
+      if (HasAlpha()) {
+        m_pAlphaMask->MultiplyAlpha(alpha);
+      } else if (IsCmykImage()) {
+        if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
+          return FALSE;
+        }
+        m_pAlphaMask->MultiplyAlpha(alpha);
+      } else {
+        if (!ConvertFormat(FXDIB_Argb)) {
+          return FALSE;
+        }
+        MultiplyAlpha(alpha);
+      }
+      break;
+  }
+  return TRUE;
+}
+#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
+FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const {
+  if (m_pBuffer == NULL) {
+    return 0;
+  }
+  FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
+  switch (GetFormat()) {
+    case FXDIB_1bppMask: {
+      if ((*pos) & (1 << (7 - x % 8))) {
+        return 0xff000000;
+      }
+      return 0;
+    }
+    case FXDIB_1bppRgb: {
+      if ((*pos) & (1 << (7 - x % 8))) {
+        return m_pPalette ? m_pPalette[1] : 0xffffffff;
+      } else {
+        return m_pPalette ? m_pPalette[0] : 0xff000000;
+      }
+      break;
+    }
+    case FXDIB_8bppMask:
+      return (*pos) << 24;
+    case FXDIB_8bppRgb:
+      return m_pPalette ? m_pPalette[*pos] : (0xff000000 | ((*pos) * 0x10101));
+    case FXDIB_Rgb:
+    case FXDIB_Rgba:
+    case FXDIB_Rgb32:
+      return FXARGB_GETDIB(pos) | 0xff000000;
+    case FXDIB_Argb:
+      return FXARGB_GETDIB(pos);
+    default:
+      break;
+  }
+  return 0;
+}
+#endif
+void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color) {
+  if (m_pBuffer == NULL) {
+    return;
+  }
+  if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
+    return;
+  }
+  FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
+  switch (GetFormat()) {
+    case FXDIB_1bppMask:
+      if (color >> 24) {
+        *pos |= 1 << (7 - x % 8);
+      } else {
+        *pos &= ~(1 << (7 - x % 8));
+      }
+      break;
+    case FXDIB_1bppRgb:
+      if (m_pPalette) {
+        if (color == m_pPalette[1]) {
+          *pos |= 1 << (7 - x % 8);
         } else {
-            m_pBuffer = FX_Alloc(FX_BYTE, size);
-        }
-        if (m_pBuffer == NULL) {
-            return FALSE;
-        }
-    }
-    m_Width = width;
-    m_Height = height;
-    m_Pitch = pitch;
-    if (HasAlpha() && format != FXDIB_Argb) {
-        FX_BOOL ret = TRUE;
-        ret = BuildAlphaMask();
-        if (!ret) {
-            if (!m_bExtBuf && m_pBuffer) {
-                FX_Free(m_pBuffer);
-                m_pBuffer = NULL;
-                m_Width = m_Height = m_Pitch = 0;
-                return FALSE;
-            }
-        }
-    }
+          *pos &= ~(1 << (7 - x % 8));
+        }
+      } else {
+        if (color == 0xffffffff) {
+          *pos |= 1 << (7 - x % 8);
+        } else {
+          *pos &= ~(1 << (7 - x % 8));
+        }
+      }
+      break;
+    case FXDIB_8bppMask:
+      *pos = (FX_BYTE)(color >> 24);
+      break;
+    case FXDIB_8bppRgb: {
+      if (m_pPalette) {
+        for (int i = 0; i < 256; i++) {
+          if (m_pPalette[i] == color) {
+            *pos = (FX_BYTE)i;
+            return;
+          }
+        }
+        *pos = 0;
+      } else {
+        *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
+      }
+      break;
+    }
+    case FXDIB_Rgb:
+    case FXDIB_Rgb32: {
+      int alpha = FXARGB_A(color);
+      pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
+      pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
+      pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
+      break;
+    }
+    case FXDIB_Rgba: {
+      pos[0] = FXARGB_B(color);
+      pos[1] = FXARGB_G(color);
+      pos[2] = FXARGB_R(color);
+      break;
+    }
+    case FXDIB_Argb:
+      FXARGB_SETDIB(pos, color);
+      break;
+    default:
+      break;
+  }
+}
+void CFX_DIBitmap::DownSampleScanline(int line,
+                                      FX_LPBYTE dest_scan,
+                                      int dest_bpp,
+                                      int dest_width,
+                                      FX_BOOL bFlipX,
+                                      int clip_left,
+                                      int clip_width) const {
+  if (m_pBuffer == NULL) {
+    return;
+  }
+  int src_Bpp = m_bpp / 8;
+  FX_LPBYTE scanline = m_pBuffer + line * m_Pitch;
+  if (src_Bpp == 0) {
+    for (int i = 0; i < clip_width; i++) {
+      FX_DWORD dest_x = clip_left + i;
+      FX_DWORD src_x = dest_x * m_Width / dest_width;
+      if (bFlipX) {
+        src_x = m_Width - src_x - 1;
+      }
+#ifdef FOXIT_CHROME_BUILD
+      src_x %= m_Width;
+#endif
+      dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
+    }
+  } else if (src_Bpp == 1) {
+    for (int i = 0; i < clip_width; i++) {
+      FX_DWORD dest_x = clip_left + i;
+      FX_DWORD src_x = dest_x * m_Width / dest_width;
+      if (bFlipX) {
+        src_x = m_Width - src_x - 1;
+      }
+#ifdef FOXIT_CHROME_BUILD
+      src_x %= m_Width;
+#endif
+      int dest_pos = i;
+      if (m_pPalette) {
+        if (!IsCmykImage()) {
+          dest_pos *= 3;
+          FX_ARGB argb = m_pPalette[scanline[src_x]];
+          dest_scan[dest_pos] = FXARGB_B(argb);
+          dest_scan[dest_pos + 1] = FXARGB_G(argb);
+          dest_scan[dest_pos + 2] = FXARGB_R(argb);
+        } else {
+          dest_pos *= 4;
+          FX_CMYK cmyk = m_pPalette[scanline[src_x]];
+          dest_scan[dest_pos] = FXSYS_GetCValue(cmyk);
+          dest_scan[dest_pos + 1] = FXSYS_GetMValue(cmyk);
+          dest_scan[dest_pos + 2] = FXSYS_GetYValue(cmyk);
+          dest_scan[dest_pos + 3] = FXSYS_GetKValue(cmyk);
+        }
+      } else {
+        dest_scan[dest_pos] = scanline[src_x];
+      }
+    }
+  } else {
+    for (int i = 0; i < clip_width; i++) {
+      FX_DWORD dest_x = clip_left + i;
+      FX_DWORD src_x =
+          bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp
+                 : (dest_x * m_Width / dest_width) * src_Bpp;
+#ifdef FOXIT_CHROME_BUILD
+      src_x %= m_Width * src_Bpp;
+#endif
+      int dest_pos = i * src_Bpp;
+      for (int b = 0; b < src_Bpp; b++) {
+        dest_scan[dest_pos + b] = scanline[src_x + b];
+      }
+    }
+  }
+}
+FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor,
+                                        FX_DWORD backcolor) {
+  ASSERT(!IsAlphaMask());
+  if (m_pBuffer == NULL || IsAlphaMask()) {
+    return FALSE;
+  }
+  int fc, fm, fy, fk, bc, bm, by, bk;
+  int fr, fg, fb, br, bg, bb;
+  FX_BOOL isCmykImage = IsCmykImage();
+  if (isCmykImage) {
+    fc = FXSYS_GetCValue(forecolor);
+    fm = FXSYS_GetMValue(forecolor);
+    fy = FXSYS_GetYValue(forecolor);
+    fk = FXSYS_GetKValue(forecolor);
+    bc = FXSYS_GetCValue(backcolor);
+    bm = FXSYS_GetMValue(backcolor);
+    by = FXSYS_GetYValue(backcolor);
+    bk = FXSYS_GetKValue(backcolor);
+  } else {
+    fr = FXSYS_GetRValue(forecolor);
+    fg = FXSYS_GetGValue(forecolor);
+    fb = FXSYS_GetBValue(forecolor);
+    br = FXSYS_GetRValue(backcolor);
+    bg = FXSYS_GetGValue(backcolor);
+    bb = FXSYS_GetBValue(backcolor);
+  }
+  if (m_bpp <= 8) {
+    if (isCmykImage) {
+      if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
+        return TRUE;
+      }
+    } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
+      return TRUE;
+    }
+    if (m_pPalette == NULL) {
+      BuildPalette();
+    }
+    int size = 1 << m_bpp;
+    if (isCmykImage) {
+      for (int i = 0; i < size; i++) {
+        FX_BYTE b, g, r;
+        AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]),
+                           FXSYS_GetMValue(m_pPalette[i]),
+                           FXSYS_GetYValue(m_pPalette[i]),
+                           FXSYS_GetKValue(m_pPalette[i]),
+                           r,
+                           g,
+                           b);
+        int gray = 255 - FXRGB2GRAY(r, g, b);
+        m_pPalette[i] = CmykEncode(bc + (fc - bc) * gray / 255,
+                                   bm + (fm - bm) * gray / 255,
+                                   by + (fy - by) * gray / 255,
+                                   bk + (fk - bk) * gray / 255);
+      }
+    } else
+      for (int i = 0; i < size; i++) {
+        int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]),
+                              FXARGB_G(m_pPalette[i]),
+                              FXARGB_B(m_pPalette[i]));
+        m_pPalette[i] = FXARGB_MAKE(0xff,
+                                    br + (fr - br) * gray / 255,
+                                    bg + (fg - bg) * gray / 255,
+                                    bb + (fb - bb) * gray / 255);
+      }
     return TRUE;
-}
-FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
-{
-    if (m_pBuffer) {
-        return FALSE;
-    }
-    if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
-        return FALSE;
-    }
-    CopyPalette(pSrc->GetPalette());
-    CopyAlphaMask(pSrc->m_pAlphaMask);
-    for (int row = 0; row < pSrc->GetHeight(); row ++) {
-        FXSYS_memcpy32(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
+  }
+  if (isCmykImage) {
+    if (forecolor == 0xff && backcolor == 0x00) {
+      for (int row = 0; row < m_Height; row++) {
+        FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
+        for (int col = 0; col < m_Width; col++) {
+          FX_BYTE b, g, r;
+          AdobeCMYK_to_sRGB1(
+              scanline[0], scanline[1], scanline[2], scanline[3], r, g, b);
+          *scanline++ = 0;
+          *scanline++ = 0;
+          *scanline++ = 0;
+          *scanline++ = 255 - FXRGB2GRAY(r, g, b);
+        }
+      }
+      return TRUE;
+    }
+  } else if (forecolor == 0 && backcolor == 0xffffff) {
+    for (int row = 0; row < m_Height; row++) {
+      FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
+      int gap = m_bpp / 8 - 2;
+      for (int col = 0; col < m_Width; col++) {
+        int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
+        *scanline++ = gray;
+        *scanline++ = gray;
+        *scanline = gray;
+        scanline += gap;
+      }
     }
     return TRUE;
-}
-CFX_DIBitmap::~CFX_DIBitmap()
-{
-    if (m_pBuffer && !m_bExtBuf) {
-        FX_Free(m_pBuffer);
-    }
-    m_pBuffer = NULL;
-}
-void CFX_DIBitmap::TakeOver(CFX_DIBitmap* pSrcBitmap)
-{
-    if (m_pBuffer && !m_bExtBuf) {
-        FX_Free(m_pBuffer);
-    }
-    if (m_pPalette) {
-        FX_Free(m_pPalette);
-    }
-    if (m_pAlphaMask) {
-        delete m_pAlphaMask;
-    }
-    m_pBuffer = pSrcBitmap->m_pBuffer;
-    m_pPalette = pSrcBitmap->m_pPalette;
-    m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
-    pSrcBitmap->m_pBuffer = NULL;
-    pSrcBitmap->m_pPalette = NULL;
-    pSrcBitmap->m_pAlphaMask = NULL;
-    m_bpp = pSrcBitmap->m_bpp;
-    m_bExtBuf = pSrcBitmap->m_bExtBuf;
-    m_AlphaFlag = pSrcBitmap->m_AlphaFlag;
-    m_Width = pSrcBitmap->m_Width;
-    m_Height = pSrcBitmap->m_Height;
-    m_Pitch = pSrcBitmap->m_Pitch;
-}
-CFX_DIBitmap* CFX_DIBSource::Clone(const FX_RECT* pClip) const
-{
-    FX_RECT rect(0, 0, m_Width, m_Height);
-    if (pClip) {
-        rect.Intersect(*pClip);
-        if (rect.IsEmpty()) {
-            return NULL;
-        }
-    }
-    CFX_DIBitmap* pNewBitmap = FX_NEW CFX_DIBitmap;
-    if (!pNewBitmap) {
-        return NULL;
-    }
-    if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) {
-        delete pNewBitmap;
-        return NULL;
-    }
-    pNewBitmap->CopyPalette(m_pPalette);
-    pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
-    if (GetBPP() == 1 && rect.left % 8 != 0) {
-        int left_shift = rect.left % 32;
-        int right_shift = 32 - left_shift;
-        int dword_count = pNewBitmap->m_Pitch / 4;
-        for (int row = rect.top; row < rect.bottom; row ++) {
-            FX_DWORD* src_scan = (FX_DWORD*)GetScanline(row) + rect.left / 32;
-            FX_DWORD* dest_scan = (FX_DWORD*)pNewBitmap->GetScanline(row - rect.top);
-            for (int i = 0; i < dword_count; i ++) {
-                dest_scan[i] = (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
-            }
+  }
+  if (isCmykImage) {
+    for (int row = 0; row < m_Height; row++) {
+      FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
+      for (int col = 0; col < m_Width; col++) {
+        FX_BYTE b, g, r;
+        AdobeCMYK_to_sRGB1(
+            scanline[0], scanline[1], scanline[2], scanline[3], r, g, b);
+        int gray = 255 - FXRGB2GRAY(r, g, b);
+        *scanline++ = bc + (fc - bc) * gray / 255;
+        *scanline++ = bm + (fm - bm) * gray / 255;
+        *scanline++ = by + (fy - by) * gray / 255;
+        *scanline++ = bk + (fk - bk) * gray / 255;
+      }
+    }
+  } else {
+    for (int row = 0; row < m_Height; row++) {
+      FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
+      int gap = m_bpp / 8 - 2;
+      for (int col = 0; col < m_Width; col++) {
+        int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
+        *scanline++ = bb + (fb - bb) * gray / 255;
+        *scanline++ = bg + (fg - bg) * gray / 255;
+        *scanline = br + (fr - br) * gray / 255;
+        scanline += gap;
+      }
+    }
+  }
+  return TRUE;
+}
+FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette,
+                               int pal_size,
+                               const FX_RECT* pRect) {
+  if (m_pBuffer == NULL) {
+    return FALSE;
+  }
+  if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
+    return FALSE;
+  }
+  if (m_Width < 4 && m_Height < 4) {
+    return FALSE;
+  }
+  FX_RECT rect(0, 0, m_Width, m_Height);
+  if (pRect) {
+    rect.Intersect(*pRect);
+  }
+  FX_BYTE translate[256];
+  for (int i = 0; i < 256; i++) {
+    int err2 = 65536;
+    for (int j = 0; j < pal_size; j++) {
+      FX_BYTE entry = (FX_BYTE)pPalette[j];
+      int err = (int)entry - i;
+      if (err * err < err2) {
+        err2 = err * err;
+        translate[i] = entry;
+      }
+    }
+  }
+  for (int row = rect.top; row < rect.bottom; row++) {
+    FX_LPBYTE scan = m_pBuffer + row * m_Pitch;
+    FX_LPBYTE next_scan = m_pBuffer + (row + 1) * m_Pitch;
+    for (int col = rect.left; col < rect.right; col++) {
+      int src_pixel = scan[col];
+      int dest_pixel = translate[src_pixel];
+      scan[col] = (FX_BYTE)dest_pixel;
+      int error = -dest_pixel + src_pixel;
+      if (col < rect.right - 1) {
+        int src = scan[col + 1];
+        src += error * 7 / 16;
+        if (src > 255) {
+          scan[col + 1] = 255;
+        } else if (src < 0) {
+          scan[col + 1] = 0;
+        } else {
+          scan[col + 1] = src;
+        }
+      }
+      if (col < rect.right - 1 && row < rect.bottom - 1) {
+        int src = next_scan[col + 1];
+        src += error * 1 / 16;
+        if (src > 255) {
+          next_scan[col + 1] = 255;
+        } else if (src < 0) {
+          next_scan[col + 1] = 0;
+        } else {
+          next_scan[col + 1] = src;
+        }
+      }
+      if (row < rect.bottom - 1) {
+        int src = next_scan[col];
+        src += error * 5 / 16;
+        if (src > 255) {
+          next_scan[col] = 255;
+        } else if (src < 0) {
+          next_scan[col] = 0;
+        } else {
+          next_scan[col] = src;
+        }
+      }
+      if (col > rect.left && row < rect.bottom - 1) {
+        int src = next_scan[col - 1];
+        src += error * 3 / 16;
+        if (src > 255) {
+          next_scan[col - 1] = 255;
+        } else if (src < 0) {
+          next_scan[col - 1] = 0;
+        } else {
+          next_scan[col - 1] = src;
+        }
+      }
+    }
+  }
+  return TRUE;
+}
+CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const {
+  CFX_DIBitmap* pFlipped = FX_NEW CFX_DIBitmap;
+  if (!pFlipped) {
+    return NULL;
+  }
+  if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
+    delete pFlipped;
+    return NULL;
+  }
+  pFlipped->CopyPalette(m_pPalette);
+  FX_LPBYTE pDestBuffer = pFlipped->GetBuffer();
+  int Bpp = m_bpp / 8;
+  for (int row = 0; row < m_Height; row++) {
+    FX_LPCBYTE src_scan = GetScanline(row);
+    FX_LPBYTE dest_scan =
+        pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
+    if (!bXFlip) {
+      FXSYS_memcpy32(dest_scan, src_scan, m_Pitch);
+      continue;
+    }
+    if (m_bpp == 1) {
+      FXSYS_memset32(dest_scan, 0, m_Pitch);
+      for (int col = 0; col < m_Width; col++)
+        if (src_scan[col / 8] & (1 << (7 - col % 8))) {
+          int dest_col = m_Width - col - 1;
+          dest_scan[dest_col / 8] |= (1 << (7 - dest_col % 8));
         }
     } else {
-        int copy_len = (pNewBitmap->GetWidth() * pNewBitmap->GetBPP() + 7) / 8;
-        if (m_Pitch < (FX_DWORD)copy_len) {
-            copy_len = m_Pitch;
-        }
-        for (int row = rect.top; row < rect.bottom; row ++) {
-            FX_LPCBYTE src_scan = GetScanline(row) + rect.left * m_bpp / 8;
-            FX_LPBYTE dest_scan = (FX_LPBYTE)pNewBitmap->GetScanline(row - rect.top);
-            FXSYS_memcpy32(dest_scan, src_scan, copy_len);
-        }
-    }
-    return pNewBitmap;
-}
-void CFX_DIBSource::BuildPalette()
-{
-    if (m_pPalette) {
-        return;
-    }
-    if (GetBPP() == 1) {
-        m_pPalette = FX_Alloc(FX_DWORD, 2);
-        if (!m_pPalette) {
-            return;
-        }
-        if(IsCmykImage()) {
-            m_pPalette[0] = 0xff;
-            m_pPalette[1] = 0;
-        } else {
-            m_pPalette[0] = 0xff000000;
-            m_pPalette[1] = 0xffffffff;
-        }
-    } else if (GetBPP() == 8) {
-        m_pPalette = FX_Alloc(FX_DWORD, 256);
-        if (!m_pPalette) {
-            return;
-        }
-        if(IsCmykImage()) {
-            for (int i = 0; i < 256; i ++) {
-                m_pPalette[i] = 0xff - i;
-            }
-        } else {
-            for (int i = 0; i < 256; i ++) {
-                m_pPalette[i] = 0xff000000 | (i * 0x10101);
-            }
-        }
-    }
-}
-FX_BOOL CFX_DIBSource::BuildAlphaMask()
-{
-    if (m_pAlphaMask) {
-        return TRUE;
-    }
-    m_pAlphaMask = FX_NEW CFX_DIBitmap;
-    if (!m_pAlphaMask) {
-        return FALSE;
-    }
-    if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
-        delete m_pAlphaMask;
-        m_pAlphaMask = NULL;
-        return FALSE;
-    }
-    FXSYS_memset8(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-    return TRUE;
-}
-FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const
-{
-    ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
-    if (m_pPalette) {
-        return m_pPalette[index];
-    }
-    if (IsCmykImage()) {
-        if (GetBPP() == 1) {
-            return index ? 0 : 0xff;
-        }
-        return 0xff - index;
-    }
-    if (GetBPP() == 1) {
-        return index ? 0xffffffff : 0xff000000;
-    }
-    return index * 0x10101 | 0xff000000;
-}
-void CFX_DIBSource::SetPaletteEntry(int index, FX_DWORD color)
-{
-    ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
-    if (m_pPalette == NULL) {
-        BuildPalette();
-    }
-    m_pPalette[index] = color;
-}
-int CFX_DIBSource::FindPalette(FX_DWORD color) const
-{
-    ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
-    if (m_pPalette == NULL) {
-        if (IsCmykImage()) {
-            if (GetBPP() == 1) {
-                return ((FX_BYTE)color == 0xff) ? 0 : 1;
-            }
-            return 0xff - (FX_BYTE)color;
-        }
-        if (GetBPP() == 1) {
-            return ((FX_BYTE)color == 0xff) ? 1 : 0;
-        }
-        return (FX_BYTE)color;
-    }
-    int palsize = (1 << GetBPP());
-    for (int i = 0; i < palsize; i ++)
-        if (m_pPalette[i] == color) {
-            return i;
-        }
-    return -1;
-}
-void CFX_DIBitmap::Clear(FX_DWORD color)
-{
-    if (m_pBuffer == NULL) {
-        return;
-    }
-    switch (GetFormat()) {
-        case FXDIB_1bppMask:
-            FXSYS_memset8(m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
-            break;
-        case FXDIB_1bppRgb: {
-                int index = FindPalette(color);
-                FXSYS_memset8(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
-                break;
-            }
-        case FXDIB_8bppMask:
-            FXSYS_memset8(m_pBuffer, color >> 24, m_Pitch * m_Height);
-            break;
-        case FXDIB_8bppRgb: {
-                int index = FindPalette(color);
-                FXSYS_memset8(m_pBuffer, index, m_Pitch * m_Height);
-                break;
-            }
-        case FXDIB_Rgb:
-        case FXDIB_Rgba: {
-                int a, r, g, b;
-                ArgbDecode(color, a, r, g, b);
-                if (r == g && g == b) {
-                    FXSYS_memset8(m_pBuffer, r, m_Pitch * m_Height);
-                } else {
-                    int byte_pos = 0;
-                    for (int col = 0; col < m_Width; col ++) {
-                        m_pBuffer[byte_pos++] = b;
-                        m_pBuffer[byte_pos++] = g;
-                        m_pBuffer[byte_pos++] = r;
-                    }
-                    for (int row = 1; row < m_Height; row ++) {
-                        FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
-                    }
-                }
-                break;
-            }
-        case FXDIB_Rgb32:
-        case FXDIB_Argb: {
-                color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-                for (int i = 0; i < m_Width; i ++) {
-                    ((FX_DWORD*)m_pBuffer)[i] = color;
-                }
-                for (int row = 1; row < m_Height; row ++) {
-                    FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
-                }
-                break;
-            }
-        default:
-            break;
-    }
-}
-void CFX_DIBSource::GetOverlapRect(int& dest_left, int& dest_top, int& width, int& height,
-                                   int src_width, int src_height, int& src_left, int& src_top,
-                                   const CFX_ClipRgn* pClipRgn)
-{
-    if (width == 0 || height == 0) {
-        return;
-    }
-    ASSERT(width > 0 && height > 0);
-    if (dest_left > m_Width || dest_top > m_Height) {
-        width = 0;
-        height = 0;
-        return;
-    }
-    int x_offset = dest_left - src_left;
-    int y_offset = dest_top - src_top;
-    FX_RECT src_rect(src_left, src_top, src_left + width, src_top + height);
-    FX_RECT src_bound(0, 0, src_width, src_height);
-    src_rect.Intersect(src_bound);
-    FX_RECT dest_rect(src_rect.left + x_offset, src_rect.top + y_offset,
-                      src_rect.right + x_offset, src_rect.bottom + y_offset);
-    FX_RECT dest_bound(0, 0, m_Width, m_Height);
-    dest_rect.Intersect(dest_bound);
-    if (pClipRgn) {
-        dest_rect.Intersect(pClipRgn->GetBox());
-    }
-    dest_left = dest_rect.left;
-    dest_top = dest_rect.top;
-    src_left = dest_left - x_offset;
-    src_top = dest_top - y_offset;
-    width = dest_rect.right - dest_rect.left;
-    height = dest_rect.bottom - dest_rect.top;
-}
-FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
-                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
-    if (width == 0 || height == 0) {
-        return TRUE;
-    }
-    FXDIB_Format dest_format = GetFormat();
-    FXDIB_Format src_format = pSrcBitmap->GetFormat();
-    if (dest_format == src_format && pIccTransform == NULL) {
-        if (GetBPP() == 1) {
-            for (int row = 0; row < height; row ++) {
-                FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
-                FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
-                for (int col = 0; col < width; col ++) {
-                    if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
-                        dest_scan[(dest_left + col) / 8] |= 1 << (7 - (dest_left + col) % 8);
-                    } else {
-                        dest_scan[(dest_left + col) / 8] &= ~(1 << (7 - (dest_left + col) % 8));
-                    }
-                }
-            }
-        } else {
-            int Bpp = GetBPP() / 8;
-            for (int row = 0; row < height; row ++) {
-                FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
-                FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
-                FXSYS_memcpy32(dest_scan, src_scan, width * Bpp);
-            }
-        }
-    } else {
-        if (m_pPalette) {
-            return FALSE;
-        }
-        if (m_bpp == 8) {
-            dest_format = FXDIB_8bppMask;
-        }
-        FX_LPBYTE dest_buf = m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
-        FX_DWORD* d_plt = NULL;
-        if(!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-#ifndef _FPDFAPI_MINI_
-FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
-                                   const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top, int alpha_flag, void* pIccTransform)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    ASSERT(HasAlpha() && (m_bpp >= 24));
-    ASSERT(pMask->IsAlphaMask());
-    if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
-        return FALSE;
-    }
-    GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, NULL);
-    if (width == 0 || height == 0) {
-        return TRUE;
-    }
-    int src_bpp = pMask->GetBPP();
-    int alpha;
-    FX_DWORD dst_color;
-    if (alpha_flag >> 8) {
-        alpha = alpha_flag & 0xff;
-        dst_color = FXCMYK_TODIB(color);
-    } else {
-        alpha = FXARGB_A(color);
-        dst_color = FXARGB_TODIB(color);
-    }
-    FX_LPBYTE color_p = (FX_LPBYTE)&dst_color;
-    if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() && CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-        ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-        pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
-    } else {
-        if (alpha_flag >> 8 && !IsCmykImage())
-            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
-                               color_p[2], color_p[1], color_p[0]);
-        else if (!(alpha_flag >> 8) && IsCmykImage()) {
-            return FALSE;
-        }
-    }
-    if(!IsCmykImage()) {
-        color_p[3] = (FX_BYTE)alpha;
-    }
-    if (GetFormat() == FXDIB_Argb) {
-        for (int row = 0; row < height; row ++) {
-            FX_DWORD* dest_pos = (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
-            FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
-            if (src_bpp == 1) {
-                for (int col = 0; col < width; col ++) {
-                    int src_bitpos = src_left + col;
-                    if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
-                        *dest_pos = dst_color;
-                    } else {
-                        *dest_pos = 0;
-                    }
-                    dest_pos ++;
-                }
-            } else {
-                src_scan += src_left;
-                dst_color = FXARGB_TODIB(dst_color);
-                dst_color &= 0xffffff;
-                for (int col = 0; col < width; col ++) {
-                    FXARGB_SETDIB(dest_pos++, dst_color | ((alpha * (*src_scan++) / 255) << 24));
-                }
-            }
-        }
-    } else {
-        int comps = m_bpp / 8;
-        for (int row = 0; row < height; row ++) {
-            FX_LPBYTE dest_color_pos = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * comps;
-            FX_LPBYTE dest_alpha_pos = (FX_LPBYTE)m_pAlphaMask->GetScanline(dest_top + row) + dest_left;
-            FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
-            if (src_bpp == 1) {
-                for (int col = 0; col < width; col ++) {
-                    int src_bitpos = src_left + col;
-                    if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
-                        FXSYS_memcpy32(dest_color_pos, color_p, comps);
-                        *dest_alpha_pos = 0xff;
-                    } else {
-                        FXSYS_memset32(dest_color_pos, 0, comps);
-                        *dest_alpha_pos = 0;
-                    }
-                    dest_color_pos += comps;
-                    dest_alpha_pos ++;
-                }
-            } else {
-                src_scan += src_left;
-                for (int col = 0; col < width; col ++) {
-                    FXSYS_memcpy32(dest_color_pos, color_p, comps);
-                    dest_color_pos += comps;
-                    *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
-                }
-            }
-        }
-    }
-    return TRUE;
-}
-#endif
-void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size)
-{
-    if (pSrc == NULL || GetBPP() > 8) {
-        if (m_pPalette) {
-            FX_Free(m_pPalette);
-        }
-        m_pPalette = NULL;
-    } else {
-        FX_DWORD pal_size = 1 << GetBPP();
-        if (m_pPalette == NULL) {
-            m_pPalette = FX_Alloc(FX_DWORD, pal_size);
-        }
-        if (!m_pPalette) {
-            return;
-        }
-        if (pal_size > size) {
-            pal_size = size;
-        }
-        FXSYS_memcpy32(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
-    }
-}
-void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const
-{
-    ASSERT(GetBPP() <= 8 && !IsCmykImage());
-    if (GetBPP() == 1) {
-        pal[0] = ((m_pPalette ? m_pPalette[0] : 0xff000000) & 0xffffff) | (alpha << 24);
-        pal[1] = ((m_pPalette ? m_pPalette[1] : 0xffffffff) & 0xffffff) | (alpha << 24);
-        return;
-    }
-    if (m_pPalette) {
-        for (int i = 0; i < 256; i ++) {
-            pal[i] = (m_pPalette[i] & 0x00ffffff) | (alpha << 24);
-        }
-    } else {
-        for (int i = 0; i < 256; i ++) {
-            pal[i] = (i * 0x10101) | (alpha << 24);
-        }
-    }
-}
-CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const
-{
-    ASSERT(GetFormat() == FXDIB_Argb);
-    FX_RECT rect(0, 0, m_Width, m_Height);
-    if (pClip) {
-        rect.Intersect(*pClip);
-        if (rect.IsEmpty()) {
-            return NULL;
-        }
-    }
-    CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
-    if (!pMask) {
-        return NULL;
-    }
-    if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
-        delete pMask;
-        return NULL;
-    }
-    for (int row = rect.top; row < rect.bottom; row ++) {
-        FX_LPCBYTE src_scan = GetScanline(row) + rect.left * 4 + 3;
-        FX_LPBYTE dest_scan = (FX_LPBYTE)pMask->GetScanline(row - rect.top);
-        for (int col = rect.left; col < rect.right; col ++) {
-            *dest_scan ++ = *src_scan;
-            src_scan += 4;
-        }
-    }
-    return pMask;
-}
-FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
-{
-    if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
-        return FALSE;
-    }
-    if (pAlphaMask) {
-        FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
-        if (pClip) {
-            rect.Intersect(*pClip);
-            if (rect.IsEmpty() || rect.Width() != m_Width || rect.Height() != m_Height) {
-                return FALSE;
-            }
-        } else {
-            if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
-                return FALSE;
-            }
-        }
-        for (int row = 0; row < m_Height; row ++)
-            FXSYS_memcpy32((void*)m_pAlphaMask->GetScanline(row),
-                           pAlphaMask->GetScanline(row + rect.top) + rect.left, m_pAlphaMask->m_Pitch);
-    } else {
-        m_pAlphaMask->Clear(0xff000000);
-    }
-    return TRUE;
-}
-const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
-    CFX_DIBitmap* pDst = this;
-    int destOffset, srcOffset;
-    if (srcChannel == FXDIB_Alpha) {
-        if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
-        }
-        if (pSrcBitmap->GetBPP() == 1) {
-            pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
-            if (pSrcClone == NULL) {
-                return FALSE;
-            }
-        }
-        if(pSrcBitmap->GetFormat() == FXDIB_Argb) {
-            srcOffset = 3;
-        } else {
-            srcOffset = 0;
-        }
-    } else {
-        if (pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
-        }
-        if (pSrcBitmap->GetBPP() < 24) {
-            if (pSrcBitmap->IsCmykImage()) {
-                pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
-            } else {
-                pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
-            }
-            if (pSrcClone == NULL) {
-                return FALSE;
-            }
-        }
-        srcOffset = g_ChannelOffset[srcChannel];
-    }
-    if (destChannel == FXDIB_Alpha) {
-        if (IsAlphaMask()) {
-            if(!ConvertFormat(FXDIB_8bppMask)) {
-                if (pSrcClone != pSrcBitmap) {
-                    delete pSrcClone;
-                }
-                return FALSE;
-            }
-            destOffset = 0;
-        } else {
-            destOffset = 0;
-            if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                if (pSrcClone != pSrcBitmap) {
-                    delete pSrcClone;
-                }
-                return FALSE;
-            }
-            if (GetFormat() == FXDIB_Argb) {
-                destOffset = 3;
-            }
-        }
-    } else {
-        if (IsAlphaMask()) {
-            if (pSrcClone != pSrcBitmap) {
-                delete pSrcClone;
-            }
-            return FALSE;
-        }
-        if (GetBPP() < 24) {
-            if (HasAlpha()) {
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                    if (pSrcClone != pSrcBitmap) {
-                        delete pSrcClone;
-                    }
-                    return FALSE;
-                }
-            } else
-#if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-#else
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-#endif
-                    if (pSrcClone != pSrcBitmap) {
-                        delete pSrcClone;
-                    }
-                    return FALSE;
-                }
-        }
-        destOffset = g_ChannelOffset[destChannel];
-    }
-    if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
-        CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
-        if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
-            if (pAlphaMask) {
-                pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
-                if (pAlphaMask == NULL) {
-                    if (pSrcClone != pSrcBitmap) {
-                        delete pSrcClone;
-                    }
-                    return FALSE;
-                }
-            }
-        }
-        if (pSrcClone != pSrcBitmap) {
-            pSrcClone->m_pAlphaMask = NULL;
-            delete pSrcClone;
-        }
-        pSrcClone = pAlphaMask;
-        srcOffset = 0;
-    } else if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
-        CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
-        if (pSrcClone != pSrcBitmap) {
-            delete pSrcClone;
-        }
-        if (pSrcMatched == NULL) {
-            return FALSE;
-        }
-        pSrcClone = pSrcMatched;
-    }
-    if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
-        pDst = m_pAlphaMask;
-        destOffset = 0;
-    }
-    int srcBytes = pSrcClone->GetBPP() / 8;
-    int destBytes = pDst->GetBPP() / 8;
-    for (int row = 0; row < m_Height; row ++) {
-        FX_LPBYTE dest_pos = (FX_LPBYTE)pDst->GetScanline(row) + destOffset;
-        FX_LPCBYTE src_pos = pSrcClone->GetScanline(row) + srcOffset;
-        for (int col = 0; col < m_Width; col ++) {
-            *dest_pos = *src_pos;
-            dest_pos += destBytes;
-            src_pos += srcBytes;
-        }
-    }
-    if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
-        delete pSrcClone;
-    }
-    return TRUE;
-}
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    int destOffset;
-    if (destChannel == FXDIB_Alpha) {
-        if (IsAlphaMask()) {
-            if(!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
-            }
-            destOffset = 0;
-        } else {
-            destOffset = 0;
-            if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                return FALSE;
-            }
-            if (GetFormat() == FXDIB_Argb) {
-                destOffset = 3;
-            }
-        }
-    } else {
-        if (IsAlphaMask()) {
-            return FALSE;
-        }
-        if (GetBPP() < 24) {
-            if (HasAlpha()) {
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                    return FALSE;
-                }
-            } else
-#if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-                    return FALSE;
-                }
-#else
-                if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-                    return FALSE;
-                }
-#endif
-        }
-        destOffset = g_ChannelOffset[destChannel];
-    }
-    int Bpp = GetBPP() / 8;
-    if (Bpp == 1) {
-        FXSYS_memset8(m_pBuffer, value, m_Height * m_Pitch);
-        return TRUE;
-    }
-    if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
-        FXSYS_memset8(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-        return TRUE;
-    }
-    for (int row = 0; row < m_Height; row ++) {
-        FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + destOffset;
-        for (int col = 0; col < m_Width; col ++) {
-            *scan_line = value;
-            scan_line += Bpp;
-        }
-    }
-    return TRUE;
-}
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    ASSERT(pSrcBitmap->IsAlphaMask());
-    if (!pSrcBitmap->IsAlphaMask()) {
-        return FALSE;
-    }
-    if (!IsAlphaMask() && !HasAlpha()) {
-        return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
-    }
-    CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
-    if (pSrcBitmap->GetWidth() != m_Width || pSrcBitmap->GetHeight() != m_Height) {
-        pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
-        ASSERT(pSrcClone != NULL);
-        if (pSrcClone == NULL) {
-            return FALSE;
-        }
-    }
-    if (IsAlphaMask()) {
-        if(!ConvertFormat(FXDIB_8bppMask)) {
-            if (pSrcClone != pSrcBitmap) {
-                delete pSrcClone;
-            }
-            return FALSE;
-        }
-        for (int row = 0; row < m_Height; row ++) {
-            FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row;
-            FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
-            if (pSrcClone->GetBPP() == 1) {
-                for (int col = 0; col < m_Width; col ++) {
-                    if (!((1 << (7 - col % 8)) & src_scan[col / 8])) {
-                        dest_scan[col] = 0;
-                    }
-                }
-            } else {
-                for (int col = 0; col < m_Width; col ++) {
-                    *dest_scan = (*dest_scan) * src_scan[col] / 255;
-                    dest_scan ++;
-                }
-            }
-        }
-    } else {
-        if(GetFormat() == FXDIB_Argb) {
-            if (pSrcClone->GetBPP() == 1) {
-                if (pSrcClone != pSrcBitmap) {
-                    delete pSrcClone;
-                }
-                return FALSE;
-            }
-            for (int row = 0; row < m_Height; row ++) {
-                FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row + 3;
-                FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
-                for (int col = 0; col < m_Width; col ++) {
-                    *dest_scan = (*dest_scan) * src_scan[col] / 255;
-                    dest_scan += 4;
-                }
-            }
-        } else {
-            m_pAlphaMask->MultiplyAlpha(pSrcClone);
-        }
-    }
-    if (pSrcClone != pSrcBitmap) {
-        delete pSrcClone;
-    }
-    return TRUE;
-}
-FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    switch (GetFormat()) {
-        case FXDIB_1bppRgb: {
-                if (m_pPalette == NULL) {
-                    return FALSE;
-                }
-                FX_BYTE gray[2];
-                for (int i = 0; i < 2; i ++) {
-                    int r = (FX_BYTE)(m_pPalette[i] >> 16);
-                    int g = (FX_BYTE)(m_pPalette[i] >> 8);
-                    int b = (FX_BYTE)m_pPalette[i];
-                    gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
-                }
-                CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
-                if (!pMask) {
-                    return FALSE;
-                }
-                if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
-                    delete pMask;
-                    return FALSE;
-                }
-                FXSYS_memset8(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
-                    FX_LPBYTE dest_pos = (FX_LPBYTE)pMask->GetScanline(row);
-                    for (int col = 0; col < m_Width; col ++) {
-                        if (src_pos[col / 8] & (1 << (7 - col % 8))) {
-                            *dest_pos = gray[1];
-                        }
-                        dest_pos ++;
-                    }
-                }
-                TakeOver(pMask);
-                delete pMask;
-                break;
-            }
-        case FXDIB_8bppRgb: {
-                if (m_pPalette == NULL) {
-                    return FALSE;
-                }
-                FX_BYTE gray[256];
-                for (int i = 0; i < 256; i ++) {
-                    int r = (FX_BYTE)(m_pPalette[i] >> 16);
-                    int g = (FX_BYTE)(m_pPalette[i] >> 8);
-                    int b = (FX_BYTE)m_pPalette[i];
-                    gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
-                }
-                CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
-                if (!pMask) {
-                    return FALSE;
-                }
-                if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
-                    delete pMask;
-                    return FALSE;
-                }
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
-                    FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
-                    for (int col = 0; col < m_Width; col ++) {
-                        *dest_pos ++ = gray[*src_pos ++];
-                    }
-                }
-                TakeOver(pMask);
-                delete pMask;
-                break;
-            }
-        case FXDIB_Rgb: {
-                CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
-                if (!pMask) {
-                    return FALSE;
-                }
-                if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
-                    delete pMask;
-                    return FALSE;
-                }
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
-                    FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
-                    for (int col = 0; col < m_Width; col ++) {
-                        *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
-                        src_pos += 3;
-                    }
-                }
-                TakeOver(pMask);
-                delete pMask;
-                break;
-            }
-        case FXDIB_Rgb32: {
-                CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
-                if (!pMask) {
-                    return FALSE;
-                }
-                if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
-                    delete pMask;
-                    return FALSE;
-                }
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
-                    FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
-                    for (int col = 0; col < m_Width; col ++) {
-                        *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
-                        src_pos += 4;
-                    }
-                }
-                TakeOver(pMask);
-                delete pMask;
-                break;
-            }
-        default:
-            return FALSE;
-    }
-    return TRUE;
-}
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    switch (GetFormat()) {
-        case FXDIB_1bppMask:
-            if (!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
-            }
-            MultiplyAlpha(alpha);
-            break;
-        case FXDIB_8bppMask: {
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch;
-                    for (int col = 0; col < m_Width; col ++) {
-                        scan_line[col] = scan_line[col] * alpha / 255;
-                    }
-                }
-                break;
-            }
-        case FXDIB_Argb: {
-                for (int row = 0; row < m_Height; row ++) {
-                    FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + 3;
-                    for (int col = 0; col < m_Width; col ++) {
-                        *scan_line = (*scan_line) * alpha / 255;
-                        scan_line += 4;
-                    }
-                }
-                break;
-            }
-        default:
-            if (HasAlpha()) {
-                m_pAlphaMask->MultiplyAlpha(alpha);
-            } else if (IsCmykImage()) {
-                if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
-                    return FALSE;
-                }
-                m_pAlphaMask->MultiplyAlpha(alpha);
-            } else {
-                if (!ConvertFormat(FXDIB_Argb)) {
-                    return FALSE;
-                }
-                MultiplyAlpha(alpha);
-            }
-            break;
-    }
-    return TRUE;
-}
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
-FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const
-{
-    if (m_pBuffer == NULL) {
-        return 0;
-    }
-    FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
-    switch (GetFormat()) {
-        case FXDIB_1bppMask: {
-                if ((*pos) & (1 << (7 - x % 8))) {
-                    return 0xff000000;
-                }
-                return 0;
-            }
-        case FXDIB_1bppRgb: {
-                if ((*pos) & (1 << (7 - x % 8))) {
-                    return m_pPalette ? m_pPalette[1] : 0xffffffff;
-                } else {
-                    return m_pPalette ? m_pPalette[0] : 0xff000000;
-                }
-                break;
-            }
-        case FXDIB_8bppMask:
-            return (*pos) << 24;
-        case FXDIB_8bppRgb:
-            return m_pPalette ? m_pPalette[*pos] : (0xff000000 | ((*pos) * 0x10101));
-        case FXDIB_Rgb:
-        case FXDIB_Rgba:
-        case FXDIB_Rgb32:
-            return FXARGB_GETDIB(pos) | 0xff000000;
-        case FXDIB_Argb:
-            return FXARGB_GETDIB(pos);
-        default:
-            break;
-    }
-    return 0;
-}
-#endif
-void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color)
-{
-    if (m_pBuffer == NULL) {
-        return;
-    }
-    if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
-        return;
-    }
-    FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
-    switch (GetFormat()) {
-        case FXDIB_1bppMask:
-            if (color >> 24) {
-                *pos |= 1 << (7 - x % 8);
-            } else {
-                *pos &= ~(1 << (7 - x % 8));
-            }
-            break;
-        case FXDIB_1bppRgb:
-            if (m_pPalette) {
-                if (color == m_pPalette[1]) {
-                    *pos |= 1 << (7 - x % 8);
-                } else {
-                    *pos &= ~(1 << (7 - x % 8));
-                }
-            } else {
-                if (color == 0xffffffff) {
-                    *pos |= 1 << (7 - x % 8);
-                } else {
-                    *pos &= ~(1 << (7 - x % 8));
-                }
-            }
-            break;
-        case FXDIB_8bppMask:
-            *pos = (FX_BYTE)(color >> 24);
-            break;
-        case FXDIB_8bppRgb: {
-                if (m_pPalette) {
-                    for (int i = 0; i < 256; i ++) {
-                        if (m_pPalette[i] == color) {
-                            *pos = (FX_BYTE)i;
-                            return;
-                        }
-                    }
-                    *pos = 0;
-                } else {
-                    *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
-                }
-                break;
-            }
-        case FXDIB_Rgb:
-        case FXDIB_Rgb32: {
-                int alpha = FXARGB_A(color);
-                pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
-                pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
-                pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
-                break;
-            }
-        case FXDIB_Rgba: {
-                pos[0] = FXARGB_B(color);
-                pos[1] = FXARGB_G(color);
-                pos[2] = FXARGB_R(color);
-                break;
-            }
-        case FXDIB_Argb:
-            FXARGB_SETDIB(pos, color);
-            break;
-        default:
-            break;
-    }
-}
-void CFX_DIBitmap::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
-                                      int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
-{
-    if (m_pBuffer == NULL) {
-        return;
-    }
-    int src_Bpp = m_bpp / 8;
-    FX_LPBYTE scanline = m_pBuffer + line * m_Pitch;
-    if (src_Bpp == 0) {
-        for (int i = 0; i < clip_width; i ++) {
-            FX_DWORD dest_x = clip_left + i;
-            FX_DWORD src_x = dest_x * m_Width / dest_width;
-            if (bFlipX) {
-                src_x = m_Width - src_x - 1;
-            }
-#ifdef FOXIT_CHROME_BUILD
-            src_x %= m_Width;
-#endif
-            dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
-        }
-    } else if (src_Bpp == 1) {
-        for (int i = 0; i < clip_width; i ++) {
-            FX_DWORD dest_x = clip_left + i;
-            FX_DWORD src_x = dest_x * m_Width / dest_width;
-            if (bFlipX) {
-                src_x = m_Width - src_x - 1;
-            }
-#ifdef FOXIT_CHROME_BUILD
-            src_x %= m_Width;
-#endif
-            int dest_pos = i;
-            if (m_pPalette) {
-                if (!IsCmykImage()) {
-                    dest_pos *= 3;
-                    FX_ARGB argb = m_pPalette[scanline[src_x]];
-                    dest_scan[dest_pos] = FXARGB_B(argb);
-                    dest_scan[dest_pos + 1] = FXARGB_G(argb);
-                    dest_scan[dest_pos + 2] = FXARGB_R(argb);
-                } else {
-                    dest_pos *= 4;
-                    FX_CMYK cmyk = m_pPalette[scanline[src_x]];
-                    dest_scan[dest_pos] = FXSYS_GetCValue(cmyk);
-                    dest_scan[dest_pos + 1] = FXSYS_GetMValue(cmyk);
-                    dest_scan[dest_pos + 2] = FXSYS_GetYValue(cmyk);
-                    dest_scan[dest_pos + 3] = FXSYS_GetKValue(cmyk);
-                }
-            } else {
-                dest_scan[dest_pos] = scanline[src_x];
-            }
-        }
-    } else {
-        for (int i = 0; i < clip_width; i ++) {
-            FX_DWORD dest_x = clip_left + i;
-            FX_DWORD src_x = bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp : (dest_x * m_Width / dest_width) * src_Bpp;
-#ifdef FOXIT_CHROME_BUILD
-            src_x %= m_Width * src_Bpp;
-#endif
-            int dest_pos = i * src_Bpp;
-            for (int b = 0; b < src_Bpp; b ++) {
-                dest_scan[dest_pos + b] = scanline[src_x + b];
-            }
-        }
-    }
-}
-FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
-{
-    ASSERT(!IsAlphaMask());
-    if (m_pBuffer == NULL || IsAlphaMask()) {
-        return FALSE;
-    }
-    int fc, fm, fy, fk, bc, bm, by, bk;
-    int fr, fg, fb, br, bg, bb;
-    FX_BOOL isCmykImage = IsCmykImage();
-    if (isCmykImage) {
-        fc = FXSYS_GetCValue(forecolor);
-        fm = FXSYS_GetMValue(forecolor);
-        fy = FXSYS_GetYValue(forecolor);
-        fk = FXSYS_GetKValue(forecolor);
-        bc = FXSYS_GetCValue(backcolor);
-        bm = FXSYS_GetMValue(backcolor);
-        by = FXSYS_GetYValue(backcolor);
-        bk = FXSYS_GetKValue(backcolor);
-    } else {
-        fr = FXSYS_GetRValue(forecolor);
-        fg = FXSYS_GetGValue(forecolor);
-        fb = FXSYS_GetBValue(forecolor);
-        br = FXSYS_GetRValue(backcolor);
-        bg = FXSYS_GetGValue(backcolor);
-        bb = FXSYS_GetBValue(backcolor);
-    }
-    if (m_bpp <= 8) {
-        if (isCmykImage) {
-            if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
-                return TRUE;
-            }
-        } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
-            return TRUE;
-        }
-        if (m_pPalette == NULL) {
-            BuildPalette();
-        }
-        int size = 1 << m_bpp;
-        if (isCmykImage) {
-            for (int i = 0; i < size; i ++) {
-                FX_BYTE b, g, r;
-                AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]), FXSYS_GetMValue(m_pPalette[i]), FXSYS_GetYValue(m_pPalette[i]), FXSYS_GetKValue(m_pPalette[i]),
-                                   r, g, b);
-                int gray = 255 - FXRGB2GRAY(r, g, b);
-                m_pPalette[i] = CmykEncode(bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
-                                           by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
-            }
-        } else
-            for (int i = 0; i < size; i ++) {
-                int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]), FXARGB_G(m_pPalette[i]), FXARGB_B(m_pPalette[i]));
-                m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255, bg + (fg - bg) * gray / 255,
-                                            bb + (fb - bb) * gray / 255);
-            }
-        return TRUE;
-    }
-    if (isCmykImage) {
-        if (forecolor == 0xff && backcolor == 0x00) {
-            for (int row = 0; row < m_Height; row ++) {
-                FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
-                for (int col = 0; col < m_Width; col ++) {
-                    FX_BYTE b, g, r;
-                    AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
-                                       r, g, b);
-                    *scanline ++ = 0;
-                    *scanline ++ = 0;
-                    *scanline ++ = 0;
-                    *scanline ++ = 255 - FXRGB2GRAY(r, g, b);
-                }
-            }
-            return TRUE;
-        }
-    } else if (forecolor == 0 && backcolor == 0xffffff) {
-        for (int row = 0; row < m_Height; row ++) {
-            FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
-            int gap = m_bpp / 8 - 2;
-            for (int col = 0; col < m_Width; col ++) {
-                int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
-                *scanline ++ = gray;
-                *scanline ++ = gray;
-                *scanline    = gray;
-                scanline += gap;
-            }
-        }
-        return TRUE;
-    }
-    if (isCmykImage) {
-        for (int row = 0; row < m_Height; row ++) {
-            FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
-            for (int col = 0; col < m_Width; col ++) {
-                FX_BYTE b, g, r;
-                AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
-                                   r, g, b);
-                int gray = 255 - FXRGB2GRAY(r, g, b);
-                *scanline ++ = bc + (fc - bc) * gray / 255;
-                *scanline ++ = bm + (fm - bm) * gray / 255;
-                *scanline ++ = by + (fy - by) * gray / 255;
-                *scanline ++ = bk + (fk - bk) * gray / 255;
-            }
-        }
-    } else {
-        for (int row = 0; row < m_Height; row ++) {
-            FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
-            int gap = m_bpp / 8 - 2;
-            for (int col = 0; col < m_Width; col ++) {
-                int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
-                *scanline ++ = bb + (fb - bb) * gray / 255;
-                *scanline ++ = bg + (fg - bg) * gray / 255;
-                *scanline    = br + (fr - br) * gray / 255;
-                scanline += gap;
-            }
-        }
-    }
-    return TRUE;
-}
-FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
-{
-    if (m_pBuffer == NULL) {
-        return FALSE;
-    }
-    if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
-        return FALSE;
-    }
-    if (m_Width < 4 && m_Height < 4) {
-        return FALSE;
-    }
-    FX_RECT rect(0, 0, m_Width, m_Height);
-    if (pRect) {
-        rect.Intersect(*pRect);
-    }
-    FX_BYTE translate[256];
-    for (int i = 0; i < 256; i ++) {
-        int err2 = 65536;
-        for (int j = 0; j < pal_size; j ++) {
-            FX_BYTE entry = (FX_BYTE)pPalette[j];
-            int err = (int)entry - i;
-            if (err * err < err2) {
-                err2 = err * err;
-                translate[i] = entry;
-            }
-        }
-    }
-    for (int row = rect.top; row < rect.bottom; row ++) {
-        FX_LPBYTE scan = m_pBuffer + row * m_Pitch;
-        FX_LPBYTE next_scan = m_pBuffer + (row + 1) * m_Pitch;
-        for (int col = rect.left; col < rect.right; col ++) {
-            int src_pixel = scan[col];
-            int dest_pixel = translate[src_pixel];
-            scan[col] = (FX_BYTE)dest_pixel;
-            int error = -dest_pixel + src_pixel;
-            if (col < rect.right - 1) {
-                int src = scan[col + 1];
-                src += error * 7 / 16;
-                if (src > 255) {
-                    scan[col + 1] = 255;
-                } else if (src < 0) {
-                    scan[col + 1] = 0;
-                } else {
-                    scan[col + 1] = src;
-                }
-            }
-            if (col < rect.right - 1 && row < rect.bottom - 1) {
-                int src = next_scan[col + 1];
-                src += error * 1 / 16;
-                if (src > 255) {
-                    next_scan[col + 1] = 255;
-                } else if (src < 0) {
-                    next_scan[col + 1] = 0;
-                } else {
-                    next_scan[col + 1] = src;
-                }
-            }
-            if (row < rect.bottom - 1) {
-                int src = next_scan[col];
-                src += error * 5 / 16;
-                if (src > 255) {
-                    next_scan[col] = 255;
-                } else if (src < 0) {
-                    next_scan[col] = 0;
-                } else {
-                    next_scan[col] = src;
-                }
-            }
-            if (col > rect.left && row < rect.bottom - 1) {
-                int src = next_scan[col - 1];
-                src += error * 3 / 16;
-                if (src > 255) {
-                    next_scan[col - 1] = 255;
-                } else if (src < 0) {
-                    next_scan[col - 1] = 0;
-                } else {
-                    next_scan[col - 1] = src;
-                }
-            }
-        }
-    }
-    return TRUE;
-}
-CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const
-{
-    CFX_DIBitmap* pFlipped = FX_NEW CFX_DIBitmap;
-    if (!pFlipped) {
-        return NULL;
-    }
-    if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
-        delete pFlipped;
-        return NULL;
-    }
-    pFlipped->CopyPalette(m_pPalette);
-    FX_LPBYTE pDestBuffer = pFlipped->GetBuffer();
-    int Bpp = m_bpp / 8;
-    for (int row = 0; row < m_Height; row ++) {
-        FX_LPCBYTE src_scan = GetScanline(row);
-        FX_LPBYTE dest_scan = pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
-        if (!bXFlip) {
-            FXSYS_memcpy32(dest_scan, src_scan, m_Pitch);
-            continue;
-        }
-        if (m_bpp == 1) {
-            FXSYS_memset32(dest_scan, 0, m_Pitch);
-            for (int col = 0; col < m_Width; col ++)
-                if (src_scan[col / 8] & (1 << (7 - col % 8))) {
-                    int dest_col = m_Width - col - 1;
-                    dest_scan[dest_col / 8] |= (1 << (7 - dest_col % 8));
-                }
-        } else {
-            dest_scan += (m_Width - 1) * Bpp;
-            if (Bpp == 1) {
-                for (int col = 0; col < m_Width; col ++) {
-                    *dest_scan = *src_scan;
-                    dest_scan --;
-                    src_scan ++;
-                }
-            } else if (Bpp == 3) {
-                for (int col = 0; col < m_Width; col ++) {
-                    dest_scan[0] = src_scan[0];
-                    dest_scan[1] = src_scan[1];
-                    dest_scan[2] = src_scan[2];
-                    dest_scan -= 3;
-                    src_scan += 3;
-                }
-            } else {
-                ASSERT(Bpp == 4);
-                for (int col = 0; col < m_Width; col ++) {
-                    *(FX_DWORD*)dest_scan = *(FX_DWORD*)src_scan;
-                    dest_scan -= 4;
-                    src_scan += 4;
-                }
-            }
-        }
-    }
-    if (m_pAlphaMask) {
-        pDestBuffer = pFlipped->m_pAlphaMask->GetBuffer();
-        FX_DWORD dest_pitch = pFlipped->m_pAlphaMask->GetPitch();
-        for (int row = 0; row < m_Height; row ++) {
-            FX_LPCBYTE src_scan = m_pAlphaMask->GetScanline(row);
-            FX_LPBYTE dest_scan = pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row);
-            if (!bXFlip) {
-                FXSYS_memcpy32(dest_scan, src_scan, dest_pitch);
-                continue;
-            }
-            dest_scan += (m_Width - 1);
-            for (int col = 0; col < m_Width; col ++) {
-                *dest_scan = *src_scan;
-                dest_scan --;
-                src_scan ++;
-            }
-        }
-    }
-    return pFlipped;
-}
-CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc)
-{
-    m_pBitmap = NULL;
-    if (pSrc->GetBuffer() == NULL) {
-        m_pBitmap = pSrc->Clone();
-    } else {
-        m_pBitmap = FX_NEW CFX_DIBitmap;
-        if (!m_pBitmap) {
-            return;
-        }
-        if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat(), pSrc->GetBuffer())) {
-            delete m_pBitmap;
-            m_pBitmap = NULL;
-            return;
-        }
-        m_pBitmap->CopyPalette(pSrc->GetPalette());
-        m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
-    }
-}
-CFX_DIBExtractor::~CFX_DIBExtractor()
-{
-    if (m_pBitmap) {
-        delete m_pBitmap;
-    }
-}
-CFX_FilteredDIB::CFX_FilteredDIB()
-{
-    m_pScanline = NULL;
-    m_pSrc = NULL;
-}
-CFX_FilteredDIB::~CFX_FilteredDIB()
-{
-    if (m_pSrc && m_bAutoDropSrc) {
-        delete m_pSrc;
-    }
-    if (m_pScanline) {
-        FX_Free(m_pScanline);
-    }
-}
-void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
-{
-    m_pSrc = pSrc;
-    m_bAutoDropSrc = bAutoDropSrc;
-    m_Width = pSrc->GetWidth();
-    m_Height = pSrc->GetHeight();
-    FXDIB_Format format = GetDestFormat();
-    m_bpp = (FX_BYTE)format;
-    m_AlphaFlag = (FX_BYTE)(format >> 8);
-    m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
-    m_pPalette = GetDestPalette();
-    m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
-}
-FX_LPCBYTE CFX_FilteredDIB::GetScanline(int line) const
-{
-    TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
-    return m_pScanline;
-}
-void CFX_FilteredDIB::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
-        int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
-{
-    m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
-    TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
-}
-CFX_ImageRenderer::CFX_ImageRenderer()
-{
-    m_Status = 0;
-    m_pTransformer = NULL;
-    m_bRgbByteOrder = FALSE;
-    m_BlendType = FXDIB_BLEND_NORMAL;
-}
-CFX_ImageRenderer::~CFX_ImageRenderer()
-{
-    if (m_pTransformer) {
-        delete m_pTransformer;
-    }
-}
-extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY);
-FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
-                                 const CFX_DIBSource* pSource, int bitmap_alpha,
-                                 FX_DWORD mask_color, const CFX_AffineMatrix* pMatrix,
-                                 FX_DWORD dib_flags, FX_BOOL bRgbByteOrder,
-                                 int alpha_flag, void* pIccTransform, int blend_type)
-{
-    m_Matrix = *pMatrix;
-    CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
-    FX_RECT image_rect = image_rect_f.GetOutterRect();
-    m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(), pDevice->GetHeight());
-    m_ClipBox.Intersect(image_rect);
-    if (m_ClipBox.IsEmpty()) {
-        return FALSE;
-    }
-    m_pDevice = pDevice;
-    m_pClipRgn = pClipRgn;
-    m_MaskColor = mask_color;
-    m_BitmapAlpha = bitmap_alpha;
-    m_Matrix = *pMatrix;
-    m_Flags = dib_flags;
-    m_AlphaFlag = alpha_flag;
-    m_pIccTransform = pIccTransform;
-    m_bRgbByteOrder = bRgbByteOrder;
-    m_BlendType = blend_type;
-    FX_BOOL ret = TRUE;
-    if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
-            (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0) ) {
-        if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 && FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
-                FXSYS_fabs(m_Matrix.a) < 0.5f && FXSYS_fabs(m_Matrix.d) < 0.5f) {
-            int dest_width = image_rect.Width();
-            int dest_height = image_rect.Height();
-            FX_RECT bitmap_clip = m_ClipBox;
-            bitmap_clip.Offset(-image_rect.left, -image_rect.top);
-            bitmap_clip = _FXDIB_SwapClipBox(bitmap_clip, dest_width, dest_height, m_Matrix.c > 0, m_Matrix.b < 0);
-            m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, TRUE,
-                               m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
-            if (!m_Stretcher.Start(&m_Composer, pSource, dest_height, dest_width, bitmap_clip, dib_flags)) {
-                return FALSE;
-            }
-            m_Status = 1;
-            return TRUE;
-        }
-        m_Status = 2;
-        m_pTransformer = FX_NEW CFX_ImageTransformer;
-        if (!m_pTransformer) {
-            return FALSE;
-        }
-        m_pTransformer->Start(pSource, &m_Matrix, dib_flags, &m_ClipBox);
-        return TRUE;
-    }
-    int dest_width = image_rect.Width();
-    if (m_Matrix.a < 0) {
-        dest_width = -dest_width;
-    }
-    int dest_height = image_rect.Height();
-    if (m_Matrix.d > 0) {
-        dest_height = -dest_height;
-    }
-    if (dest_width == 0 || dest_height == 0) {
-        return FALSE;
-    }
-    FX_RECT bitmap_clip = m_ClipBox;
-    bitmap_clip.Offset(-image_rect.left, -image_rect.top);
-    m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color,
-                       m_ClipBox, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
-    m_Status = 1;
-    ret = m_Stretcher.Start(&m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
-    return ret;
-}
-FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause)
-{
-    if (m_Status == 1) {
-        return m_Stretcher.Continue(pPause);
-    } else if (m_Status == 2) {
-        if (m_pTransformer->Continue(pPause)) {
-            return TRUE;
-        }
-        CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
-        if (pBitmap == NULL) {
-            return FALSE;
-        }
-        if (pBitmap->GetBuffer() == NULL) {
-            delete pBitmap;
-            return FALSE;
-        }
-        if (pBitmap->IsAlphaMask()) {
-            if (m_BitmapAlpha != 255) {
-                if (m_AlphaFlag >> 8) {
-                    m_AlphaFlag = (((FX_BYTE)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) | ((m_AlphaFlag >> 8) << 8));
-                } else {
-                    m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
-                }
-            }
-            m_pDevice->CompositeMask(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
-                                     pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, m_MaskColor,
-                                     0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform);
-        } else {
-            if (m_BitmapAlpha != 255) {
-                pBitmap->MultiplyAlpha(m_BitmapAlpha);
-            }
-            m_pDevice->CompositeBitmap(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
-                                       pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, 0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_pIccTransform);
-        }
-        delete pBitmap;
-        return FALSE;
-    }
-    return FALSE;
-}
-CFX_BitmapStorer::CFX_BitmapStorer()
-{
-    m_pBitmap = NULL;
-}
-CFX_BitmapStorer::~CFX_BitmapStorer()
-{
-    if (m_pBitmap) {
-        delete m_pBitmap;
-    }
-}
-CFX_DIBitmap* CFX_BitmapStorer::Detach()
-{
-    CFX_DIBitmap* pBitmap = m_pBitmap;
-    m_pBitmap = NULL;
-    return pBitmap;
-}
-void CFX_BitmapStorer::Replace(CFX_DIBitmap* pBitmap)
-{
-    if (m_pBitmap) {
-        delete m_pBitmap;
-    }
-    m_pBitmap = pBitmap;
-}
-void CFX_BitmapStorer::ComposeScanline(int line, FX_LPCBYTE scanline, FX_LPCBYTE scan_extra_alpha)
-{
-    FX_LPBYTE dest_buf = (FX_LPBYTE)m_pBitmap->GetScanline(line);
-    FX_LPBYTE dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
-                               (FX_LPBYTE)m_pBitmap->m_pAlphaMask->GetScanline(line) : NULL;
-    if (dest_buf) {
-        FXSYS_memcpy32(dest_buf, scanline, m_pBitmap->GetPitch());
-    }
-    if (dest_alpha_buf) {
-        FXSYS_memcpy32(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
-    }
-}
-FX_BOOL CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
-{
+      dest_scan += (m_Width - 1) * Bpp;
+      if (Bpp == 1) {
+        for (int col = 0; col < m_Width; col++) {
+          *dest_scan = *src_scan;
+          dest_scan--;
+          src_scan++;
+        }
+      } else if (Bpp == 3) {
+        for (int col = 0; col < m_Width; col++) {
+          dest_scan[0] = src_scan[0];
+          dest_scan[1] = src_scan[1];
+          dest_scan[2] = src_scan[2];
+          dest_scan -= 3;
+          src_scan += 3;
+        }
+      } else {
+        ASSERT(Bpp == 4);
+        for (int col = 0; col < m_Width; col++) {
+          *(FX_DWORD*)dest_scan = *(FX_DWORD*)src_scan;
+          dest_scan -= 4;
+          src_scan += 4;
+        }
+      }
+    }
+  }
+  if (m_pAlphaMask) {
+    pDestBuffer = pFlipped->m_pAlphaMask->GetBuffer();
+    FX_DWORD dest_pitch = pFlipped->m_pAlphaMask->GetPitch();
+    for (int row = 0; row < m_Height; row++) {
+      FX_LPCBYTE src_scan = m_pAlphaMask->GetScanline(row);
+      FX_LPBYTE dest_scan =
+          pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row);
+      if (!bXFlip) {
+        FXSYS_memcpy32(dest_scan, src_scan, dest_pitch);
+        continue;
+      }
+      dest_scan += (m_Width - 1);
+      for (int col = 0; col < m_Width; col++) {
+        *dest_scan = *src_scan;
+        dest_scan--;
+        src_scan++;
+      }
+    }
+  }
+  return pFlipped;
+}
+CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc) {
+  m_pBitmap = NULL;
+  if (pSrc->GetBuffer() == NULL) {
+    m_pBitmap = pSrc->Clone();
+  } else {
     m_pBitmap = FX_NEW CFX_DIBitmap;
     if (!m_pBitmap) {
-        return FALSE;
-    }
-    if (!m_pBitmap->Create(width, height, src_format)) {
-        delete m_pBitmap;
-        m_pBitmap = NULL;
-        return FALSE;
-    }
-    if (pSrcPalette) {
-        m_pBitmap->CopyPalette(pSrcPalette);
-    }
+      return;
+    }
+    if (!m_pBitmap->Create(pSrc->GetWidth(),
+                           pSrc->GetHeight(),
+                           pSrc->GetFormat(),
+                           pSrc->GetBuffer())) {
+      delete m_pBitmap;
+      m_pBitmap = NULL;
+      return;
+    }
+    m_pBitmap->CopyPalette(pSrc->GetPalette());
+    m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
+  }
+}
+CFX_DIBExtractor::~CFX_DIBExtractor() {
+  if (m_pBitmap) {
+    delete m_pBitmap;
+  }
+}
+CFX_FilteredDIB::CFX_FilteredDIB() {
+  m_pScanline = NULL;
+  m_pSrc = NULL;
+}
+CFX_FilteredDIB::~CFX_FilteredDIB() {
+  if (m_pSrc && m_bAutoDropSrc) {
+    delete m_pSrc;
+  }
+  if (m_pScanline) {
+    FX_Free(m_pScanline);
+  }
+}
+void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc) {
+  m_pSrc = pSrc;
+  m_bAutoDropSrc = bAutoDropSrc;
+  m_Width = pSrc->GetWidth();
+  m_Height = pSrc->GetHeight();
+  FXDIB_Format format = GetDestFormat();
+  m_bpp = (FX_BYTE)format;
+  m_AlphaFlag = (FX_BYTE)(format >> 8);
+  m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
+  m_pPalette = GetDestPalette();
+  m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
+}
+FX_LPCBYTE CFX_FilteredDIB::GetScanline(int line) const {
+  TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
+  return m_pScanline;
+}
+void CFX_FilteredDIB::DownSampleScanline(int line,
+                                         FX_LPBYTE dest_scan,
+                                         int dest_bpp,
+                                         int dest_width,
+                                         FX_BOOL bFlipX,
+                                         int clip_left,
+                                         int clip_width) const {
+  m_pSrc->DownSampleScanline(
+      line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
+  TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
+}
+CFX_ImageRenderer::CFX_ImageRenderer() {
+  m_Status = 0;
+  m_pTransformer = NULL;
+  m_bRgbByteOrder = FALSE;
+  m_BlendType = FXDIB_BLEND_NORMAL;
+}
+CFX_ImageRenderer::~CFX_ImageRenderer() {
+  if (m_pTransformer) {
+    delete m_pTransformer;
+  }
+}
+extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip,
+                                  int width,
+                                  int height,
+                                  FX_BOOL bFlipX,
+                                  FX_BOOL bFlipY);
+FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice,
+                                 const CFX_ClipRgn* pClipRgn,
+                                 const CFX_DIBSource* pSource,
+                                 int bitmap_alpha,
+                                 FX_DWORD mask_color,
+                                 const CFX_AffineMatrix* pMatrix,
+                                 FX_DWORD dib_flags,
+                                 FX_BOOL bRgbByteOrder,
+                                 int alpha_flag,
+                                 void* pIccTransform,
+                                 int blend_type) {
+  m_Matrix = *pMatrix;
+  CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
+  FX_RECT image_rect = image_rect_f.GetOutterRect();
+  m_ClipBox = pClipRgn
+                  ? pClipRgn->GetBox()
+                  : FX_RECT(0, 0, pDevice->GetWidth(), pDevice->GetHeight());
+  m_ClipBox.Intersect(image_rect);
+  if (m_ClipBox.IsEmpty()) {
+    return FALSE;
+  }
+  m_pDevice = pDevice;
+  m_pClipRgn = pClipRgn;
+  m_MaskColor = mask_color;
+  m_BitmapAlpha = bitmap_alpha;
+  m_Matrix = *pMatrix;
+  m_Flags = dib_flags;
+  m_AlphaFlag = alpha_flag;
+  m_pIccTransform = pIccTransform;
+  m_bRgbByteOrder = bRgbByteOrder;
+  m_BlendType = blend_type;
+  FX_BOOL ret = TRUE;
+  if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
+      (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0)) {
+    if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 &&
+        FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
+        FXSYS_fabs(m_Matrix.a) < 0.5f && FXSYS_fabs(m_Matrix.d) < 0.5f) {
+      int dest_width = image_rect.Width();
+      int dest_height = image_rect.Height();
+      FX_RECT bitmap_clip = m_ClipBox;
+      bitmap_clip.Offset(-image_rect.left, -image_rect.top);
+      bitmap_clip = _FXDIB_SwapClipBox(
+          bitmap_clip, dest_width, dest_height, m_Matrix.c > 0, m_Matrix.b < 0);
+      m_Composer.Compose(pDevice,
+                         pClipRgn,
+                         bitmap_alpha,
+                         mask_color,
+                         m_ClipBox,
+                         TRUE,
+                         m_Matrix.c > 0,
+                         m_Matrix.b < 0,
+                         m_bRgbByteOrder,
+                         alpha_flag,
+                         pIccTransform,
+                         m_BlendType);
+      if (!m_Stretcher.Start(&m_Composer,
+                             pSource,
+                             dest_height,
+                             dest_width,
+                             bitmap_clip,
+                             dib_flags)) {
+        return FALSE;
+      }
+      m_Status = 1;
+      return TRUE;
+    }
+    m_Status = 2;
+    m_pTransformer = FX_NEW CFX_ImageTransformer;
+    if (!m_pTransformer) {
+      return FALSE;
+    }
+    m_pTransformer->Start(pSource, &m_Matrix, dib_flags, &m_ClipBox);
     return TRUE;
-}
+  }
+  int dest_width = image_rect.Width();
+  if (m_Matrix.a < 0) {
+    dest_width = -dest_width;
+  }
+  int dest_height = image_rect.Height();
+  if (m_Matrix.d > 0) {
+    dest_height = -dest_height;
+  }
+  if (dest_width == 0 || dest_height == 0) {
+    return FALSE;
+  }
+  FX_RECT bitmap_clip = m_ClipBox;
+  bitmap_clip.Offset(-image_rect.left, -image_rect.top);
+  m_Composer.Compose(pDevice,
+                     pClipRgn,
+                     bitmap_alpha,
+                     mask_color,
+                     m_ClipBox,
+                     FALSE,
+                     FALSE,
+                     FALSE,
+                     m_bRgbByteOrder,
+                     alpha_flag,
+                     pIccTransform,
+                     m_BlendType);
+  m_Status = 1;
+  ret = m_Stretcher.Start(
+      &m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
+  return ret;
+}
+FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause) {
+  if (m_Status == 1) {
+    return m_Stretcher.Continue(pPause);
+  } else if (m_Status == 2) {
+    if (m_pTransformer->Continue(pPause)) {
+      return TRUE;
+    }
+    CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
+    if (pBitmap == NULL) {
+      return FALSE;
+    }
+    if (pBitmap->GetBuffer() == NULL) {
+      delete pBitmap;
+      return FALSE;
+    }
+    if (pBitmap->IsAlphaMask()) {
+      if (m_BitmapAlpha != 255) {
+        if (m_AlphaFlag >> 8) {
+          m_AlphaFlag =
+              (((FX_BYTE)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) |
+               ((m_AlphaFlag >> 8) << 8));
+        } else {
+          m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
+        }
+      }
+      m_pDevice->CompositeMask(m_pTransformer->m_ResultLeft,
+                               m_pTransformer->m_ResultTop,
+                               pBitmap->GetWidth(),
+                               pBitmap->GetHeight(),
+                               pBitmap,
+                               m_MaskColor,
+                               0,
+                               0,
+                               m_BlendType,
+                               m_pClipRgn,
+                               m_bRgbByteOrder,
+                               m_AlphaFlag,
+                               m_pIccTransform);
+    } else {
+      if (m_BitmapAlpha != 255) {
+        pBitmap->MultiplyAlpha(m_BitmapAlpha);
+      }
+      m_pDevice->CompositeBitmap(m_pTransformer->m_ResultLeft,
+                                 m_pTransformer->m_ResultTop,
+                                 pBitmap->GetWidth(),
+                                 pBitmap->GetHeight(),
+                                 pBitmap,
+                                 0,
+                                 0,
+                                 m_BlendType,
+                                 m_pClipRgn,
+                                 m_bRgbByteOrder,
+                                 m_pIccTransform);
+    }
+    delete pBitmap;
+    return FALSE;
+  }
+  return FALSE;
+}
+CFX_BitmapStorer::CFX_BitmapStorer() {
+  m_pBitmap = NULL;
+}
+CFX_BitmapStorer::~CFX_BitmapStorer() {
+  if (m_pBitmap) {
+    delete m_pBitmap;
+  }
+}
+CFX_DIBitmap* CFX_BitmapStorer::Detach() {
+  CFX_DIBitmap* pBitmap = m_pBitmap;
+  m_pBitmap = NULL;
+  return pBitmap;
+}
+void CFX_BitmapStorer::Replace(CFX_DIBitmap* pBitmap) {
+  if (m_pBitmap) {
+    delete m_pBitmap;
+  }
+  m_pBitmap = pBitmap;
+}
+void CFX_BitmapStorer::ComposeScanline(int line,
+                                       FX_LPCBYTE scanline,
+                                       FX_LPCBYTE scan_extra_alpha) {
+  FX_LPBYTE dest_buf = (FX_LPBYTE)m_pBitmap->GetScanline(line);
+  FX_LPBYTE dest_alpha_buf =
+      m_pBitmap->m_pAlphaMask
+          ? (FX_LPBYTE)m_pBitmap->m_pAlphaMask->GetScanline(line)
+          : NULL;
+  if (dest_buf) {
+    FXSYS_memcpy32(dest_buf, scanline, m_pBitmap->GetPitch());
+  }
+  if (dest_alpha_buf) {
+    FXSYS_memcpy32(
+        dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
+  }
+}
+FX_BOOL CFX_BitmapStorer::SetInfo(int width,
+                                  int height,
+                                  FXDIB_Format src_format,
+                                  FX_DWORD* pSrcPalette) {
+  m_pBitmap = FX_NEW CFX_DIBitmap;
+  if (!m_pBitmap) {
+    return FALSE;
+  }
+  if (!m_pBitmap->Create(width, height, src_format)) {
+    delete m_pBitmap;
+    m_pBitmap = NULL;
+    return FALSE;
+  }
+  if (pSrcPalette) {
+    m_pBitmap->CopyPalette(pSrcPalette);
+  }
+  return TRUE;
+}