Split fx_dib.h part 2chromium/3059

- Created cpp for CFX_FilteredDIB.
- Moved CFX_ScanLineCompositor to its own files.

Change-Id: I020e44a9e824d497db4526893d61eb3819af4059
Reviewed-on: https://pdfium-review.googlesource.com/3550
Commit-Queue: Nicolás Peña <npm@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>

6 files changed, 4032 insertions, 3995 deletions

diff --git a/core/fxge/dib/cfx_filtereddib.cpp b/core/fxge/dib/cfx_filtereddib.cpp
new file mode 100644
index 0000000000..2d6edd0d60
--- /dev/null
+++ b/core/fxge/dib/cfx_filtereddib.cpp
@@ -0,0 +1,42 @@
+// Copyright 2017 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 "core/fxge/dib/cfx_filtereddib.h"
+
+#include "core/fxge/fx_dib.h"
+
+CFX_FilteredDIB::CFX_FilteredDIB() {}
+
+CFX_FilteredDIB::~CFX_FilteredDIB() {}
+
+void CFX_FilteredDIB::LoadSrc(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
+  m_pSrc = pSrc;
+  m_Width = pSrc->GetWidth();
+  m_Height = pSrc->GetHeight();
+  FXDIB_Format format = GetDestFormat();
+  m_bpp = static_cast<uint8_t>(format);
+  m_AlphaFlag = static_cast<uint8_t>(format >> 8);
+  m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
+  m_pPalette.reset(GetDestPalette());
+  m_Scanline.resize(m_Pitch);
+}
+
+const uint8_t* CFX_FilteredDIB::GetScanline(int line) const {
+  TranslateScanline(m_pSrc->GetScanline(line), &m_Scanline);
+  return m_Scanline.data();
+}
+
+void CFX_FilteredDIB::DownSampleScanline(int line,
+                                         uint8_t* dest_scan,
+                                         int dest_bpp,
+                                         int dest_width,
+                                         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);
+}
diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp
new file mode 100644
index 0000000000..1e2a282c1f
--- /dev/null
+++ b/core/fxge/dib/cfx_scanlinecompositor.cpp
@@ -0,0 +1,3915 @@
+// Copyright 2017 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 "core/fxge/dib/cfx_scanlinecompositor.h"
+
+#include <algorithm>
+
+#include "core/fxcodec/fx_codec.h"
+#include "core/fxge/cfx_gemodule.h"
+
+namespace {
+
+const uint8_t color_sqrt[256] = {
+    0x00, 0x03, 0x07, 0x0B, 0x0F, 0x12, 0x16, 0x19, 0x1D, 0x20, 0x23, 0x26,
+    0x29, 0x2C, 0x2F, 0x32, 0x35, 0x37, 0x3A, 0x3C, 0x3F, 0x41, 0x43, 0x46,
+    0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x57, 0x59, 0x5B, 0x5C,
+    0x5E, 0x60, 0x61, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D,
+    0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
+    0x7B, 0x7C, 0x7D, 0x7E, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x91,
+    0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C,
+    0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5,
+    0xA6, 0xA7, 0xA7, 0xA8, 0xA9, 0xAA, 0xAA, 0xAB, 0xAC, 0xAD, 0xAD, 0xAE,
+    0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7,
+    0xB7, 0xB8, 0xB9, 0xBA, 0xBA, 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBE, 0xBF,
+    0xC0, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4, 0xC4, 0xC5, 0xC6, 0xC6, 0xC7,
+    0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCE,
+    0xCF, 0xD0, 0xD0, 0xD1, 0xD1, 0xD2, 0xD3, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6,
+    0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xD9, 0xDA, 0xDA, 0xDB, 0xDC, 0xDC, 0xDD,
+    0xDD, 0xDE, 0xDE, 0xDF, 0xE0, 0xE0, 0xE1, 0xE1, 0xE2, 0xE2, 0xE3, 0xE4,
+    0xE4, 0xE5, 0xE5, 0xE6, 0xE6, 0xE7, 0xE7, 0xE8, 0xE9, 0xE9, 0xEA, 0xEA,
+    0xEB, 0xEB, 0xEC, 0xEC, 0xED, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF0, 0xF1,
+    0xF1, 0xF2, 0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF6, 0xF7,
+    0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFD,
+    0xFD, 0xFE, 0xFE, 0xFF};
+
+int Blend(int blend_mode, int back_color, int src_color) {
+  switch (blend_mode) {
+    case FXDIB_BLEND_NORMAL:
+      return src_color;
+    case FXDIB_BLEND_MULTIPLY:
+      return src_color * back_color / 255;
+    case FXDIB_BLEND_SCREEN:
+      return src_color + back_color - src_color * back_color / 255;
+    case FXDIB_BLEND_OVERLAY:
+      return Blend(FXDIB_BLEND_HARDLIGHT, src_color, back_color);
+    case FXDIB_BLEND_DARKEN:
+      return src_color < back_color ? src_color : back_color;
+    case FXDIB_BLEND_LIGHTEN:
+      return src_color > back_color ? src_color : back_color;
+    case FXDIB_BLEND_COLORDODGE: {
+      if (src_color == 255)
+        return src_color;
+
+      return std::min(back_color * 255 / (255 - src_color), 255);
+    }
+    case FXDIB_BLEND_COLORBURN: {
+      if (src_color == 0)
+        return src_color;
+
+      return 255 - std::min((255 - back_color) * 255 / src_color, 255);
+    }
+    case FXDIB_BLEND_HARDLIGHT:
+      if (src_color < 128)
+        return (src_color * back_color * 2) / 255;
+
+      return Blend(FXDIB_BLEND_SCREEN, back_color, 2 * src_color - 255);
+    case FXDIB_BLEND_SOFTLIGHT: {
+      if (src_color < 128) {
+        return back_color -
+               (255 - 2 * src_color) * back_color * (255 - back_color) / 255 /
+                   255;
+      }
+      return back_color +
+             (2 * src_color - 255) * (color_sqrt[back_color] - back_color) /
+                 255;
+    }
+    case FXDIB_BLEND_DIFFERENCE:
+      return back_color < src_color ? src_color - back_color
+                                    : back_color - src_color;
+    case FXDIB_BLEND_EXCLUSION:
+      return back_color + src_color - 2 * back_color * src_color / 255;
+  }
+  return src_color;
+}
+
+struct RGB {
+  int red;
+  int green;
+  int blue;
+};
+
+int Lum(RGB color) {
+  return (color.red * 30 + color.green * 59 + color.blue * 11) / 100;
+}
+
+RGB ClipColor(RGB color) {
+  int l = Lum(color);
+  int n = std::min(color.red, std::min(color.green, color.blue));
+  int x = std::max(color.red, std::max(color.green, color.blue));
+  if (n < 0) {
+    color.red = l + ((color.red - l) * l / (l - n));
+    color.green = l + ((color.green - l) * l / (l - n));
+    color.blue = l + ((color.blue - l) * l / (l - n));
+  }
+  if (x > 255) {
+    color.red = l + ((color.red - l) * (255 - l) / (x - l));
+    color.green = l + ((color.green - l) * (255 - l) / (x - l));
+    color.blue = l + ((color.blue - l) * (255 - l) / (x - l));
+  }
+  return color;
+}
+
+RGB SetLum(RGB color, int l) {
+  int d = l - Lum(color);
+  color.red += d;
+  color.green += d;
+  color.blue += d;
+  return ClipColor(color);
+}
+
+int Sat(RGB color) {
+  return std::max(color.red, std::max(color.green, color.blue)) -
+         std::min(color.red, std::min(color.green, color.blue));
+}
+
+RGB SetSat(RGB color, int s) {
+  int min = std::min(color.red, std::min(color.green, color.blue));
+  int max = std::max(color.red, std::max(color.green, color.blue));
+  if (min == max)
+    return {0, 0, 0};
+
+  color.red = (color.red - min) * s / (max - min);
+  color.green = (color.green - min) * s / (max - min);
+  color.blue = (color.blue - min) * s / (max - min);
+  return color;
+}
+
+void RGB_Blend(int blend_mode,
+               const uint8_t* src_scan,
+               const uint8_t* dest_scan,
+               int results[3]) {
+  RGB result = {0, 0, 0};
+  RGB src;
+  src.red = src_scan[2];
+  src.green = src_scan[1];
+  src.blue = src_scan[0];
+  RGB back;
+  back.red = dest_scan[2];
+  back.green = dest_scan[1];
+  back.blue = dest_scan[0];
+  switch (blend_mode) {
+    case FXDIB_BLEND_HUE:
+      result = SetLum(SetSat(src, Sat(back)), Lum(back));
+      break;
+    case FXDIB_BLEND_SATURATION:
+      result = SetLum(SetSat(back, Sat(src)), Lum(back));
+      break;
+    case FXDIB_BLEND_COLOR:
+      result = SetLum(src, Lum(back));
+      break;
+    case FXDIB_BLEND_LUMINOSITY:
+      result = SetLum(back, Lum(src));
+      break;
+  }
+  results[0] = result.blue;
+  results[1] = result.green;
+  results[2] = result.red;
+}
+
+int GetAlpha(uint8_t src_alpha, const uint8_t* clip_scan, int col) {
+  return clip_scan ? clip_scan[col] * src_alpha / 255 : src_alpha;
+}
+
+void CompositeRow_AlphaToMask(uint8_t* dest_scan,
+                              const uint8_t* src_scan,
+                              int pixel_count,
+                              const uint8_t* clip_scan,
+                              uint8_t stride) {
+  src_scan += stride - 1;
+  for (int col = 0; col < pixel_count; ++col) {
+    int src_alpha = GetAlpha(*src_scan, clip_scan, col);
+    uint8_t back_alpha = *dest_scan;
+    if (!back_alpha)
+      *dest_scan = src_alpha;
+    else if (src_alpha)
+      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    ++dest_scan;
+    src_scan += stride;
+  }
+}
+
+void CompositeRow_Rgb2Mask(uint8_t* dest_scan,
+                           const uint8_t* src_scan,
+                           int width,
+                           const uint8_t* clip_scan) {
+  if (!clip_scan) {
+    FXSYS_memset(dest_scan, 0xff, width);
+    return;
+  }
+  for (int i = 0; i < width; ++i) {
+    *dest_scan = FXDIB_ALPHA_UNION(*dest_scan, *clip_scan);
+    ++dest_scan;
+    ++clip_scan;
+  }
+}
+
+uint8_t GetGray(void* pIccTransform,
+                CCodec_IccModule* pIccModule,
+                const uint8_t* src_scan) {
+  if (!pIccTransform)
+    return FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
+
+  uint8_t gray;
+  pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
+  return gray;
+}
+
+uint8_t GetGrayWithBlend(void* pIccTransform,
+                         CCodec_IccModule* pIccModule,
+                         const uint8_t* src_scan,
+                         const uint8_t* dest_scan,
+                         int blend_type) {
+  uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan);
+  if (blend_type >= FXDIB_BLEND_NONSEPARABLE)
+    gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+  else if (blend_type)
+    gray = Blend(blend_type, *dest_scan, gray);
+  return gray;
+}
+
+void CompositeRow_Argb2Graya(uint8_t* dest_scan,
+                             const uint8_t* src_scan,
+                             int pixel_count,
+                             int blend_type,
+                             const uint8_t* clip_scan,
+                             const uint8_t* src_alpha_scan,
+                             uint8_t* dst_alpha_scan,
+                             void* pIccTransform) {
+  CCodec_IccModule* pIccModule = nullptr;
+  if (pIccTransform)
+    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  uint8_t offset = src_alpha_scan ? 3 : 4;
+  for (int col = 0; col < pixel_count; ++col) {
+    const uint8_t* alpha_scan =
+        src_alpha_scan ? src_alpha_scan++ : &src_scan[3];
+    uint8_t back_alpha = *dst_alpha_scan;
+    if (back_alpha == 0) {
+      int src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
+      if (src_alpha) {
+        *dest_scan = GetGray(pIccTransform, pIccModule, src_scan);
+        *dst_alpha_scan = src_alpha;
+      }
+      ++dest_scan;
+      ++dst_alpha_scan;
+      src_scan += offset;
+      continue;
+    }
+    uint8_t src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
+    if (src_alpha == 0) {
+      ++dest_scan;
+      ++dst_alpha_scan;
+      src_scan += offset;
+      continue;
+    }
+    *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
+    int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
+    uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan);
+    // TODO(npm): Does this if really need src_alpha_scan or was that a bug?
+    if (blend_type && src_alpha_scan) {
+      if (blend_type >= FXDIB_BLEND_NONSEPARABLE)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = Blend(blend_type, *dest_scan, gray);
+    }
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+    ++dest_scan;
+    ++dst_alpha_scan;
+    src_scan += offset;
+  }
+}
+
+void CompositeRow_Argb2Gray(uint8_t* dest_scan,
+                            const uint8_t* src_scan,
+                            int pixel_count,
+                            int blend_type,
+                            const uint8_t* clip_scan,
+                            const uint8_t* src_alpha_scan,
+                            void* pIccTransform) {
+  CCodec_IccModule* pIccModule = nullptr;
+  uint8_t gray;
+  if (pIccTransform)
+    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+
+  uint8_t offset = src_alpha_scan ? 3 : 4;
+  for (int col = 0; col < pixel_count; ++col) {
+    const uint8_t* alpha_scan =
+        src_alpha_scan ? src_alpha_scan++ : &src_scan[3];
+    int src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
+    if (src_alpha) {
+      gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan,
+                              blend_type);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
+    }
+    ++dest_scan;
+    src_scan += offset;
+  }
+}
+
+void CompositeRow_Rgb2Gray(uint8_t* dest_scan,
+                           const uint8_t* src_scan,
+                           int src_Bpp,
+                           int pixel_count,
+                           int blend_type,
+                           const uint8_t* clip_scan,
+                           void* pIccTransform) {
+  CCodec_IccModule* pIccModule = nullptr;
+  uint8_t gray;
+  if (pIccTransform)
+    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  for (int col = 0; col < pixel_count; ++col) {
+    gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan,
+                            blend_type);
+    if (clip_scan && clip_scan[col] < 255)
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
+    else
+      *dest_scan = gray;
+    ++dest_scan;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Rgb2Graya(uint8_t* dest_scan,
+                            const uint8_t* src_scan,
+                            int src_Bpp,
+                            int pixel_count,
+                            int blend_type,
+                            const uint8_t* clip_scan,
+                            uint8_t* dest_alpha_scan,
+                            void* pIccTransform) {
+  CCodec_IccModule* pIccModule = nullptr;
+  if (pIccTransform)
+    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  for (int col = 0; col < pixel_count; ++col) {
+    if (blend_type && *dest_alpha_scan == 0) {
+      *dest_scan = GetGray(pIccTransform, pIccModule, src_scan);
+      ++dest_scan;
+      ++dest_alpha_scan;
+      src_scan += src_Bpp;
+      continue;
+    }
+    int src_alpha = clip_scan ? clip_scan[col] : 255;
+    if (src_alpha == 255) {
+      *dest_scan = GetGrayWithBlend(pIccTransform, pIccModule, src_scan,
+                                    dest_scan, blend_type);
+      ++dest_scan;
+      *dest_alpha_scan = 255;
+      ++dest_alpha_scan;
+      src_scan += src_Bpp;
+      continue;
+    }
+    if (src_alpha == 0) {
+      ++dest_scan;
+      ++dest_alpha_scan;
+      src_scan += src_Bpp;
+      continue;
+    }
+    int back_alpha = *dest_alpha_scan;
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan = dest_alpha;
+    ++dest_alpha_scan;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    uint8_t gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan,
+                                    dest_scan, blend_type);
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+    ++dest_scan;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Argb2Argb(uint8_t* dest_scan,
+                            const uint8_t* src_scan,
+                            int pixel_count,
+                            int blend_type,
+                            const uint8_t* clip_scan,
+                            uint8_t* dest_alpha_scan,
+                            const uint8_t* src_alpha_scan) {
+  int blended_colors[3];
+  uint8_t dest_offset = dest_alpha_scan ? 3 : 4;
+  uint8_t src_offset = src_alpha_scan ? 3 : 4;
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  bool has_src = !!src_alpha_scan;
+  bool has_dest = !!dest_alpha_scan;
+  for (int col = 0; col < pixel_count; ++col) {
+    uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3];
+    const uint8_t* alpha_source = has_src ? src_alpha_scan++ : &src_scan[3];
+    uint8_t src_alpha = GetAlpha(*alpha_source, clip_scan, col);
+    if (back_alpha == 0) {
+      if (!has_dest && !has_src) {
+        if (clip_scan) {
+          FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) |
+                                       (src_alpha << 24));
+        } else {
+          FXARGB_COPY(dest_scan, src_scan);
+        }
+      } else if (has_dest) {
+        *dest_alpha_scan = src_alpha;
+        for (int i = 0; i < 3; ++i) {
+          *dest_scan = *src_scan++;
+          ++dest_scan;
+        }
+        ++dest_alpha_scan;
+        if (!has_src)
+          ++src_scan;
+      } else {
+        FXARGB_SETDIB(dest_scan, FXARGB_MAKE((src_alpha << 24), src_scan[2],
+                                             src_scan[1], *src_scan));
+      }
+      if (!has_dest) {
+        dest_scan += dest_offset;
+        src_scan += src_offset;
+      }
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += dest_offset;
+      src_scan += src_offset;
+      if (has_dest)
+        ++dest_alpha_scan;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    if (has_dest) {
+      *dest_alpha_scan = dest_alpha;
+      ++dest_alpha_scan;
+    } else {
+      dest_scan[3] = dest_alpha;
+    }
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (bNonseparableBlend)
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+    for (int color = 0; color < 3; ++color) {
+      if (blend_type) {
+        int blended = bNonseparableBlend
+                          ? blended_colors[color]
+                          : Blend(blend_type, *dest_scan, *src_scan);
+        blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      } else {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
+      }
+      ++dest_scan;
+      ++src_scan;
+    }
+    if (!has_dest)
+      ++dest_scan;
+    if (!has_src)
+      ++src_scan;
+  }
+}
+
+void CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan,
+                                        const uint8_t* src_scan,
+                                        int width,
+                                        int blend_type,
+                                        int src_Bpp,
+                                        uint8_t* dest_alpha_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; ++col) {
+    uint8_t* dest_alpha = dest_alpha_scan ? dest_alpha_scan : &dest_scan[3];
+    uint8_t back_alpha = *dest_alpha;
+    if (back_alpha == 0) {
+      if (dest_alpha_scan) {
+        for (int i = 0; i < 3; ++i) {
+          *dest_scan = *src_scan++;
+          ++dest_scan;
+        }
+        *dest_alpha_scan = 0xff;
+        ++dest_alpha_scan;
+      } else {
+        if (src_Bpp == 4) {
+          FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
+        } else {
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1],
+                                               src_scan[0]));
+        }
+        dest_scan += 4;
+      }
+      src_scan += src_Bpp;
+      continue;
+    }
+    *dest_alpha = 0xff;
+    if (bNonseparableBlend)
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+    for (int color = 0; color < 3; ++color) {
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, *dest_scan, src_color);
+      *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
+      ++dest_scan;
+      ++src_scan;
+    }
+    if (dest_alpha_scan)
+      ++dest_alpha_scan;
+    else
+      ++dest_scan;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan,
+                                      const uint8_t* src_scan,
+                                      int width,
+                                      int blend_type,
+                                      int src_Bpp,
+                                      const uint8_t* clip_scan,
+                                      uint8_t* dest_alpha_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  bool has_dest = !!dest_alpha_scan;
+  for (int col = 0; col < width; ++col) {
+    int src_alpha = *clip_scan++;
+    uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3];
+    if (back_alpha == 0) {
+      for (int i = 0; i < 3; ++i) {
+        *dest_scan = *src_scan++;
+        ++dest_scan;
+      }
+      src_scan += src_gap;
+      if (has_dest)
+        dest_alpha_scan++;
+      else
+        dest_scan++;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += has_dest ? 3 : 4;
+      if (has_dest)
+        dest_alpha_scan++;
+      src_scan += src_Bpp;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    if (has_dest)
+      *dest_alpha_scan++ = dest_alpha;
+    else
+      dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (bNonseparableBlend)
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+    for (int color = 0; color < 3; color++) {
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, *dest_scan, src_color);
+      blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      src_scan++;
+    }
+    src_scan += src_gap;
+    if (!has_dest)
+      dest_scan++;
+  }
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_Clip(uint8_t* dest_scan,
+                                        const uint8_t* src_scan,
+                                        int width,
+                                        int src_Bpp,
+                                        const uint8_t* clip_scan,
+                                        uint8_t* dest_alpha_scan) {
+  int src_gap = src_Bpp - 3;
+  if (dest_alpha_scan) {
+    for (int col = 0; col < width; col++) {
+      int src_alpha = clip_scan[col];
+      if (src_alpha == 255) {
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_alpha_scan++ = 255;
+        src_scan += src_gap;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += 3;
+        dest_alpha_scan++;
+        src_scan += src_Bpp;
+        continue;
+      }
+      int back_alpha = *dest_alpha_scan;
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      *dest_alpha_scan++ = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      for (int color = 0; color < 3; color++) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
+        dest_scan++;
+        src_scan++;
+      }
+      src_scan += src_gap;
+    }
+  } else {
+    for (int col = 0; col < width; col++) {
+      int src_alpha = clip_scan[col];
+      if (src_alpha == 255) {
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = 255;
+        src_scan += src_gap;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += 4;
+        src_scan += src_Bpp;
+        continue;
+      }
+      int back_alpha = dest_scan[3];
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      dest_scan[3] = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      for (int color = 0; color < 3; color++) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
+        dest_scan++;
+        src_scan++;
+      }
+      dest_scan++;
+      src_scan += src_gap;
+    }
+  }
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_NoClip(uint8_t* dest_scan,
+                                          const uint8_t* src_scan,
+                                          int width,
+                                          int src_Bpp,
+                                          uint8_t* dest_alpha_scan) {
+  if (dest_alpha_scan) {
+    int src_gap = src_Bpp - 3;
+    for (int col = 0; col < width; col++) {
+      *dest_scan++ = *src_scan++;
+      *dest_scan++ = *src_scan++;
+      *dest_scan++ = *src_scan++;
+      *dest_alpha_scan++ = 0xff;
+      src_scan += src_gap;
+    }
+  } else {
+    for (int col = 0; col < width; col++) {
+      if (src_Bpp == 4) {
+        FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
+      } else {
+        FXARGB_SETDIB(dest_scan,
+                      FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
+      }
+      dest_scan += 4;
+      src_scan += src_Bpp;
+    }
+  }
+}
+
+void CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan,
+                                 const uint8_t* src_scan,
+                                 int width,
+                                 int blend_type,
+                                 int dest_Bpp,
+                                 const uint8_t* clip_scan,
+                                 const uint8_t* src_alpha_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int dest_gap = dest_Bpp - 3;
+  if (src_alpha_scan) {
+    for (int col = 0; col < width; col++) {
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
+      } else {
+        src_alpha = *src_alpha_scan++;
+      }
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_scan += 3;
+        continue;
+      }
+      if (bNonseparableBlend) {
+        RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      }
+      for (int color = 0; color < 3; color++) {
+        int back_color = *dest_scan;
+        int blended = bNonseparableBlend
+                          ? blended_colors[color]
+                          : Blend(blend_type, back_color, *src_scan);
+        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+        dest_scan++;
+        src_scan++;
+      }
+      dest_scan += dest_gap;
+    }
+  } else {
+    for (int col = 0; col < width; col++) {
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+      } else {
+        src_alpha = src_scan[3];
+      }
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_scan += 4;
+        continue;
+      }
+      if (bNonseparableBlend) {
+        RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      }
+      for (int color = 0; color < 3; color++) {
+        int back_color = *dest_scan;
+        int blended = bNonseparableBlend
+                          ? blended_colors[color]
+                          : Blend(blend_type, back_color, *src_scan);
+        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+        dest_scan++;
+        src_scan++;
+      }
+      dest_scan += dest_gap;
+      src_scan++;
+    }
+  }
+}
+
+void CompositeRow_Argb2Rgb_NoBlend(uint8_t* dest_scan,
+                                   const uint8_t* src_scan,
+                                   int width,
+                                   int dest_Bpp,
+                                   const uint8_t* clip_scan,
+                                   const uint8_t* src_alpha_scan) {
+  int dest_gap = dest_Bpp - 3;
+  if (src_alpha_scan) {
+    for (int col = 0; col < width; col++) {
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
+      } else {
+        src_alpha = *src_alpha_scan++;
+      }
+      if (src_alpha == 255) {
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        dest_scan += dest_gap;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_scan += 3;
+        continue;
+      }
+      for (int color = 0; color < 3; color++) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
+        dest_scan++;
+        src_scan++;
+      }
+      dest_scan += dest_gap;
+    }
+  } else {
+    for (int col = 0; col < width; col++) {
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+      } else {
+        src_alpha = src_scan[3];
+      }
+      if (src_alpha == 255) {
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        dest_scan += dest_gap;
+        src_scan++;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_scan += 4;
+        continue;
+      }
+      for (int color = 0; color < 3; color++) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
+        dest_scan++;
+        src_scan++;
+      }
+      dest_scan += dest_gap;
+      src_scan++;
+    }
+  }
+}
+
+void CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan,
+                                       const uint8_t* src_scan,
+                                       int width,
+                                       int blend_type,
+                                       int dest_Bpp,
+                                       int src_Bpp) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int dest_gap = dest_Bpp - 3;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    if (bNonseparableBlend) {
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int back_color = *dest_scan;
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, back_color, src_color);
+      *dest_scan = blended;
+      dest_scan++;
+      src_scan++;
+    }
+    dest_scan += dest_gap;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_Blend_Clip(uint8_t* dest_scan,
+                                     const uint8_t* src_scan,
+                                     int width,
+                                     int blend_type,
+                                     int dest_Bpp,
+                                     int src_Bpp,
+                                     const uint8_t* clip_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int dest_gap = dest_Bpp - 3;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    uint8_t src_alpha = *clip_scan++;
+    if (src_alpha == 0) {
+      dest_scan += dest_Bpp;
+      src_scan += src_Bpp;
+      continue;
+    }
+    if (bNonseparableBlend) {
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int src_color = *src_scan;
+      int back_color = *dest_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, back_color, src_color);
+      *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+      dest_scan++;
+      src_scan++;
+    }
+    dest_scan += dest_gap;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan,
+                                         const uint8_t* src_scan,
+                                         int width,
+                                         int dest_Bpp,
+                                         int src_Bpp) {
+  if (dest_Bpp == src_Bpp) {
+    FXSYS_memcpy(dest_scan, src_scan, width * dest_Bpp);
+    return;
+  }
+  for (int col = 0; col < width; col++) {
+    dest_scan[0] = src_scan[0];
+    dest_scan[1] = src_scan[1];
+    dest_scan[2] = src_scan[2];
+    dest_scan += dest_Bpp;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_Clip(uint8_t* dest_scan,
+                                       const uint8_t* src_scan,
+                                       int width,
+                                       int dest_Bpp,
+                                       int src_Bpp,
+                                       const uint8_t* clip_scan) {
+  for (int col = 0; col < width; col++) {
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 255) {
+      dest_scan[0] = src_scan[0];
+      dest_scan[1] = src_scan[1];
+      dest_scan[2] = src_scan[2];
+    } else if (src_alpha) {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
+      dest_scan++;
+      src_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
+      dest_scan++;
+      src_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
+      dest_scan += dest_Bpp - 2;
+      src_scan += src_Bpp - 2;
+      continue;
+    }
+    dest_scan += dest_Bpp;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Argb2Argb_Transform(uint8_t* dest_scan,
+                                      const uint8_t* src_scan,
+                                      int pixel_count,
+                                      int blend_type,
+                                      const uint8_t* clip_scan,
+                                      uint8_t* dest_alpha_scan,
+                                      const uint8_t* src_alpha_scan,
+                                      uint8_t* src_cache_scan,
+                                      void* pIccTransform) {
+  uint8_t* dp = src_cache_scan;
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_alpha_scan) {
+    if (dest_alpha_scan) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count);
+    } else {
+      for (int col = 0; col < pixel_count; col++) {
+        pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+        dp[3] = *src_alpha_scan++;
+        src_scan += 3;
+        dp += 4;
+      }
+      src_alpha_scan = nullptr;
+    }
+  } else {
+    if (dest_alpha_scan) {
+      int blended_colors[3];
+      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+      for (int col = 0; col < pixel_count; col++) {
+        pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                      1);
+        uint8_t back_alpha = *dest_alpha_scan;
+        if (back_alpha == 0) {
+          if (clip_scan) {
+            int src_alpha = clip_scan[col] * src_scan[3] / 255;
+            *dest_alpha_scan = src_alpha;
+            *dest_scan++ = *src_cache_scan++;
+            *dest_scan++ = *src_cache_scan++;
+            *dest_scan++ = *src_cache_scan++;
+          } else {
+            *dest_alpha_scan = src_scan[3];
+            *dest_scan++ = *src_cache_scan++;
+            *dest_scan++ = *src_cache_scan++;
+            *dest_scan++ = *src_cache_scan++;
+          }
+          dest_alpha_scan++;
+          src_scan += 4;
+          continue;
+        }
+        uint8_t src_alpha;
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * src_scan[3] / 255;
+        } else {
+          src_alpha = src_scan[3];
+        }
+        src_scan += 4;
+        if (src_alpha == 0) {
+          dest_scan += 3;
+          src_cache_scan += 3;
+          dest_alpha_scan++;
+          continue;
+        }
+        uint8_t dest_alpha =
+            back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        *dest_alpha_scan++ = dest_alpha;
+        int alpha_ratio = src_alpha * 255 / dest_alpha;
+        if (bNonseparableBlend) {
+          RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
+        }
+        for (int color = 0; color < 3; color++) {
+          if (blend_type) {
+            int blended = bNonseparableBlend
+                              ? blended_colors[color]
+                              : Blend(blend_type, *dest_scan, *src_cache_scan);
+            blended = FXDIB_ALPHA_MERGE(*src_cache_scan, blended, back_alpha);
+            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+          } else {
+            *dest_scan =
+                FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, alpha_ratio);
+          }
+          dest_scan++;
+          src_cache_scan++;
+        }
+      }
+      return;
+    }
+    for (int col = 0; col < pixel_count; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      dp[3] = src_scan[3];
+      src_scan += 4;
+      dp += 4;
+    }
+  }
+  CompositeRow_Argb2Argb(dest_scan, src_cache_scan, pixel_count, blend_type,
+                         clip_scan, dest_alpha_scan, src_alpha_scan);
+}
+
+void CompositeRow_Rgb2Argb_Blend_NoClip_Transform(uint8_t* dest_scan,
+                                                  const uint8_t* src_scan,
+                                                  int width,
+                                                  int blend_type,
+                                                  int src_Bpp,
+                                                  uint8_t* dest_alpha_scan,
+                                                  uint8_t* src_cache_scan,
+                                                  void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width,
+                                     blend_type, 3, dest_alpha_scan);
+}
+
+void CompositeRow_Rgb2Argb_Blend_Clip_Transform(uint8_t* dest_scan,
+                                                const uint8_t* src_scan,
+                                                int width,
+                                                int blend_type,
+                                                int src_Bpp,
+                                                const uint8_t* clip_scan,
+                                                uint8_t* dest_alpha_scan,
+                                                uint8_t* src_cache_scan,
+                                                void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
+                                   3, clip_scan, dest_alpha_scan);
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(uint8_t* dest_scan,
+                                                  const uint8_t* src_scan,
+                                                  int width,
+                                                  int src_Bpp,
+                                                  const uint8_t* clip_scan,
+                                                  uint8_t* dest_alpha_scan,
+                                                  uint8_t* src_cache_scan,
+                                                  void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3,
+                                     clip_scan, dest_alpha_scan);
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(uint8_t* dest_scan,
+                                                    const uint8_t* src_scan,
+                                                    int width,
+                                                    int src_Bpp,
+                                                    uint8_t* dest_alpha_scan,
+                                                    uint8_t* src_cache_scan,
+                                                    void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3,
+                                       dest_alpha_scan);
+}
+
+void CompositeRow_Argb2Rgb_Blend_Transform(uint8_t* dest_scan,
+                                           const uint8_t* src_scan,
+                                           int width,
+                                           int blend_type,
+                                           int dest_Bpp,
+                                           const uint8_t* clip_scan,
+                                           const uint8_t* src_alpha_scan,
+                                           uint8_t* src_cache_scan,
+                                           void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_alpha_scan) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    int blended_colors[3];
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    int dest_gap = dest_Bpp - 3;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+      } else {
+        src_alpha = src_scan[3];
+      }
+      src_scan += 4;
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_cache_scan += 3;
+        continue;
+      }
+      if (bNonseparableBlend) {
+        RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
+      }
+      for (int color = 0; color < 3; color++) {
+        int back_color = *dest_scan;
+        int blended = bNonseparableBlend
+                          ? blended_colors[color]
+                          : Blend(blend_type, back_color, *src_cache_scan);
+        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+        dest_scan++;
+        src_cache_scan++;
+      }
+      dest_scan += dest_gap;
+    }
+    return;
+  }
+  CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type,
+                              dest_Bpp, clip_scan, src_alpha_scan);
+}
+
+void CompositeRow_Argb2Rgb_NoBlend_Transform(uint8_t* dest_scan,
+                                             const uint8_t* src_scan,
+                                             int width,
+                                             int dest_Bpp,
+                                             const uint8_t* clip_scan,
+                                             const uint8_t* src_alpha_scan,
+                                             uint8_t* src_cache_scan,
+                                             void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_alpha_scan) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    int dest_gap = dest_Bpp - 3;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+      } else {
+        src_alpha = src_scan[3];
+      }
+      src_scan += 4;
+      if (src_alpha == 255) {
+        *dest_scan++ = *src_cache_scan++;
+        *dest_scan++ = *src_cache_scan++;
+        *dest_scan++ = *src_cache_scan++;
+        dest_scan += dest_gap;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += dest_Bpp;
+        src_cache_scan += 3;
+        continue;
+      }
+      for (int color = 0; color < 3; color++) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, src_alpha);
+        dest_scan++;
+        src_cache_scan++;
+      }
+      dest_scan += dest_gap;
+    }
+    return;
+  }
+  CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp,
+                                clip_scan, src_alpha_scan);
+}
+
+void CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(uint8_t* dest_scan,
+                                                 const uint8_t* src_scan,
+                                                 int width,
+                                                 int blend_type,
+                                                 int dest_Bpp,
+                                                 int src_Bpp,
+                                                 uint8_t* src_cache_scan,
+                                                 void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width,
+                                    blend_type, dest_Bpp, 3);
+}
+
+void CompositeRow_Rgb2Rgb_Blend_Clip_Transform(uint8_t* dest_scan,
+                                               const uint8_t* src_scan,
+                                               int width,
+                                               int blend_type,
+                                               int dest_Bpp,
+                                               int src_Bpp,
+                                               const uint8_t* clip_scan,
+                                               uint8_t* src_cache_scan,
+                                               void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
+                                  dest_Bpp, 3, clip_scan);
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(uint8_t* dest_scan,
+                                                   const uint8_t* src_scan,
+                                                   int width,
+                                                   int dest_Bpp,
+                                                   int src_Bpp,
+                                                   uint8_t* src_cache_scan,
+                                                   void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width,
+                                      dest_Bpp, 3);
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(uint8_t* dest_scan,
+                                                 const uint8_t* src_scan,
+                                                 int width,
+                                                 int dest_Bpp,
+                                                 int src_Bpp,
+                                                 const uint8_t* clip_scan,
+                                                 uint8_t* src_cache_scan,
+                                                 void* pIccTransform) {
+  CCodec_IccModule* pIccModule =
+      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  if (src_Bpp == 3) {
+    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
+                                  width);
+  } else {
+    uint8_t* dp = src_cache_scan;
+    for (int col = 0; col < width; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      src_scan += 4;
+      dp += 3;
+    }
+  }
+  CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp,
+                                    3, clip_scan);
+}
+
+void CompositeRow_8bppPal2Gray(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               const uint8_t* pPalette,
+                               int pixel_count,
+                               int blend_type,
+                               const uint8_t* clip_scan,
+                               const uint8_t* src_alpha_scan) {
+  if (src_alpha_scan) {
+    if (blend_type) {
+      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+      for (int col = 0; col < pixel_count; col++) {
+        uint8_t gray = pPalette[*src_scan];
+        int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = Blend(blend_type, *dest_scan, gray);
+        if (src_alpha)
+          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
+        else
+          *dest_scan = gray;
+        dest_scan++;
+        src_scan++;
+      }
+      return;
+    }
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray = pPalette[*src_scan];
+      int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+      if (src_alpha)
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
+      else
+        *dest_scan = gray;
+      dest_scan++;
+      src_scan++;
+    }
+  } else {
+    if (blend_type) {
+      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+      for (int col = 0; col < pixel_count; col++) {
+        uint8_t gray = pPalette[*src_scan];
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = Blend(blend_type, *dest_scan, gray);
+        if (clip_scan && clip_scan[col] < 255)
+          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
+        else
+          *dest_scan = gray;
+        dest_scan++;
+        src_scan++;
+      }
+      return;
+    }
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray = pPalette[*src_scan];
+      if (clip_scan && clip_scan[col] < 255)
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
+      else
+        *dest_scan = gray;
+      dest_scan++;
+      src_scan++;
+    }
+  }
+}
+
+void CompositeRow_8bppPal2Graya(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                const uint8_t* pPalette,
+                                int pixel_count,
+                                int blend_type,
+                                const uint8_t* clip_scan,
+                                uint8_t* dest_alpha_scan,
+                                const uint8_t* src_alpha_scan) {
+  if (src_alpha_scan) {
+    if (blend_type) {
+      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+      for (int col = 0; col < pixel_count; col++) {
+        uint8_t gray = pPalette[*src_scan];
+        src_scan++;
+        uint8_t back_alpha = *dest_alpha_scan;
+        if (back_alpha == 0) {
+          int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+          if (src_alpha) {
+            *dest_scan = gray;
+            *dest_alpha_scan = src_alpha;
+          }
+          dest_scan++;
+          dest_alpha_scan++;
+          continue;
+        }
+        uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+        if (src_alpha == 0) {
+          dest_scan++;
+          dest_alpha_scan++;
+          continue;
+        }
+        *dest_alpha_scan =
+            back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = Blend(blend_type, *dest_scan, gray);
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+        dest_alpha_scan++;
+        dest_scan++;
+      }
+      return;
+    }
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray = pPalette[*src_scan];
+      src_scan++;
+      uint8_t back_alpha = *dest_alpha_scan;
+      if (back_alpha == 0) {
+        int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+        if (src_alpha) {
+          *dest_scan = gray;
+          *dest_alpha_scan = src_alpha;
+        }
+        dest_scan++;
+        dest_alpha_scan++;
+        continue;
+      }
+      uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
+      if (src_alpha == 0) {
+        dest_scan++;
+        dest_alpha_scan++;
+        continue;
+      }
+      *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
+      dest_alpha_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+      dest_scan++;
+    }
+  } else {
+    if (blend_type) {
+      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+      for (int col = 0; col < pixel_count; col++) {
+        uint8_t gray = pPalette[*src_scan];
+        src_scan++;
+        if (!clip_scan || clip_scan[col] == 255) {
+          *dest_scan++ = gray;
+          *dest_alpha_scan++ = 255;
+          continue;
+        }
+        int src_alpha = clip_scan[col];
+        if (src_alpha == 0) {
+          dest_scan++;
+          dest_alpha_scan++;
+          continue;
+        }
+        int back_alpha = *dest_alpha_scan;
+        uint8_t dest_alpha =
+            back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        *dest_alpha_scan++ = dest_alpha;
+        int alpha_ratio = src_alpha * 255 / dest_alpha;
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = Blend(blend_type, *dest_scan, gray);
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+        dest_scan++;
+      }
+      return;
+    }
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray = pPalette[*src_scan];
+      src_scan++;
+      if (!clip_scan || clip_scan[col] == 255) {
+        *dest_scan++ = gray;
+        *dest_alpha_scan++ = 255;
+        continue;
+      }
+      int src_alpha = clip_scan[col];
+      if (src_alpha == 0) {
+        dest_scan++;
+        dest_alpha_scan++;
+        continue;
+      }
+      int back_alpha = *dest_alpha_scan;
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      *dest_alpha_scan++ = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+      dest_scan++;
+    }
+  }
+}
+
+void CompositeRow_1bppPal2Gray(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               int src_left,
+                               const uint8_t* pPalette,
+                               int pixel_count,
+                               int blend_type,
+                               const uint8_t* clip_scan) {
+  int reset_gray = pPalette[0];
+  int set_gray = pPalette[1];
+  if (blend_type) {
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray =
+          (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
+              ? set_gray
+              : reset_gray;
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = Blend(blend_type, *dest_scan, gray);
+      if (clip_scan && clip_scan[col] < 255) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
+      } else {
+        *dest_scan = gray;
+      }
+      dest_scan++;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    uint8_t gray =
+        (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
+            ? set_gray
+            : reset_gray;
+    if (clip_scan && clip_scan[col] < 255) {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
+    } else {
+      *dest_scan = gray;
+    }
+    dest_scan++;
+  }
+}
+
+void CompositeRow_1bppPal2Graya(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int src_left,
+                                const uint8_t* pPalette,
+                                int pixel_count,
+                                int blend_type,
+                                const uint8_t* clip_scan,
+                                uint8_t* dest_alpha_scan) {
+  int reset_gray = pPalette[0];
+  int set_gray = pPalette[1];
+  if (blend_type) {
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    for (int col = 0; col < pixel_count; col++) {
+      uint8_t gray =
+          (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
+              ? set_gray
+              : reset_gray;
+      if (!clip_scan || clip_scan[col] == 255) {
+        *dest_scan++ = gray;
+        *dest_alpha_scan++ = 255;
+        continue;
+      }
+      int src_alpha = clip_scan[col];
+      if (src_alpha == 0) {
+        dest_scan++;
+        dest_alpha_scan++;
+        continue;
+      }
+      int back_alpha = *dest_alpha_scan;
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      *dest_alpha_scan++ = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = Blend(blend_type, *dest_scan, gray);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+      dest_scan++;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    uint8_t gray =
+        (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
+            ? set_gray
+            : reset_gray;
+    if (!clip_scan || clip_scan[col] == 255) {
+      *dest_scan++ = gray;
+      *dest_alpha_scan++ = 255;
+      continue;
+    }
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 0) {
+      dest_scan++;
+      dest_alpha_scan++;
+      continue;
+    }
+    int back_alpha = *dest_alpha_scan;
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan++ = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
+    dest_scan++;
+  }
+}
+
+void CompositeRow_8bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
+                                      const uint8_t* src_scan,
+                                      uint32_t* pPalette,
+                                      int pixel_count,
+                                      int DestBpp,
+                                      const uint8_t* clip_scan,
+                                      const uint8_t* src_alpha_scan) {
+  if (src_alpha_scan) {
+    int dest_gap = DestBpp - 3;
+    FX_ARGB argb = 0;
+    for (int col = 0; col < pixel_count; col++) {
+      argb = pPalette[*src_scan];
+      int src_r = FXARGB_R(argb);
+      int src_g = FXARGB_G(argb);
+      int src_b = FXARGB_B(argb);
+      src_scan++;
+      uint8_t src_alpha = 0;
+      if (clip_scan) {
+        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
+      } else {
+        src_alpha = *src_alpha_scan++;
+      }
+      if (src_alpha == 255) {
+        *dest_scan++ = src_b;
+        *dest_scan++ = src_g;
+        *dest_scan++ = src_r;
+        dest_scan += dest_gap;
+        continue;
+      }
+      if (src_alpha == 0) {
+        dest_scan += DestBpp;
+        continue;
+      }
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
+      dest_scan++;
+      dest_scan += dest_gap;
+    }
+  } else {
+    FX_ARGB argb = 0;
+    for (int col = 0; col < pixel_count; col++) {
+      argb = pPalette[*src_scan];
+      int src_r = FXARGB_R(argb);
+      int src_g = FXARGB_G(argb);
+      int src_b = FXARGB_B(argb);
+      if (clip_scan && clip_scan[col] < 255) {
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]);
+        dest_scan++;
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]);
+        dest_scan++;
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]);
+        dest_scan++;
+      } else {
+        *dest_scan++ = src_b;
+        *dest_scan++ = src_g;
+        *dest_scan++ = src_r;
+      }
+      if (DestBpp == 4) {
+        dest_scan++;
+      }
+      src_scan++;
+    }
+  }
+}
+
+void CompositeRow_1bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
+                                      const uint8_t* src_scan,
+                                      int src_left,
+                                      uint32_t* pPalette,
+                                      int pixel_count,
+                                      int DestBpp,
+                                      const uint8_t* clip_scan) {
+  int reset_r, reset_g, reset_b;
+  int set_r, set_g, set_b;
+  reset_r = FXARGB_R(pPalette[0]);
+  reset_g = FXARGB_G(pPalette[0]);
+  reset_b = FXARGB_B(pPalette[0]);
+  set_r = FXARGB_R(pPalette[1]);
+  set_g = FXARGB_G(pPalette[1]);
+  set_b = FXARGB_B(pPalette[1]);
+  for (int col = 0; col < pixel_count; col++) {
+    int src_r, src_g, src_b;
+    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
+      src_r = set_r;
+      src_g = set_g;
+      src_b = set_b;
+    } else {
+      src_r = reset_r;
+      src_g = reset_g;
+      src_b = reset_b;
+    }
+    if (clip_scan && clip_scan[col] < 255) {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]);
+      dest_scan++;
+    } else {
+      *dest_scan++ = src_b;
+      *dest_scan++ = src_g;
+      *dest_scan++ = src_r;
+    }
+    if (DestBpp == 4) {
+      dest_scan++;
+    }
+  }
+}
+
+void CompositeRow_8bppRgb2Argb_NoBlend(uint8_t* dest_scan,
+                                       const uint8_t* src_scan,
+                                       int width,
+                                       uint32_t* pPalette,
+                                       const uint8_t* clip_scan,
+                                       const uint8_t* src_alpha_scan) {
+  if (src_alpha_scan) {
+    for (int col = 0; col < width; col++) {
+      FX_ARGB argb = pPalette[*src_scan];
+      src_scan++;
+      int src_r = FXARGB_R(argb);
+      int src_g = FXARGB_G(argb);
+      int src_b = FXARGB_B(argb);
+      uint8_t back_alpha = dest_scan[3];
+      if (back_alpha == 0) {
+        if (clip_scan) {
+          int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
+        } else {
+          FXARGB_SETDIB(dest_scan,
+                        FXARGB_MAKE(*src_alpha_scan, src_r, src_g, src_b));
+        }
+        dest_scan += 4;
+        src_alpha_scan++;
+        continue;
+      }
+      uint8_t src_alpha;
+      if (clip_scan) {
+        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
+      } else {
+        src_alpha = *src_alpha_scan++;
+      }
+      if (src_alpha == 0) {
+        dest_scan += 4;
+        continue;
+      }
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      dest_scan[3] = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+      dest_scan++;
+      dest_scan++;
+    }
+  } else {
+    for (int col = 0; col < width; col++) {
+      FX_ARGB argb = pPalette[*src_scan];
+      int src_r = FXARGB_R(argb);
+      int src_g = FXARGB_G(argb);
+      int src_b = FXARGB_B(argb);
+      if (!clip_scan || clip_scan[col] == 255) {
+        *dest_scan++ = src_b;
+        *dest_scan++ = src_g;
+        *dest_scan++ = src_r;
+        *dest_scan++ = 255;
+        src_scan++;
+        continue;
+      }
+      int src_alpha = clip_scan[col];
+      if (src_alpha == 0) {
+        dest_scan += 4;
+        src_scan++;
+        continue;
+      }
+      int back_alpha = dest_scan[3];
+      uint8_t dest_alpha =
+          back_alpha + src_alpha - back_alpha * src_alpha / 255;
+      dest_scan[3] = dest_alpha;
+      int alpha_ratio = src_alpha * 255 / dest_alpha;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+      dest_scan++;
+      dest_scan++;
+      src_scan++;
+    }
+  }
+}
+
+void CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan,
+                                       const uint8_t* src_scan,
+                                       int src_left,
+                                       int width,
+                                       uint32_t* pPalette,
+                                       const uint8_t* clip_scan) {
+  int reset_r, reset_g, reset_b;
+  int set_r, set_g, set_b;
+  reset_r = FXARGB_R(pPalette[0]);
+  reset_g = FXARGB_G(pPalette[0]);
+  reset_b = FXARGB_B(pPalette[0]);
+  set_r = FXARGB_R(pPalette[1]);
+  set_g = FXARGB_G(pPalette[1]);
+  set_b = FXARGB_B(pPalette[1]);
+  for (int col = 0; col < width; col++) {
+    int src_r, src_g, src_b;
+    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
+      src_r = set_r;
+      src_g = set_g;
+      src_b = set_b;
+    } else {
+      src_r = reset_r;
+      src_g = reset_g;
+      src_b = reset_b;
+    }
+    if (!clip_scan || clip_scan[col] == 255) {
+      *dest_scan++ = src_b;
+      *dest_scan++ = src_g;
+      *dest_scan++ = src_r;
+      *dest_scan++ = 255;
+      continue;
+    }
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      continue;
+    }
+    int back_alpha = dest_scan[3];
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+    dest_scan++;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+    dest_scan++;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+    dest_scan++;
+    dest_scan++;
+  }
+}
+
+void CompositeRow_1bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
+                                       const uint8_t* src_scan,
+                                       int src_left,
+                                       int width,
+                                       uint32_t* pPalette,
+                                       const uint8_t* clip_scan,
+                                       uint8_t* dest_alpha_scan) {
+  int reset_r, reset_g, reset_b;
+  int set_r, set_g, set_b;
+  reset_r = FXARGB_R(pPalette[0]);
+  reset_g = FXARGB_G(pPalette[0]);
+  reset_b = FXARGB_B(pPalette[0]);
+  set_r = FXARGB_R(pPalette[1]);
+  set_g = FXARGB_G(pPalette[1]);
+  set_b = FXARGB_B(pPalette[1]);
+  for (int col = 0; col < width; col++) {
+    int src_r, src_g, src_b;
+    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
+      src_r = set_r;
+      src_g = set_g;
+      src_b = set_b;
+    } else {
+      src_r = reset_r;
+      src_g = reset_g;
+      src_b = reset_b;
+    }
+    if (!clip_scan || clip_scan[col] == 255) {
+      *dest_scan++ = src_b;
+      *dest_scan++ = src_g;
+      *dest_scan++ = src_r;
+      *dest_alpha_scan++ = 255;
+      continue;
+    }
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 0) {
+      dest_scan += 3;
+      dest_alpha_scan++;
+      continue;
+    }
+    int back_alpha = *dest_alpha_scan;
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan++ = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+    dest_scan++;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+    dest_scan++;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+    dest_scan++;
+  }
+}
+
+void CompositeRow_ByteMask2Argb(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int mask_alpha,
+                                int src_r,
+                                int src_g,
+                                int src_b,
+                                int pixel_count,
+                                int blend_type,
+                                const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
+      dest_scan += 4;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, *dest_scan, src_b);
+      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_g);
+      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_r);
+      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+    } else {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+    }
+    dest_scan += 2;
+  }
+}
+
+void CompositeRow_ByteMask2Rgba(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int mask_alpha,
+                                int src_r,
+                                int src_g,
+                                int src_b,
+                                int pixel_count,
+                                int blend_type,
+                                const uint8_t* clip_scan,
+                                uint8_t* dest_alpha_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    uint8_t back_alpha = *dest_alpha_scan;
+    if (back_alpha == 0) {
+      *dest_scan++ = src_b;
+      *dest_scan++ = src_g;
+      *dest_scan++ = src_r;
+      *dest_alpha_scan++ = src_alpha;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += 3;
+      dest_alpha_scan++;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan++ = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
+      dest_scan++;
+    } else if (blend_type) {
+      int blended = Blend(blend_type, *dest_scan, src_b);
+      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_g);
+      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_r);
+      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+    } else {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+      dest_scan++;
+    }
+  }
+}
+
+void CompositeRow_ByteMask2Rgb(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               int mask_alpha,
+                               int src_r,
+                               int src_g,
+                               int src_b,
+                               int pixel_count,
+                               int blend_type,
+                               int Bpp,
+                               const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    if (src_alpha == 0) {
+      dest_scan += Bpp;
+      continue;
+    }
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, *dest_scan, src_b);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_g);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_r);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+    } else {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
+    }
+    dest_scan += Bpp - 2;
+  }
+}
+
+void CompositeRow_ByteMask2Mask(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int mask_alpha,
+                                int pixel_count,
+                                const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    uint8_t back_alpha = *dest_scan;
+    if (!back_alpha) {
+      *dest_scan = src_alpha;
+    } else if (src_alpha) {
+      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    }
+    dest_scan++;
+  }
+}
+
+void CompositeRow_ByteMask2Gray(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int mask_alpha,
+                                int src_gray,
+                                int pixel_count,
+                                const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    if (src_alpha) {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
+    }
+    dest_scan++;
+  }
+}
+
+void CompositeRow_ByteMask2Graya(uint8_t* dest_scan,
+                                 const uint8_t* src_scan,
+                                 int mask_alpha,
+                                 int src_gray,
+                                 int pixel_count,
+                                 const uint8_t* clip_scan,
+                                 uint8_t* dest_alpha_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    uint8_t back_alpha = *dest_alpha_scan;
+    if (back_alpha == 0) {
+      *dest_scan++ = src_gray;
+      *dest_alpha_scan++ = src_alpha;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan++;
+      dest_alpha_scan++;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan++ = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
+    dest_scan++;
+  }
+}
+
+void CompositeRow_BitMask2Argb(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               int mask_alpha,
+                               int src_r,
+                               int src_g,
+                               int src_b,
+                               int src_left,
+                               int pixel_count,
+                               int blend_type,
+                               const uint8_t* clip_scan) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
+    FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
+    for (int col = 0; col < pixel_count; col++) {
+      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
+        FXARGB_SETDIB(dest_scan, argb);
+      }
+      dest_scan += 4;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan += 4;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
+      dest_scan += 4;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
+      dest_scan++;
+      *dest_scan =
+          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, *dest_scan, src_b);
+      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_g);
+      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_r);
+      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
+    } else {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
+    }
+    dest_scan += 2;
+  }
+}
+
+void CompositeRow_BitMask2Rgb(uint8_t* dest_scan,
+                              const uint8_t* src_scan,
+                              int mask_alpha,
+                              int src_r,
+                              int src_g,
+                              int src_b,
+                              int src_left,
+                              int pixel_count,
+                              int blend_type,
+                              int Bpp,
+                              const uint8_t* clip_scan) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
+    for (int col = 0; col < pixel_count; col++) {
+      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
+        dest_scan[2] = src_r;
+        dest_scan[1] = src_g;
+        dest_scan[0] = src_b;
+      }
+      dest_scan += Bpp;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan += Bpp;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    if (src_alpha == 0) {
+      dest_scan += Bpp;
+      continue;
+    }
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, *dest_scan, src_b);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_g);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+      dest_scan++;
+      blended = Blend(blend_type, *dest_scan, src_r);
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
+    } else {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
+      dest_scan++;
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
+    }
+    dest_scan += Bpp - 2;
+  }
+}
+
+void CompositeRow_BitMask2Mask(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               int mask_alpha,
+                               int src_left,
+                               int pixel_count,
+                               const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan++;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    uint8_t back_alpha = *dest_scan;
+    if (!back_alpha) {
+      *dest_scan = src_alpha;
+    } else if (src_alpha) {
+      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    }
+    dest_scan++;
+  }
+}
+
+void CompositeRow_BitMask2Gray(uint8_t* dest_scan,
+                               const uint8_t* src_scan,
+                               int mask_alpha,
+                               int src_gray,
+                               int src_left,
+                               int pixel_count,
+                               const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan++;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    if (src_alpha) {
+      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
+    }
+    dest_scan++;
+  }
+}
+
+void CompositeRow_BitMask2Graya(uint8_t* dest_scan,
+                                const uint8_t* src_scan,
+                                int mask_alpha,
+                                int src_gray,
+                                int src_left,
+                                int pixel_count,
+                                const uint8_t* clip_scan,
+                                uint8_t* dest_alpha_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan++;
+      dest_alpha_scan++;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    uint8_t back_alpha = *dest_alpha_scan;
+    if (back_alpha == 0) {
+      *dest_scan++ = src_gray;
+      *dest_alpha_scan++ = src_alpha;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan++;
+      dest_alpha_scan++;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    *dest_alpha_scan++ = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
+    dest_scan++;
+  }
+}
+
+void CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan,
+                                         const uint8_t* src_scan,
+                                         int pixel_count,
+                                         int blend_type,
+                                         const uint8_t* clip_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  for (int col = 0; col < pixel_count; col++) {
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      if (clip_scan) {
+        int src_alpha = clip_scan[col] * src_scan[3] / 255;
+        dest_scan[3] = src_alpha;
+        dest_scan[0] = src_scan[2];
+        dest_scan[1] = src_scan[1];
+        dest_scan[2] = src_scan[0];
+      } else {
+        FXARGB_RGBORDERCOPY(dest_scan, src_scan);
+      }
+      dest_scan += 4;
+      src_scan += 4;
+      continue;
+    }
+    uint8_t src_alpha;
+    if (clip_scan) {
+      src_alpha = clip_scan[col] * src_scan[3] / 255;
+    } else {
+      src_alpha = src_scan[3];
+    }
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      src_scan += 4;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      if (blend_type) {
+        int blended = bNonseparableBlend
+                          ? blended_colors[color]
+                          : Blend(blend_type, dest_scan[index], *src_scan);
+        blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
+        dest_scan[index] =
+            FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
+      } else {
+        dest_scan[index] =
+            FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
+      }
+      src_scan++;
+    }
+    dest_scan += 4;
+    src_scan++;
+  }
+}
+
+void CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan,
+                                                     const uint8_t* src_scan,
+                                                     int width,
+                                                     int blend_type,
+                                                     int src_Bpp) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      if (src_Bpp == 4) {
+        FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
+      } else {
+        FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2],
+                                                     src_scan[1], src_scan[0]));
+      }
+      dest_scan += 4;
+      src_scan += src_Bpp;
+      continue;
+    }
+    dest_scan[3] = 0xff;
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, dest_scan[index], src_color);
+      dest_scan[index] = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
+      src_scan++;
+    }
+    dest_scan += 4;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Argb2Rgb_Blend_RgbByteOrder(uint8_t* dest_scan,
+                                              const uint8_t* src_scan,
+                                              int width,
+                                              int blend_type,
+                                              int dest_Bpp,
+                                              const uint8_t* clip_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  for (int col = 0; col < width; col++) {
+    uint8_t src_alpha;
+    if (clip_scan) {
+      src_alpha = src_scan[3] * (*clip_scan++) / 255;
+    } else {
+      src_alpha = src_scan[3];
+    }
+    if (src_alpha == 0) {
+      dest_scan += dest_Bpp;
+      src_scan += 4;
+      continue;
+    }
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      int back_color = dest_scan[index];
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, back_color, *src_scan);
+      dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+      src_scan++;
+    }
+    dest_scan += dest_Bpp;
+    src_scan++;
+  }
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan,
+                                                       const uint8_t* src_scan,
+                                                       int width,
+                                                       int src_Bpp) {
+  for (int col = 0; col < width; col++) {
+    if (src_Bpp == 4) {
+      FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
+    } else {
+      FXARGB_SETRGBORDERDIB(
+          dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
+    }
+    dest_scan += 4;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan,
+                                                    const uint8_t* src_scan,
+                                                    int width,
+                                                    int blend_type,
+                                                    int dest_Bpp,
+                                                    int src_Bpp) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      int back_color = dest_scan[index];
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, back_color, src_color);
+      dest_scan[index] = blended;
+      src_scan++;
+    }
+    dest_scan += dest_Bpp;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
+                                                const uint8_t* src_scan,
+                                                int width,
+                                                int dest_Bpp,
+                                                const uint8_t* clip_scan) {
+  for (int col = 0; col < width; col++) {
+    uint8_t src_alpha;
+    if (clip_scan) {
+      src_alpha = src_scan[3] * (*clip_scan++) / 255;
+    } else {
+      src_alpha = src_scan[3];
+    }
+    if (src_alpha == 255) {
+      dest_scan[2] = *src_scan++;
+      dest_scan[1] = *src_scan++;
+      dest_scan[0] = *src_scan++;
+      dest_scan += dest_Bpp;
+      src_scan++;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += dest_Bpp;
+      src_scan += 4;
+      continue;
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      dest_scan[index] =
+          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, src_alpha);
+      src_scan++;
+    }
+    dest_scan += dest_Bpp;
+    src_scan++;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan,
+                                                      const uint8_t* src_scan,
+                                                      int width,
+                                                      int dest_Bpp,
+                                                      int src_Bpp) {
+  for (int col = 0; col < width; col++) {
+    dest_scan[2] = src_scan[0];
+    dest_scan[1] = src_scan[1];
+    dest_scan[0] = src_scan[2];
+    dest_scan += dest_Bpp;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan,
+                                                   const uint8_t* src_scan,
+                                                   int width,
+                                                   int blend_type,
+                                                   int src_Bpp,
+                                                   const uint8_t* clip_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    int src_alpha = *clip_scan++;
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      dest_scan[2] = *src_scan++;
+      dest_scan[1] = *src_scan++;
+      dest_scan[0] = *src_scan++;
+      src_scan += src_gap;
+      dest_scan += 4;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      src_scan += src_Bpp;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      int src_color = *src_scan;
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, dest_scan[index], src_color);
+      blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
+      dest_scan[index] =
+          FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
+      src_scan++;
+    }
+    dest_scan += 4;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan,
+                                                  const uint8_t* src_scan,
+                                                  int width,
+                                                  int blend_type,
+                                                  int dest_Bpp,
+                                                  int src_Bpp,
+                                                  const uint8_t* clip_scan) {
+  int blended_colors[3];
+  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    uint8_t src_alpha = *clip_scan++;
+    if (src_alpha == 0) {
+      dest_scan += dest_Bpp;
+      src_scan += src_Bpp;
+      continue;
+    }
+    if (bNonseparableBlend) {
+      uint8_t dest_scan_o[3];
+      dest_scan_o[0] = dest_scan[2];
+      dest_scan_o[1] = dest_scan[1];
+      dest_scan_o[2] = dest_scan[0];
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+    }
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      int src_color = *src_scan;
+      int back_color = dest_scan[index];
+      int blended = bNonseparableBlend
+                        ? blended_colors[color]
+                        : Blend(blend_type, back_color, src_color);
+      dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+      src_scan++;
+    }
+    dest_scan += dest_Bpp;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan,
+                                                     const uint8_t* src_scan,
+                                                     int width,
+                                                     int src_Bpp,
+                                                     const uint8_t* clip_scan) {
+  int src_gap = src_Bpp - 3;
+  for (int col = 0; col < width; col++) {
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 255) {
+      dest_scan[2] = *src_scan++;
+      dest_scan[1] = *src_scan++;
+      dest_scan[0] = *src_scan++;
+      dest_scan[3] = 255;
+      dest_scan += 4;
+      src_scan += src_gap;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      src_scan += src_Bpp;
+      continue;
+    }
+    int back_alpha = dest_scan[3];
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    for (int color = 0; color < 3; color++) {
+      int index = 2 - color;
+      dest_scan[index] =
+          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
+      src_scan++;
+    }
+    dest_scan += 4;
+    src_scan += src_gap;
+  }
+}
+
+void CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan,
+                                                    const uint8_t* src_scan,
+                                                    int width,
+                                                    int dest_Bpp,
+                                                    int src_Bpp,
+                                                    const uint8_t* clip_scan) {
+  for (int col = 0; col < width; col++) {
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 255) {
+      dest_scan[2] = src_scan[0];
+      dest_scan[1] = src_scan[1];
+      dest_scan[0] = src_scan[2];
+    } else if (src_alpha) {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], *src_scan, src_alpha);
+      src_scan++;
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], *src_scan, src_alpha);
+      src_scan++;
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], *src_scan, src_alpha);
+      dest_scan += dest_Bpp;
+      src_scan += src_Bpp - 2;
+      continue;
+    }
+    dest_scan += dest_Bpp;
+    src_scan += src_Bpp;
+  }
+}
+
+void CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
+                                                   const uint8_t* src_scan,
+                                                   FX_ARGB* pPalette,
+                                                   int pixel_count,
+                                                   int DestBpp,
+                                                   const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    FX_ARGB argb = pPalette ? pPalette[*src_scan] : (*src_scan) * 0x010101;
+    int src_r = FXARGB_R(argb);
+    int src_g = FXARGB_G(argb);
+    int src_b = FXARGB_B(argb);
+    if (clip_scan && clip_scan[col] < 255) {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
+    } else {
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
+    }
+    dest_scan += DestBpp;
+    src_scan++;
+  }
+}
+
+void CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
+                                                   const uint8_t* src_scan,
+                                                   int src_left,
+                                                   FX_ARGB* pPalette,
+                                                   int pixel_count,
+                                                   int DestBpp,
+                                                   const uint8_t* clip_scan) {
+  int reset_r, reset_g, reset_b;
+  int set_r, set_g, set_b;
+  if (pPalette) {
+    reset_r = FXARGB_R(pPalette[0]);
+    reset_g = FXARGB_G(pPalette[0]);
+    reset_b = FXARGB_B(pPalette[0]);
+    set_r = FXARGB_R(pPalette[1]);
+    set_g = FXARGB_G(pPalette[1]);
+    set_b = FXARGB_B(pPalette[1]);
+  } else {
+    reset_r = reset_g = reset_b = 0;
+    set_r = set_g = set_b = 255;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    int src_r, src_g, src_b;
+    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
+      src_r = set_r;
+      src_g = set_g;
+      src_b = set_b;
+    } else {
+      src_r = reset_r;
+      src_g = reset_g;
+      src_b = reset_b;
+    }
+    if (clip_scan && clip_scan[col] < 255) {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
+    } else {
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
+    }
+    dest_scan += DestBpp;
+  }
+}
+
+void CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
+                                                    const uint8_t* src_scan,
+                                                    int width,
+                                                    FX_ARGB* pPalette,
+                                                    const uint8_t* clip_scan) {
+  for (int col = 0; col < width; col++) {
+    int src_r, src_g, src_b;
+    if (pPalette) {
+      FX_ARGB argb = pPalette[*src_scan];
+      src_r = FXARGB_R(argb);
+      src_g = FXARGB_G(argb);
+      src_b = FXARGB_B(argb);
+    } else {
+      src_r = src_g = src_b = *src_scan;
+    }
+    if (!clip_scan || clip_scan[col] == 255) {
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
+      dest_scan[3] = 255;
+      src_scan++;
+      dest_scan += 4;
+      continue;
+    }
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      src_scan++;
+      continue;
+    }
+    int back_alpha = dest_scan[3];
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
+    dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
+    dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
+    dest_scan += 4;
+    src_scan++;
+  }
+}
+
+void CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
+                                                    const uint8_t* src_scan,
+                                                    int src_left,
+                                                    int width,
+                                                    FX_ARGB* pPalette,
+                                                    const uint8_t* clip_scan) {
+  int reset_r, reset_g, reset_b;
+  int set_r, set_g, set_b;
+  if (pPalette) {
+    reset_r = FXARGB_R(pPalette[0]);
+    reset_g = FXARGB_G(pPalette[0]);
+    reset_b = FXARGB_B(pPalette[0]);
+    set_r = FXARGB_R(pPalette[1]);
+    set_g = FXARGB_G(pPalette[1]);
+    set_b = FXARGB_B(pPalette[1]);
+  } else {
+    reset_r = reset_g = reset_b = 0;
+    set_r = set_g = set_b = 255;
+  }
+  for (int col = 0; col < width; col++) {
+    int src_r, src_g, src_b;
+    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
+      src_r = set_r;
+      src_g = set_g;
+      src_b = set_b;
+    } else {
+      src_r = reset_r;
+      src_g = reset_g;
+      src_b = reset_b;
+    }
+    if (!clip_scan || clip_scan[col] == 255) {
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
+      dest_scan[3] = 255;
+      dest_scan += 4;
+      continue;
+    }
+    int src_alpha = clip_scan[col];
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      continue;
+    }
+    int back_alpha = dest_scan[3];
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
+    dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
+    dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
+    dest_scan += 4;
+  }
+}
+
+void CompositeRow_ByteMask2Argb_RgbByteOrder(uint8_t* dest_scan,
+                                             const uint8_t* src_scan,
+                                             int mask_alpha,
+                                             int src_r,
+                                             int src_g,
+                                             int src_b,
+                                             int pixel_count,
+                                             int blend_type,
+                                             const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      FXARGB_SETRGBORDERDIB(dest_scan,
+                            FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
+      dest_scan += 4;
+      continue;
+    }
+    if (src_alpha == 0) {
+      dest_scan += 4;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
+      dest_scan[2] =
+          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
+      dest_scan[1] =
+          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
+      dest_scan[0] =
+          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, dest_scan[2], src_b);
+      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
+      blended = Blend(blend_type, dest_scan[1], src_g);
+      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio);
+      blended = Blend(blend_type, dest_scan[0], src_r);
+      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
+    } else {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
+    }
+    dest_scan += 4;
+  }
+}
+
+void CompositeRow_ByteMask2Rgb_RgbByteOrder(uint8_t* dest_scan,
+                                            const uint8_t* src_scan,
+                                            int mask_alpha,
+                                            int src_r,
+                                            int src_g,
+                                            int src_b,
+                                            int pixel_count,
+                                            int blend_type,
+                                            int Bpp,
+                                            const uint8_t* clip_scan) {
+  for (int col = 0; col < pixel_count; col++) {
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
+    } else {
+      src_alpha = mask_alpha * src_scan[col] / 255;
+    }
+    if (src_alpha == 0) {
+      dest_scan += Bpp;
+      continue;
+    }
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
+      dest_scan[2] =
+          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
+      dest_scan[1] =
+          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
+      dest_scan[0] =
+          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, dest_scan[2], src_b);
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, src_alpha);
+      blended = Blend(blend_type, dest_scan[1], src_g);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, src_alpha);
+      blended = Blend(blend_type, dest_scan[0], src_r);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, src_alpha);
+    } else {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
+    }
+    dest_scan += Bpp;
+  }
+}
+
+void CompositeRow_BitMask2Argb_RgbByteOrder(uint8_t* dest_scan,
+                                            const uint8_t* src_scan,
+                                            int mask_alpha,
+                                            int src_r,
+                                            int src_g,
+                                            int src_b,
+                                            int src_left,
+                                            int pixel_count,
+                                            int blend_type,
+                                            const uint8_t* clip_scan) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
+    FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
+    for (int col = 0; col < pixel_count; col++) {
+      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
+        FXARGB_SETRGBORDERDIB(dest_scan, argb);
+      }
+      dest_scan += 4;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan += 4;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    uint8_t back_alpha = dest_scan[3];
+    if (back_alpha == 0) {
+      FXARGB_SETRGBORDERDIB(dest_scan,
+                            FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
+      dest_scan += 4;
+      continue;
+    }
+    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+    dest_scan[3] = dest_alpha;
+    int alpha_ratio = src_alpha * 255 / dest_alpha;
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
+      dest_scan[2] =
+          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
+      dest_scan[1] =
+          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
+      dest_scan[0] =
+          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
+    } else if (blend_type) {
+      int blended = Blend(blend_type, dest_scan[2], src_b);
+      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
+      blended = Blend(blend_type, dest_scan[1], src_g);
+      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio);
+      blended = Blend(blend_type, dest_scan[0], src_r);
+      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
+    } else {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
+    }
+    dest_scan += 4;
+  }
+}
+
+void CompositeRow_BitMask2Rgb_RgbByteOrder(uint8_t* dest_scan,
+                                           const uint8_t* src_scan,
+                                           int mask_alpha,
+                                           int src_r,
+                                           int src_g,
+                                           int src_b,
+                                           int src_left,
+                                           int pixel_count,
+                                           int blend_type,
+                                           int Bpp,
+                                           const uint8_t* clip_scan) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
+    for (int col = 0; col < pixel_count; col++) {
+      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
+        dest_scan[2] = src_b;
+        dest_scan[1] = src_g;
+        dest_scan[0] = src_r;
+      }
+      dest_scan += Bpp;
+    }
+    return;
+  }
+  for (int col = 0; col < pixel_count; col++) {
+    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
+      dest_scan += Bpp;
+      continue;
+    }
+    int src_alpha;
+    if (clip_scan) {
+      src_alpha = mask_alpha * clip_scan[col] / 255;
+    } else {
+      src_alpha = mask_alpha;
+    }
+    if (src_alpha == 0) {
+      dest_scan += Bpp;
+      continue;
+    }
+    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
+      int blended_colors[3];
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
+      dest_scan[2] =
+          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
+      dest_scan[1] =
+          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
+      dest_scan[0] =
+          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
+    } else if (blend_type) {
+      int back_color = dest_scan[2];
+      int blended = Blend(blend_type, back_color, src_b);
+      dest_scan[2] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+      back_color = dest_scan[1];
+      blended = Blend(blend_type, back_color, src_g);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+      back_color = dest_scan[0];
+      blended = Blend(blend_type, back_color, src_r);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
+    } else {
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
+    }
+    dest_scan += Bpp;
+  }
+}
+
+bool ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
+                                       int alpha_flag,
+                                       uint32_t mask_color,
+                                       int& mask_alpha,
+                                       int& mask_red,
+                                       int& mask_green,
+                                       int& mask_blue,
+                                       int& mask_black,
+                                       CCodec_IccModule* pIccModule,
+                                       void* pIccTransform) {
+  if (alpha_flag >> 8) {
+    mask_alpha = alpha_flag & 0xff;
+    mask_red = FXSYS_GetCValue(mask_color);
+    mask_green = FXSYS_GetMValue(mask_color);
+    mask_blue = FXSYS_GetYValue(mask_color);
+    mask_black = FXSYS_GetKValue(mask_color);
+  } else {
+    mask_alpha = FXARGB_A(mask_color);
+    mask_red = FXARGB_R(mask_color);
+    mask_green = FXARGB_G(mask_color);
+    mask_blue = FXARGB_B(mask_color);
+  }
+  if (dest_format == FXDIB_8bppMask) {
+    return true;
+  }
+  if ((dest_format & 0xff) == 8) {
+    if (pIccTransform) {
+      mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color)
+                                     : FXARGB_TODIB(mask_color);
+      uint8_t* gray_p = (uint8_t*)&mask_color;
+      pIccModule->TranslateScanline(pIccTransform, gray_p, gray_p, 1);
+      mask_red = dest_format & 0x0400 ? FX_CCOLOR(gray_p[0]) : gray_p[0];
+    } else {
+      if (alpha_flag >> 8) {
+        uint8_t r, g, b;
+        AdobeCMYK_to_sRGB1(mask_red, mask_green, mask_blue, mask_black, r, g,
+                           b);
+        mask_red = FXRGB2GRAY(r, g, b);
+      } else {
+        mask_red = FXRGB2GRAY(mask_red, mask_green, mask_blue);
+      }
+      if (dest_format & 0x0400) {
+        mask_red = FX_CCOLOR(mask_red);
+      }
+    }
+  } else {
+    uint8_t* mask_color_p = (uint8_t*)&mask_color;
+    mask_color =
+        (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color);
+    if (pIccTransform) {
+      pIccModule->TranslateScanline(pIccTransform, mask_color_p, mask_color_p,
+                                    1);
+      mask_red = mask_color_p[2];
+      mask_green = mask_color_p[1];
+      mask_blue = mask_color_p[0];
+    } else if (alpha_flag >> 8) {
+      AdobeCMYK_to_sRGB1(mask_color_p[0], mask_color_p[1], mask_color_p[2],
+                         mask_color_p[3], mask_color_p[2], mask_color_p[1],
+                         mask_color_p[0]);
+      mask_red = mask_color_p[2];
+      mask_green = mask_color_p[1];
+      mask_blue = mask_color_p[0];
+    }
+  }
+  return true;
+}
+
+void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
+                                          FXDIB_Format dest_format,
+                                          uint32_t*& pDestPalette,
+                                          uint32_t* pSrcPalette,
+                                          CCodec_IccModule* pIccModule,
+                                          void* pIccTransform) {
+  bool isSrcCmyk = !!(src_format & 0x0400);
+  bool isDstCmyk = !!(dest_format & 0x0400);
+  pDestPalette = nullptr;
+  if (pIccTransform) {
+    if (pSrcPalette) {
+      if ((dest_format & 0xff) == 8) {
+        int pal_count = 1 << (src_format & 0xff);
+        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
+        pDestPalette = (uint32_t*)gray_pal;
+        for (int i = 0; i < pal_count; i++) {
+          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
+                                     : FXARGB_TODIB(pSrcPalette[i]);
+          pIccModule->TranslateScanline(pIccTransform, gray_pal,
+                                        (const uint8_t*)&color, 1);
+          gray_pal++;
+        }
+      } else {
+        int palsize = 1 << (src_format & 0xff);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
+        for (int i = 0; i < palsize; i++) {
+          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
+                                     : FXARGB_TODIB(pSrcPalette[i]);
+          pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color,
+                                        (const uint8_t*)&color, 1);
+          pDestPalette[i] =
+              isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
+        }
+      }
+    } else {
+      int pal_count = 1 << (src_format & 0xff);
+      uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
+      if (pal_count == 2) {
+        gray_pal[0] = 0;
+        gray_pal[1] = 255;
+      } else {
+        for (int i = 0; i < pal_count; i++) {
+          gray_pal[i] = i;
+        }
+      }
+      if ((dest_format & 0xff) == 8) {
+        pIccModule->TranslateScanline(pIccTransform, gray_pal, gray_pal,
+                                      pal_count);
+        pDestPalette = (uint32_t*)gray_pal;
+      } else {
+        pDestPalette = FX_Alloc(uint32_t, pal_count);
+        for (int i = 0; i < pal_count; i++) {
+          pIccModule->TranslateScanline(
+              pIccTransform, (uint8_t*)&pDestPalette[i], &gray_pal[i], 1);
+          pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(pDestPalette[i])
+                                      : FXARGB_TODIB(pDestPalette[i]);
+        }
+        FX_Free(gray_pal);
+      }
+    }
+  } else {
+    if (pSrcPalette) {
+      if ((dest_format & 0xff) == 8) {
+        int pal_count = 1 << (src_format & 0xff);
+        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
+        pDestPalette = (uint32_t*)gray_pal;
+        if (isSrcCmyk) {
+          for (int i = 0; i < pal_count; i++) {
+            FX_CMYK cmyk = pSrcPalette[i];
+            uint8_t r, g, b;
+            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
+                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
+                               g, b);
+            *gray_pal++ = FXRGB2GRAY(r, g, b);
+          }
+        } else {
+          for (int i = 0; i < pal_count; i++) {
+            FX_ARGB argb = pSrcPalette[i];
+            *gray_pal++ =
+                FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
+          }
+        }
+      } else {
+        int palsize = 1 << (src_format & 0xff);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
+        if (isDstCmyk == isSrcCmyk) {
+          FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t));
+        } else {
+          for (int i = 0; i < palsize; i++) {
+            FX_CMYK cmyk = pSrcPalette[i];
+            uint8_t r, g, b;
+            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
+                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
+                               g, b);
+            pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
+          }
+        }
+      }
+    } else {
+      if ((dest_format & 0xff) == 8) {
+        int pal_count = 1 << (src_format & 0xff);
+        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
+        if (pal_count == 2) {
+          gray_pal[0] = 0;
+          gray_pal[1] = 255;
+        } else {
+          for (int i = 0; i < pal_count; i++) {
+            gray_pal[i] = i;
+          }
+        }
+        pDestPalette = (uint32_t*)gray_pal;
+      } else {
+        int palsize = 1 << (src_format & 0xff);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
+        if (palsize == 2) {
+          pDestPalette[0] = isSrcCmyk ? 255 : 0xff000000;
+          pDestPalette[1] = isSrcCmyk ? 0 : 0xffffffff;
+        } else {
+          for (int i = 0; i < palsize; i++) {
+            pDestPalette[i] = isSrcCmyk ? FX_CCOLOR(i) : (i * 0x10101);
+          }
+        }
+        if (isSrcCmyk != isDstCmyk) {
+          for (int i = 0; i < palsize; i++) {
+            FX_CMYK cmyk = pDestPalette[i];
+            uint8_t r, g, b;
+            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
+                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
+                               g, b);
+            pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
+          }
+        }
+      }
+    }
+  }
+}
+
+}  // namespace
+
+CFX_ScanlineCompositor::CFX_ScanlineCompositor() {
+  m_pSrcPalette = nullptr;
+  m_pCacheScanline = nullptr;
+  m_CacheSize = 0;
+  m_bRgbByteOrder = false;
+  m_BlendType = FXDIB_BLEND_NORMAL;
+  m_pIccTransform = nullptr;
+}
+
+CFX_ScanlineCompositor::~CFX_ScanlineCompositor() {
+  FX_Free(m_pSrcPalette);
+  FX_Free(m_pCacheScanline);
+}
+
+bool CFX_ScanlineCompositor::Init(FXDIB_Format dest_format,
+                                  FXDIB_Format src_format,
+                                  int32_t width,
+                                  uint32_t* pSrcPalette,
+                                  uint32_t mask_color,
+                                  int blend_type,
+                                  bool bClip,
+                                  bool bRgbByteOrder,
+                                  int alpha_flag,
+                                  void* pIccTransform) {
+  m_SrcFormat = src_format;
+  m_DestFormat = dest_format;
+  m_BlendType = blend_type;
+  m_bRgbByteOrder = bRgbByteOrder;
+  CCodec_IccModule* pIccModule = nullptr;
+  if (CFX_GEModule::Get()->GetCodecModule()) {
+    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+  }
+  if (!pIccModule) {
+    pIccTransform = nullptr;
+  }
+  m_pIccTransform = pIccTransform;
+  if ((dest_format & 0xff) == 1) {
+    return false;
+  }
+  if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
+    return ScanlineCompositor_InitSourceMask(
+        dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed,
+        m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform);
+  }
+  if (!pIccTransform && (~src_format & 0x0400) && (dest_format & 0x0400)) {
+    return false;
+  }
+  if ((m_SrcFormat & 0xff) <= 8) {
+    if (dest_format == FXDIB_8bppMask) {
+      return true;
+    }
+    ScanlineCompositor_InitSourcePalette(src_format, dest_format, m_pSrcPalette,
+                                         pSrcPalette, pIccModule,
+                                         pIccTransform);
+    m_Transparency =
+        (dest_format == FXDIB_Argb ? 1 : 0) + (dest_format & 0x0200 ? 2 : 0) +
+        (dest_format & 0x0400 ? 4 : 0) + ((src_format & 0xff) == 1 ? 8 : 0);
+    return true;
+  }
+  m_Transparency = (src_format & 0x0200 ? 0 : 1) +
+                   (dest_format & 0x0200 ? 0 : 2) +
+                   (blend_type == FXDIB_BLEND_NORMAL ? 4 : 0) +
+                   (bClip ? 8 : 0) + (src_format & 0x0400 ? 16 : 0) +
+                   (dest_format & 0x0400 ? 32 : 0) + (pIccTransform ? 64 : 0);
+  return true;
+}
+
+void CFX_ScanlineCompositor::CompositeRgbBitmapLine(
+    uint8_t* dest_scan,
+    const uint8_t* src_scan,
+    int width,
+    const uint8_t* clip_scan,
+    const uint8_t* src_extra_alpha,
+    uint8_t* dst_extra_alpha) {
+  int src_Bpp = (m_SrcFormat & 0xff) >> 3;
+  int dest_Bpp = (m_DestFormat & 0xff) >> 3;
+  if (m_bRgbByteOrder) {
+    switch (m_Transparency) {
+      case 0:
+      case 4:
+      case 8:
+      case 12:
+        CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width,
+                                            m_BlendType, clip_scan);
+        break;
+      case 1:
+        CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(
+            dest_scan, src_scan, width, m_BlendType, src_Bpp);
+        break;
+      case 2:
+      case 10:
+        CompositeRow_Argb2Rgb_Blend_RgbByteOrder(
+            dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan);
+        break;
+      case 3:
+        CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(
+            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp);
+        break;
+      case 5:
+        CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(dest_scan, src_scan,
+                                                          width, src_Bpp);
+        break;
+      case 6:
+      case 14:
+        CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, width,
+                                                   dest_Bpp, clip_scan);
+        break;
+      case 7:
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
+            dest_scan, src_scan, width, dest_Bpp, src_Bpp);
+        break;
+      case 9:
+        CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(
+            dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan);
+        break;
+      case 11:
+        CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(dest_scan, src_scan, width,
+                                                     m_BlendType, dest_Bpp,
+                                                     src_Bpp, clip_scan);
+        break;
+      case 13:
+        CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(
+            dest_scan, src_scan, width, src_Bpp, clip_scan);
+        break;
+      case 15:
+        CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(
+            dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan);
+        break;
+    }
+    return;
+  }
+  if (m_DestFormat == FXDIB_8bppMask) {
+    if (m_SrcFormat & 0x0200) {
+      if (m_SrcFormat == FXDIB_Argb) {
+        CompositeRow_AlphaToMask(dest_scan, src_scan, width, clip_scan, 4);
+      } else {
+        CompositeRow_AlphaToMask(dest_scan, src_extra_alpha, width, clip_scan,
+                                 1);
+      }
+    } else {
+      CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+    }
+  } else if ((m_DestFormat & 0xff) == 8) {
+    if (m_DestFormat & 0x0400) {
+      for (int i = 0; i < width; i++) {
+        *dest_scan = ~*dest_scan;
+        dest_scan++;
+      }
+    }
+    if (m_SrcFormat & 0x0200) {
+      if (m_DestFormat & 0x0200) {
+        CompositeRow_Argb2Graya(dest_scan, src_scan, width, m_BlendType,
+                                clip_scan, src_extra_alpha, dst_extra_alpha,
+                                m_pIccTransform);
+      } else {
+        CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType,
+                               clip_scan, src_extra_alpha, m_pIccTransform);
+      }
+    } else {
+      if (m_DestFormat & 0x0200) {
+        CompositeRow_Rgb2Graya(dest_scan, src_scan, src_Bpp, width, m_BlendType,
+                               clip_scan, dst_extra_alpha, m_pIccTransform);
+      } else {
+        CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType,
+                              clip_scan, m_pIccTransform);
+      }
+    }
+    if (m_DestFormat & 0x0400) {
+      for (int i = 0; i < width; i++) {
+        *dest_scan = ~*dest_scan;
+        dest_scan++;
+      }
+    }
+  } else {
+    int dest_Size = width * dest_Bpp + 4;
+    if (dest_Size > m_CacheSize) {
+      m_pCacheScanline = FX_Realloc(uint8_t, m_pCacheScanline, dest_Size);
+      if (!m_pCacheScanline) {
+        return;
+      }
+      m_CacheSize = dest_Size;
+    }
+    switch (m_Transparency) {
+      case 0:
+      case 4:
+      case 8:
+      case 4 + 8: {
+        CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType,
+                               clip_scan, dst_extra_alpha, src_extra_alpha);
+      } break;
+      case 64:
+      case 4 + 64:
+      case 8 + 64:
+      case 4 + 8 + 64: {
+        CompositeRow_Argb2Argb_Transform(
+            dest_scan, src_scan, width, m_BlendType, clip_scan, dst_extra_alpha,
+            src_extra_alpha, m_pCacheScanline, m_pIccTransform);
+      } break;
+      case 1:
+        CompositeRow_Rgb2Argb_Blend_NoClip(
+            dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha);
+        break;
+      case 1 + 64:
+        CompositeRow_Rgb2Argb_Blend_NoClip_Transform(
+            dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 8:
+        CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan, width,
+                                         m_BlendType, src_Bpp, clip_scan,
+                                         dst_extra_alpha);
+        break;
+      case 1 + 8 + 64:
+        CompositeRow_Rgb2Argb_Blend_Clip_Transform(
+            dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan,
+            dst_extra_alpha, m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 4:
+        CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width,
+                                             src_Bpp, dst_extra_alpha);
+        break;
+      case 1 + 4 + 64:
+        CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(
+            dest_scan, src_scan, width, src_Bpp, dst_extra_alpha,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 4 + 8:
+        CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan, width, src_Bpp,
+                                           clip_scan, dst_extra_alpha);
+        break;
+      case 1 + 4 + 8 + 64:
+        CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(
+            dest_scan, src_scan, width, src_Bpp, clip_scan, dst_extra_alpha,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+      case 2:
+      case 2 + 8:
+        CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan, width, m_BlendType,
+                                    dest_Bpp, clip_scan, src_extra_alpha);
+        break;
+      case 2 + 64:
+      case 2 + 8 + 64:
+        CompositeRow_Argb2Rgb_Blend_Transform(
+            dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan,
+            src_extra_alpha, m_pCacheScanline, m_pIccTransform);
+        break;
+      case 2 + 4:
+      case 2 + 4 + 8:
+        CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan, width, dest_Bpp,
+                                      clip_scan, src_extra_alpha);
+        break;
+      case 2 + 4 + 64:
+      case 2 + 4 + 8 + 64:
+        CompositeRow_Argb2Rgb_NoBlend_Transform(
+            dest_scan, src_scan, width, dest_Bpp, clip_scan, src_extra_alpha,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 2:
+        CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan, width,
+                                          m_BlendType, dest_Bpp, src_Bpp);
+        break;
+      case 1 + 2 + 64:
+        CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(
+            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 2 + 8:
+        CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_scan, width, m_BlendType,
+                                        dest_Bpp, src_Bpp, clip_scan);
+        break;
+      case 1 + 2 + 8 + 64:
+        CompositeRow_Rgb2Rgb_Blend_Clip_Transform(
+            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp,
+            clip_scan, m_pCacheScanline, m_pIccTransform);
+        break;
+      case 1 + 2 + 4:
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan, width,
+                                            dest_Bpp, src_Bpp);
+        break;
+      case 1 + 2 + 4 + 64:
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(
+            dest_scan, src_scan, width, dest_Bpp, src_Bpp, m_pCacheScanline,
+            m_pIccTransform);
+        break;
+      case 1 + 2 + 4 + 8:
+        CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan, width, dest_Bpp,
+                                          src_Bpp, clip_scan);
+        break;
+      case 1 + 2 + 4 + 8 + 64:
+        CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(
+            dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan,
+            m_pCacheScanline, m_pIccTransform);
+        break;
+    }
+  }
+}
+
+void CFX_ScanlineCompositor::CompositePalBitmapLine(
+    uint8_t* dest_scan,
+    const uint8_t* src_scan,
+    int src_left,
+    int width,
+    const uint8_t* clip_scan,
+    const uint8_t* src_extra_alpha,
+    uint8_t* dst_extra_alpha) {
+  if (m_bRgbByteOrder) {
+    if (m_SrcFormat == FXDIB_1bppRgb) {
+      if (m_DestFormat == FXDIB_8bppRgb) {
+        return;
+      }
+      if (m_DestFormat == FXDIB_Argb) {
+        CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
+            dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan);
+      } else {
+        CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(
+            dest_scan, src_scan, src_left, m_pSrcPalette, width,
+            (m_DestFormat & 0xff) >> 3, clip_scan);
+      }
+    } else {
+      if (m_DestFormat == FXDIB_8bppRgb) {
+        return;
+      }
+      if (m_DestFormat == FXDIB_Argb) {
+        CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
+            dest_scan, src_scan, width, m_pSrcPalette, clip_scan);
+      } else {
+        CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(
+            dest_scan, src_scan, m_pSrcPalette, width,
+            (m_DestFormat & 0xff) >> 3, clip_scan);
+      }
+    }
+    return;
+  }
+  if (m_DestFormat == FXDIB_8bppMask) {
+    CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+    return;
+  }
+  if ((m_DestFormat & 0xff) == 8) {
+    if (m_Transparency & 8) {
+      if (m_DestFormat & 0x0200) {
+        CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left,
+                                   (const uint8_t*)m_pSrcPalette, width,
+                                   m_BlendType, clip_scan, dst_extra_alpha);
+      } else {
+        CompositeRow_1bppPal2Gray(dest_scan, src_scan, src_left,
+                                  (const uint8_t*)m_pSrcPalette, width,
+                                  m_BlendType, clip_scan);
+      }
+    } else {
+      if (m_DestFormat & 0x0200)
+        CompositeRow_8bppPal2Graya(
+            dest_scan, src_scan, (const uint8_t*)m_pSrcPalette, width,
+            m_BlendType, clip_scan, dst_extra_alpha, src_extra_alpha);
+      else
+        CompositeRow_8bppPal2Gray(dest_scan, src_scan,
+                                  (const uint8_t*)m_pSrcPalette, width,
+                                  m_BlendType, clip_scan, src_extra_alpha);
+    }
+  } else {
+    switch (m_Transparency) {
+      case 1 + 2:
+        CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width,
+                                          m_pSrcPalette, clip_scan,
+                                          src_extra_alpha);
+        break;
+      case 1 + 2 + 8:
+        CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width,
+                                          m_pSrcPalette, clip_scan);
+        break;
+      case 0:
+        CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette,
+                                         width, (m_DestFormat & 0xff) >> 3,
+                                         clip_scan, src_extra_alpha);
+        break;
+      case 0 + 8:
+        CompositeRow_1bppRgb2Rgb_NoBlend(dest_scan, src_scan, src_left,
+                                         m_pSrcPalette, width,
+                                         (m_DestFormat & 0xff) >> 3, clip_scan);
+        break;
+      case 0 + 2:
+        CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette,
+                                         width, (m_DestFormat & 0xff) >> 3,
+                                         clip_scan, src_extra_alpha);
+        break;
+      case 0 + 2 + 8:
+        CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width,
+                                          m_pSrcPalette, clip_scan,
+                                          dst_extra_alpha);
+        break;
+        break;
+    }
+  }
+}
+
+void CFX_ScanlineCompositor::CompositeByteMaskLine(uint8_t* dest_scan,
+                                                   const uint8_t* src_scan,
+                                                   int width,
+                                                   const uint8_t* clip_scan,
+                                                   uint8_t* dst_extra_alpha) {
+  if (m_DestFormat == FXDIB_8bppMask) {
+    CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width,
+                               clip_scan);
+  } else if ((m_DestFormat & 0xff) == 8) {
+    if (m_DestFormat & 0x0200) {
+      CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                                  width, clip_scan, dst_extra_alpha);
+    } else {
+      CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                                 width, clip_scan);
+    }
+  } else if (m_bRgbByteOrder) {
+    if (m_DestFormat == FXDIB_Argb) {
+      CompositeRow_ByteMask2Argb_RgbByteOrder(
+          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
+          width, m_BlendType, clip_scan);
+    } else {
+      CompositeRow_ByteMask2Rgb_RgbByteOrder(
+          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
+          width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+    }
+    return;
+  } else if (m_DestFormat == FXDIB_Argb) {
+    CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
+                               clip_scan);
+  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
+    CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                              m_MaskGreen, m_MaskBlue, width, m_BlendType,
+                              (m_DestFormat & 0xff) >> 3, clip_scan);
+  } else if (m_DestFormat == FXDIB_Rgba) {
+    CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
+                               clip_scan, dst_extra_alpha);
+  }
+}
+
+void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan,
+                                                  const uint8_t* src_scan,
+                                                  int src_left,
+                                                  int width,
+                                                  const uint8_t* clip_scan,
+                                                  uint8_t* dst_extra_alpha) {
+  if (m_DestFormat == FXDIB_8bppMask) {
+    CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width,
+                              clip_scan);
+  } else if ((m_DestFormat & 0xff) == 8) {
+    if (m_DestFormat & 0x0200) {
+      CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                                 src_left, width, clip_scan, dst_extra_alpha);
+    } else {
+      CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                                src_left, width, clip_scan);
+    }
+  } else if (m_bRgbByteOrder) {
+    if (m_DestFormat == FXDIB_Argb) {
+      CompositeRow_BitMask2Argb_RgbByteOrder(
+          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
+          src_left, width, m_BlendType, clip_scan);
+    } else {
+      CompositeRow_BitMask2Rgb_RgbByteOrder(
+          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
+          src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+    }
+    return;
+  } else if (m_DestFormat == FXDIB_Argb) {
+    CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+                              m_MaskGreen, m_MaskBlue, src_left, width,
+                              m_BlendType, clip_scan);
+  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
+    CompositeRow_BitMask2Rgb(
+        dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
+        src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+  }
+}
diff --git a/core/fxge/dib/cfx_scanlinecompositor.h b/core/fxge/dib/cfx_scanlinecompositor.h
new file mode 100644
index 0000000000..2401bc5da8
--- /dev/null
+++ b/core/fxge/dib/cfx_scanlinecompositor.h
@@ -0,0 +1,74 @@
+// Copyright 2017 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
+
+#ifndef CORE_FXGE_DIB_CFX_SCANLINECOMPOSITOR_H_
+#define CORE_FXGE_DIB_CFX_SCANLINECOMPOSITOR_H_
+
+#include "core/fxge/dib/cfx_dibsource.h"
+
+class CFX_ScanlineCompositor {
+ public:
+  CFX_ScanlineCompositor();
+
+  ~CFX_ScanlineCompositor();
+
+  bool Init(FXDIB_Format dest_format,
+            FXDIB_Format src_format,
+            int32_t width,
+            uint32_t* pSrcPalette,
+            uint32_t mask_color,
+            int blend_type,
+            bool bClip,
+            bool bRgbByteOrder = false,
+            int alpha_flag = 0,
+            void* pIccTransform = nullptr);
+
+  void CompositeRgbBitmapLine(uint8_t* dest_scan,
+                              const uint8_t* src_scan,
+                              int width,
+                              const uint8_t* clip_scan,
+                              const uint8_t* src_extra_alpha = nullptr,
+                              uint8_t* dst_extra_alpha = nullptr);
+
+  void CompositePalBitmapLine(uint8_t* dest_scan,
+                              const uint8_t* src_scan,
+                              int src_left,
+                              int width,
+                              const uint8_t* clip_scan,
+                              const uint8_t* src_extra_alpha = nullptr,
+                              uint8_t* dst_extra_alpha = nullptr);
+
+  void CompositeByteMaskLine(uint8_t* dest_scan,
+                             const uint8_t* src_scan,
+                             int width,
+                             const uint8_t* clip_scan,
+                             uint8_t* dst_extra_alpha = nullptr);
+
+  void CompositeBitMaskLine(uint8_t* dest_scan,
+                            const uint8_t* src_scan,
+                            int src_left,
+                            int width,
+                            const uint8_t* clip_scan,
+                            uint8_t* dst_extra_alpha = nullptr);
+
+ private:
+  int m_Transparency;
+  FXDIB_Format m_SrcFormat;
+  FXDIB_Format m_DestFormat;
+  uint32_t* m_pSrcPalette;
+  int m_MaskAlpha;
+  int m_MaskRed;
+  int m_MaskGreen;
+  int m_MaskBlue;
+  int m_MaskBlack;
+  int m_BlendType;
+  void* m_pIccTransform;
+  uint8_t* m_pCacheScanline;
+  int m_CacheSize;
+  bool m_bRgbByteOrder;
+};
+
+#endif  // CORE_FXGE_DIB_CFX_SCANLINECOMPOSITOR_H_
diff --git a/core/fxge/dib/fx_dib_composite.cpp b/core/fxge/dib/fx_dib_composite.cpp
index fb00cb855b..86be539008 100644
--- a/core/fxge/dib/fx_dib_composite.cpp
+++ b/core/fxge/dib/fx_dib_composite.cpp
@@ -8,3912 +8,8 @@
 
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxge/cfx_gemodule.h"
-#include "core/fxge/dib/dib_int.h"
 #include "core/fxge/ge/cfx_cliprgn.h"
 
-namespace {
-
-const uint8_t color_sqrt[256] = {
-    0x00, 0x03, 0x07, 0x0B, 0x0F, 0x12, 0x16, 0x19, 0x1D, 0x20, 0x23, 0x26,
-    0x29, 0x2C, 0x2F, 0x32, 0x35, 0x37, 0x3A, 0x3C, 0x3F, 0x41, 0x43, 0x46,
-    0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x57, 0x59, 0x5B, 0x5C,
-    0x5E, 0x60, 0x61, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D,
-    0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
-    0x7B, 0x7C, 0x7D, 0x7E, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
-    0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x91,
-    0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C,
-    0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5,
-    0xA6, 0xA7, 0xA7, 0xA8, 0xA9, 0xAA, 0xAA, 0xAB, 0xAC, 0xAD, 0xAD, 0xAE,
-    0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7,
-    0xB7, 0xB8, 0xB9, 0xBA, 0xBA, 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBE, 0xBF,
-    0xC0, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4, 0xC4, 0xC5, 0xC6, 0xC6, 0xC7,
-    0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCE,
-    0xCF, 0xD0, 0xD0, 0xD1, 0xD1, 0xD2, 0xD3, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6,
-    0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xD9, 0xDA, 0xDA, 0xDB, 0xDC, 0xDC, 0xDD,
-    0xDD, 0xDE, 0xDE, 0xDF, 0xE0, 0xE0, 0xE1, 0xE1, 0xE2, 0xE2, 0xE3, 0xE4,
-    0xE4, 0xE5, 0xE5, 0xE6, 0xE6, 0xE7, 0xE7, 0xE8, 0xE9, 0xE9, 0xEA, 0xEA,
-    0xEB, 0xEB, 0xEC, 0xEC, 0xED, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF0, 0xF1,
-    0xF1, 0xF2, 0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF6, 0xF7,
-    0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFD,
-    0xFD, 0xFE, 0xFE, 0xFF};
-
-int Blend(int blend_mode, int back_color, int src_color) {
-  switch (blend_mode) {
-    case FXDIB_BLEND_NORMAL:
-      return src_color;
-    case FXDIB_BLEND_MULTIPLY:
-      return src_color * back_color / 255;
-    case FXDIB_BLEND_SCREEN:
-      return src_color + back_color - src_color * back_color / 255;
-    case FXDIB_BLEND_OVERLAY:
-      return Blend(FXDIB_BLEND_HARDLIGHT, src_color, back_color);
-    case FXDIB_BLEND_DARKEN:
-      return src_color < back_color ? src_color : back_color;
-    case FXDIB_BLEND_LIGHTEN:
-      return src_color > back_color ? src_color : back_color;
-    case FXDIB_BLEND_COLORDODGE: {
-      if (src_color == 255)
-        return src_color;
-
-      return std::min(back_color * 255 / (255 - src_color), 255);
-    }
-    case FXDIB_BLEND_COLORBURN: {
-      if (src_color == 0)
-        return src_color;
-
-      return 255 - std::min((255 - back_color) * 255 / src_color, 255);
-    }
-    case FXDIB_BLEND_HARDLIGHT:
-      if (src_color < 128)
-        return (src_color * back_color * 2) / 255;
-
-      return Blend(FXDIB_BLEND_SCREEN, back_color, 2 * src_color - 255);
-    case FXDIB_BLEND_SOFTLIGHT: {
-      if (src_color < 128) {
-        return back_color -
-               (255 - 2 * src_color) * back_color * (255 - back_color) / 255 /
-                   255;
-      }
-      return back_color +
-             (2 * src_color - 255) * (color_sqrt[back_color] - back_color) /
-                 255;
-    }
-    case FXDIB_BLEND_DIFFERENCE:
-      return back_color < src_color ? src_color - back_color
-                                    : back_color - src_color;
-    case FXDIB_BLEND_EXCLUSION:
-      return back_color + src_color - 2 * back_color * src_color / 255;
-  }
-  return src_color;
-}
-
-struct RGB {
-  int red;
-  int green;
-  int blue;
-};
-
-int Lum(RGB color) {
-  return (color.red * 30 + color.green * 59 + color.blue * 11) / 100;
-}
-
-RGB ClipColor(RGB color) {
-  int l = Lum(color);
-  int n = std::min(color.red, std::min(color.green, color.blue));
-  int x = std::max(color.red, std::max(color.green, color.blue));
-  if (n < 0) {
-    color.red = l + ((color.red - l) * l / (l - n));
-    color.green = l + ((color.green - l) * l / (l - n));
-    color.blue = l + ((color.blue - l) * l / (l - n));
-  }
-  if (x > 255) {
-    color.red = l + ((color.red - l) * (255 - l) / (x - l));
-    color.green = l + ((color.green - l) * (255 - l) / (x - l));
-    color.blue = l + ((color.blue - l) * (255 - l) / (x - l));
-  }
-  return color;
-}
-
-RGB SetLum(RGB color, int l) {
-  int d = l - Lum(color);
-  color.red += d;
-  color.green += d;
-  color.blue += d;
-  return ClipColor(color);
-}
-
-int Sat(RGB color) {
-  return std::max(color.red, std::max(color.green, color.blue)) -
-         std::min(color.red, std::min(color.green, color.blue));
-}
-
-RGB SetSat(RGB color, int s) {
-  int min = std::min(color.red, std::min(color.green, color.blue));
-  int max = std::max(color.red, std::max(color.green, color.blue));
-  if (min == max)
-    return {0, 0, 0};
-
-  color.red = (color.red - min) * s / (max - min);
-  color.green = (color.green - min) * s / (max - min);
-  color.blue = (color.blue - min) * s / (max - min);
-  return color;
-}
-
-void RGB_Blend(int blend_mode,
-               const uint8_t* src_scan,
-               const uint8_t* dest_scan,
-               int results[3]) {
-  RGB result = {0, 0, 0};
-  RGB src;
-  src.red = src_scan[2];
-  src.green = src_scan[1];
-  src.blue = src_scan[0];
-  RGB back;
-  back.red = dest_scan[2];
-  back.green = dest_scan[1];
-  back.blue = dest_scan[0];
-  switch (blend_mode) {
-    case FXDIB_BLEND_HUE:
-      result = SetLum(SetSat(src, Sat(back)), Lum(back));
-      break;
-    case FXDIB_BLEND_SATURATION:
-      result = SetLum(SetSat(back, Sat(src)), Lum(back));
-      break;
-    case FXDIB_BLEND_COLOR:
-      result = SetLum(src, Lum(back));
-      break;
-    case FXDIB_BLEND_LUMINOSITY:
-      result = SetLum(back, Lum(src));
-      break;
-  }
-  results[0] = result.blue;
-  results[1] = result.green;
-  results[2] = result.red;
-}
-
-int GetAlpha(uint8_t src_alpha, const uint8_t* clip_scan, int col) {
-  return clip_scan ? clip_scan[col] * src_alpha / 255 : src_alpha;
-}
-
-void CompositeRow_AlphaToMask(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
-                              int pixel_count,
-                              const uint8_t* clip_scan,
-                              uint8_t stride) {
-  src_scan += stride - 1;
-  for (int col = 0; col < pixel_count; ++col) {
-    int src_alpha = GetAlpha(*src_scan, clip_scan, col);
-    uint8_t back_alpha = *dest_scan;
-    if (!back_alpha)
-      *dest_scan = src_alpha;
-    else if (src_alpha)
-      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    ++dest_scan;
-    src_scan += stride;
-  }
-}
-
-void CompositeRow_Rgb2Mask(uint8_t* dest_scan,
-                           const uint8_t* src_scan,
-                           int width,
-                           const uint8_t* clip_scan) {
-  if (!clip_scan) {
-    FXSYS_memset(dest_scan, 0xff, width);
-    return;
-  }
-  for (int i = 0; i < width; ++i) {
-    *dest_scan = FXDIB_ALPHA_UNION(*dest_scan, *clip_scan);
-    ++dest_scan;
-    ++clip_scan;
-  }
-}
-
-uint8_t GetGray(void* pIccTransform,
-                CCodec_IccModule* pIccModule,
-                const uint8_t* src_scan) {
-  if (!pIccTransform)
-    return FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-
-  uint8_t gray;
-  pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-  return gray;
-}
-
-uint8_t GetGrayWithBlend(void* pIccTransform,
-                         CCodec_IccModule* pIccModule,
-                         const uint8_t* src_scan,
-                         const uint8_t* dest_scan,
-                         int blend_type) {
-  uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan);
-  if (blend_type >= FXDIB_BLEND_NONSEPARABLE)
-    gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-  else if (blend_type)
-    gray = Blend(blend_type, *dest_scan, gray);
-  return gray;
-}
-
-void CompositeRow_Argb2Graya(uint8_t* dest_scan,
-                             const uint8_t* src_scan,
-                             int pixel_count,
-                             int blend_type,
-                             const uint8_t* clip_scan,
-                             const uint8_t* src_alpha_scan,
-                             uint8_t* dst_alpha_scan,
-                             void* pIccTransform) {
-  CCodec_IccModule* pIccModule = nullptr;
-  if (pIccTransform)
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  uint8_t offset = src_alpha_scan ? 3 : 4;
-  for (int col = 0; col < pixel_count; ++col) {
-    const uint8_t* alpha_scan =
-        src_alpha_scan ? src_alpha_scan++ : &src_scan[3];
-    uint8_t back_alpha = *dst_alpha_scan;
-    if (back_alpha == 0) {
-      int src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
-      if (src_alpha) {
-        *dest_scan = GetGray(pIccTransform, pIccModule, src_scan);
-        *dst_alpha_scan = src_alpha;
-      }
-      ++dest_scan;
-      ++dst_alpha_scan;
-      src_scan += offset;
-      continue;
-    }
-    uint8_t src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
-    if (src_alpha == 0) {
-      ++dest_scan;
-      ++dst_alpha_scan;
-      src_scan += offset;
-      continue;
-    }
-    *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
-    int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
-    uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan);
-    // TODO(npm): Does this if really need src_alpha_scan or was that a bug?
-    if (blend_type && src_alpha_scan) {
-      if (blend_type >= FXDIB_BLEND_NONSEPARABLE)
-        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      else
-        gray = Blend(blend_type, *dest_scan, gray);
-    }
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-    ++dest_scan;
-    ++dst_alpha_scan;
-    src_scan += offset;
-  }
-}
-
-void CompositeRow_Argb2Gray(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
-                            int pixel_count,
-                            int blend_type,
-                            const uint8_t* clip_scan,
-                            const uint8_t* src_alpha_scan,
-                            void* pIccTransform) {
-  CCodec_IccModule* pIccModule = nullptr;
-  uint8_t gray;
-  if (pIccTransform)
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-
-  uint8_t offset = src_alpha_scan ? 3 : 4;
-  for (int col = 0; col < pixel_count; ++col) {
-    const uint8_t* alpha_scan =
-        src_alpha_scan ? src_alpha_scan++ : &src_scan[3];
-    int src_alpha = GetAlpha(*alpha_scan, clip_scan, col);
-    if (src_alpha) {
-      gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan,
-                              blend_type);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
-    }
-    ++dest_scan;
-    src_scan += offset;
-  }
-}
-
-void CompositeRow_Rgb2Gray(uint8_t* dest_scan,
-                           const uint8_t* src_scan,
-                           int src_Bpp,
-                           int pixel_count,
-                           int blend_type,
-                           const uint8_t* clip_scan,
-                           void* pIccTransform) {
-  CCodec_IccModule* pIccModule = nullptr;
-  uint8_t gray;
-  if (pIccTransform)
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  for (int col = 0; col < pixel_count; ++col) {
-    gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan,
-                            blend_type);
-    if (clip_scan && clip_scan[col] < 255)
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
-    else
-      *dest_scan = gray;
-    ++dest_scan;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Rgb2Graya(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
-                            int src_Bpp,
-                            int pixel_count,
-                            int blend_type,
-                            const uint8_t* clip_scan,
-                            uint8_t* dest_alpha_scan,
-                            void* pIccTransform) {
-  CCodec_IccModule* pIccModule = nullptr;
-  if (pIccTransform)
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  for (int col = 0; col < pixel_count; ++col) {
-    if (blend_type && *dest_alpha_scan == 0) {
-      *dest_scan = GetGray(pIccTransform, pIccModule, src_scan);
-      ++dest_scan;
-      ++dest_alpha_scan;
-      src_scan += src_Bpp;
-      continue;
-    }
-    int src_alpha = clip_scan ? clip_scan[col] : 255;
-    if (src_alpha == 255) {
-      *dest_scan = GetGrayWithBlend(pIccTransform, pIccModule, src_scan,
-                                    dest_scan, blend_type);
-      ++dest_scan;
-      *dest_alpha_scan = 255;
-      ++dest_alpha_scan;
-      src_scan += src_Bpp;
-      continue;
-    }
-    if (src_alpha == 0) {
-      ++dest_scan;
-      ++dest_alpha_scan;
-      src_scan += src_Bpp;
-      continue;
-    }
-    int back_alpha = *dest_alpha_scan;
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan = dest_alpha;
-    ++dest_alpha_scan;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    uint8_t gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan,
-                                    dest_scan, blend_type);
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-    ++dest_scan;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Argb2Argb(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
-                            int pixel_count,
-                            int blend_type,
-                            const uint8_t* clip_scan,
-                            uint8_t* dest_alpha_scan,
-                            const uint8_t* src_alpha_scan) {
-  int blended_colors[3];
-  uint8_t dest_offset = dest_alpha_scan ? 3 : 4;
-  uint8_t src_offset = src_alpha_scan ? 3 : 4;
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  bool has_src = !!src_alpha_scan;
-  bool has_dest = !!dest_alpha_scan;
-  for (int col = 0; col < pixel_count; ++col) {
-    uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3];
-    const uint8_t* alpha_source = has_src ? src_alpha_scan++ : &src_scan[3];
-    uint8_t src_alpha = GetAlpha(*alpha_source, clip_scan, col);
-    if (back_alpha == 0) {
-      if (!has_dest && !has_src) {
-        if (clip_scan) {
-          FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) |
-                                       (src_alpha << 24));
-        } else {
-          FXARGB_COPY(dest_scan, src_scan);
-        }
-      } else if (has_dest) {
-        *dest_alpha_scan = src_alpha;
-        for (int i = 0; i < 3; ++i) {
-          *dest_scan = *src_scan++;
-          ++dest_scan;
-        }
-        ++dest_alpha_scan;
-        if (!has_src)
-          ++src_scan;
-      } else {
-        FXARGB_SETDIB(dest_scan, FXARGB_MAKE((src_alpha << 24), src_scan[2],
-                                             src_scan[1], *src_scan));
-      }
-      if (!has_dest) {
-        dest_scan += dest_offset;
-        src_scan += src_offset;
-      }
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += dest_offset;
-      src_scan += src_offset;
-      if (has_dest)
-        ++dest_alpha_scan;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    if (has_dest) {
-      *dest_alpha_scan = dest_alpha;
-      ++dest_alpha_scan;
-    } else {
-      dest_scan[3] = dest_alpha;
-    }
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (bNonseparableBlend)
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-    for (int color = 0; color < 3; ++color) {
-      if (blend_type) {
-        int blended = bNonseparableBlend
-                          ? blended_colors[color]
-                          : Blend(blend_type, *dest_scan, *src_scan);
-        blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      } else {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
-      }
-      ++dest_scan;
-      ++src_scan;
-    }
-    if (!has_dest)
-      ++dest_scan;
-    if (!has_src)
-      ++src_scan;
-  }
-}
-
-void CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan,
-                                        const uint8_t* src_scan,
-                                        int width,
-                                        int blend_type,
-                                        int src_Bpp,
-                                        uint8_t* dest_alpha_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; ++col) {
-    uint8_t* dest_alpha = dest_alpha_scan ? dest_alpha_scan : &dest_scan[3];
-    uint8_t back_alpha = *dest_alpha;
-    if (back_alpha == 0) {
-      if (dest_alpha_scan) {
-        for (int i = 0; i < 3; ++i) {
-          *dest_scan = *src_scan++;
-          ++dest_scan;
-        }
-        *dest_alpha_scan = 0xff;
-        ++dest_alpha_scan;
-      } else {
-        if (src_Bpp == 4) {
-          FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
-        } else {
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1],
-                                               src_scan[0]));
-        }
-        dest_scan += 4;
-      }
-      src_scan += src_Bpp;
-      continue;
-    }
-    *dest_alpha = 0xff;
-    if (bNonseparableBlend)
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-    for (int color = 0; color < 3; ++color) {
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, *dest_scan, src_color);
-      *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
-      ++dest_scan;
-      ++src_scan;
-      }
-      if (dest_alpha_scan)
-        ++dest_alpha_scan;
-      else
-        ++dest_scan;
-      src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan,
-                                      const uint8_t* src_scan,
-                                      int width,
-                                      int blend_type,
-                                      int src_Bpp,
-                                      const uint8_t* clip_scan,
-                                      uint8_t* dest_alpha_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  bool has_dest = !!dest_alpha_scan;
-  for (int col = 0; col < width; ++col) {
-    int src_alpha = *clip_scan++;
-    uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3];
-    if (back_alpha == 0) {
-      for (int i = 0; i < 3; ++i) {
-        *dest_scan = *src_scan++;
-        ++dest_scan;
-      }
-      src_scan += src_gap;
-      if (has_dest)
-        dest_alpha_scan++;
-      else
-        dest_scan++;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += has_dest ? 3 : 4;
-      if (has_dest)
-        dest_alpha_scan++;
-      src_scan += src_Bpp;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    if (has_dest)
-      *dest_alpha_scan++ = dest_alpha;
-    else
-      dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (bNonseparableBlend)
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-    for (int color = 0; color < 3; color++) {
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, *dest_scan, src_color);
-      blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      src_scan++;
-    }
-    src_scan += src_gap;
-    if (!has_dest)
-      dest_scan++;
-  }
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_Clip(uint8_t* dest_scan,
-                                        const uint8_t* src_scan,
-                                        int width,
-                                        int src_Bpp,
-                                        const uint8_t* clip_scan,
-                                        uint8_t* dest_alpha_scan) {
-  int src_gap = src_Bpp - 3;
-  if (dest_alpha_scan) {
-    for (int col = 0; col < width; col++) {
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 255) {
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_alpha_scan++ = 255;
-        src_scan += src_gap;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += 3;
-        dest_alpha_scan++;
-        src_scan += src_Bpp;
-        continue;
-      }
-      int back_alpha = *dest_alpha_scan;
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      *dest_alpha_scan++ = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      for (int color = 0; color < 3; color++) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
-        dest_scan++;
-        src_scan++;
-      }
-      src_scan += src_gap;
-    }
-  } else {
-    for (int col = 0; col < width; col++) {
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 255) {
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = 255;
-        src_scan += src_gap;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += 4;
-        src_scan += src_Bpp;
-        continue;
-      }
-      int back_alpha = dest_scan[3];
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      dest_scan[3] = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      for (int color = 0; color < 3; color++) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
-        dest_scan++;
-        src_scan++;
-      }
-      dest_scan++;
-      src_scan += src_gap;
-    }
-  }
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_NoClip(uint8_t* dest_scan,
-                                          const uint8_t* src_scan,
-                                          int width,
-                                          int src_Bpp,
-                                          uint8_t* dest_alpha_scan) {
-  if (dest_alpha_scan) {
-    int src_gap = src_Bpp - 3;
-    for (int col = 0; col < width; col++) {
-      *dest_scan++ = *src_scan++;
-      *dest_scan++ = *src_scan++;
-      *dest_scan++ = *src_scan++;
-      *dest_alpha_scan++ = 0xff;
-      src_scan += src_gap;
-    }
-  } else {
-    for (int col = 0; col < width; col++) {
-      if (src_Bpp == 4) {
-        FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
-      } else {
-        FXARGB_SETDIB(dest_scan,
-                      FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
-      }
-      dest_scan += 4;
-      src_scan += src_Bpp;
-    }
-  }
-}
-
-void CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan,
-                                 const uint8_t* src_scan,
-                                 int width,
-                                 int blend_type,
-                                 int dest_Bpp,
-                                 const uint8_t* clip_scan,
-                                 const uint8_t* src_alpha_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int dest_gap = dest_Bpp - 3;
-  if (src_alpha_scan) {
-    for (int col = 0; col < width; col++) {
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
-      } else {
-        src_alpha = *src_alpha_scan++;
-      }
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_scan += 3;
-        continue;
-      }
-      if (bNonseparableBlend) {
-        RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-      }
-      for (int color = 0; color < 3; color++) {
-        int back_color = *dest_scan;
-        int blended = bNonseparableBlend
-                          ? blended_colors[color]
-                          : Blend(blend_type, back_color, *src_scan);
-        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-        dest_scan++;
-        src_scan++;
-      }
-      dest_scan += dest_gap;
-    }
-  } else {
-    for (int col = 0; col < width; col++) {
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
-      } else {
-        src_alpha = src_scan[3];
-      }
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_scan += 4;
-        continue;
-      }
-      if (bNonseparableBlend) {
-        RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-      }
-      for (int color = 0; color < 3; color++) {
-        int back_color = *dest_scan;
-        int blended = bNonseparableBlend
-                          ? blended_colors[color]
-                          : Blend(blend_type, back_color, *src_scan);
-        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-        dest_scan++;
-        src_scan++;
-      }
-      dest_scan += dest_gap;
-      src_scan++;
-    }
-  }
-}
-
-void CompositeRow_Argb2Rgb_NoBlend(uint8_t* dest_scan,
-                                   const uint8_t* src_scan,
-                                   int width,
-                                   int dest_Bpp,
-                                   const uint8_t* clip_scan,
-                                   const uint8_t* src_alpha_scan) {
-  int dest_gap = dest_Bpp - 3;
-  if (src_alpha_scan) {
-    for (int col = 0; col < width; col++) {
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
-      } else {
-        src_alpha = *src_alpha_scan++;
-      }
-      if (src_alpha == 255) {
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        dest_scan += dest_gap;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_scan += 3;
-        continue;
-      }
-      for (int color = 0; color < 3; color++) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
-        dest_scan++;
-        src_scan++;
-      }
-      dest_scan += dest_gap;
-    }
-  } else {
-    for (int col = 0; col < width; col++) {
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
-      } else {
-        src_alpha = src_scan[3];
-      }
-      if (src_alpha == 255) {
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        dest_scan += dest_gap;
-        src_scan++;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_scan += 4;
-        continue;
-      }
-      for (int color = 0; color < 3; color++) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
-        dest_scan++;
-        src_scan++;
-      }
-      dest_scan += dest_gap;
-      src_scan++;
-    }
-  }
-}
-
-void CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan,
-                                       const uint8_t* src_scan,
-                                       int width,
-                                       int blend_type,
-                                       int dest_Bpp,
-                                       int src_Bpp) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int dest_gap = dest_Bpp - 3;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    if (bNonseparableBlend) {
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int back_color = *dest_scan;
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, back_color, src_color);
-      *dest_scan = blended;
-      dest_scan++;
-      src_scan++;
-    }
-    dest_scan += dest_gap;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_Blend_Clip(uint8_t* dest_scan,
-                                     const uint8_t* src_scan,
-                                     int width,
-                                     int blend_type,
-                                     int dest_Bpp,
-                                     int src_Bpp,
-                                     const uint8_t* clip_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int dest_gap = dest_Bpp - 3;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    uint8_t src_alpha = *clip_scan++;
-    if (src_alpha == 0) {
-      dest_scan += dest_Bpp;
-      src_scan += src_Bpp;
-      continue;
-    }
-    if (bNonseparableBlend) {
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int src_color = *src_scan;
-      int back_color = *dest_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, back_color, src_color);
-      *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-      dest_scan++;
-      src_scan++;
-    }
-    dest_scan += dest_gap;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan,
-                                         const uint8_t* src_scan,
-                                         int width,
-                                         int dest_Bpp,
-                                         int src_Bpp) {
-  if (dest_Bpp == src_Bpp) {
-    FXSYS_memcpy(dest_scan, src_scan, width * dest_Bpp);
-    return;
-  }
-  for (int col = 0; col < width; col++) {
-    dest_scan[0] = src_scan[0];
-    dest_scan[1] = src_scan[1];
-    dest_scan[2] = src_scan[2];
-    dest_scan += dest_Bpp;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_Clip(uint8_t* dest_scan,
-                                       const uint8_t* src_scan,
-                                       int width,
-                                       int dest_Bpp,
-                                       int src_Bpp,
-                                       const uint8_t* clip_scan) {
-  for (int col = 0; col < width; col++) {
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 255) {
-      dest_scan[0] = src_scan[0];
-      dest_scan[1] = src_scan[1];
-      dest_scan[2] = src_scan[2];
-    } else if (src_alpha) {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
-      dest_scan++;
-      src_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
-      dest_scan++;
-      src_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
-      dest_scan += dest_Bpp - 2;
-      src_scan += src_Bpp - 2;
-      continue;
-    }
-    dest_scan += dest_Bpp;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Argb2Argb_Transform(uint8_t* dest_scan,
-                                      const uint8_t* src_scan,
-                                      int pixel_count,
-                                      int blend_type,
-                                      const uint8_t* clip_scan,
-                                      uint8_t* dest_alpha_scan,
-                                      const uint8_t* src_alpha_scan,
-                                      uint8_t* src_cache_scan,
-                                      void* pIccTransform) {
-  uint8_t* dp = src_cache_scan;
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_alpha_scan) {
-    if (dest_alpha_scan) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count);
-    } else {
-      for (int col = 0; col < pixel_count; col++) {
-        pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-        dp[3] = *src_alpha_scan++;
-        src_scan += 3;
-        dp += 4;
-      }
-      src_alpha_scan = nullptr;
-    }
-  } else {
-    if (dest_alpha_scan) {
-      int blended_colors[3];
-      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      for (int col = 0; col < pixel_count; col++) {
-        pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                      1);
-        uint8_t back_alpha = *dest_alpha_scan;
-        if (back_alpha == 0) {
-          if (clip_scan) {
-            int src_alpha = clip_scan[col] * src_scan[3] / 255;
-            *dest_alpha_scan = src_alpha;
-            *dest_scan++ = *src_cache_scan++;
-            *dest_scan++ = *src_cache_scan++;
-            *dest_scan++ = *src_cache_scan++;
-          } else {
-            *dest_alpha_scan = src_scan[3];
-            *dest_scan++ = *src_cache_scan++;
-            *dest_scan++ = *src_cache_scan++;
-            *dest_scan++ = *src_cache_scan++;
-          }
-          dest_alpha_scan++;
-          src_scan += 4;
-          continue;
-        }
-        uint8_t src_alpha;
-        if (clip_scan) {
-          src_alpha = clip_scan[col] * src_scan[3] / 255;
-        } else {
-          src_alpha = src_scan[3];
-        }
-        src_scan += 4;
-        if (src_alpha == 0) {
-          dest_scan += 3;
-          src_cache_scan += 3;
-          dest_alpha_scan++;
-          continue;
-        }
-        uint8_t dest_alpha =
-            back_alpha + src_alpha - back_alpha * src_alpha / 255;
-        *dest_alpha_scan++ = dest_alpha;
-        int alpha_ratio = src_alpha * 255 / dest_alpha;
-        if (bNonseparableBlend) {
-          RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
-        }
-        for (int color = 0; color < 3; color++) {
-          if (blend_type) {
-            int blended = bNonseparableBlend
-                              ? blended_colors[color]
-                              : Blend(blend_type, *dest_scan, *src_cache_scan);
-            blended = FXDIB_ALPHA_MERGE(*src_cache_scan, blended, back_alpha);
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-          } else {
-            *dest_scan =
-                FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, alpha_ratio);
-          }
-          dest_scan++;
-          src_cache_scan++;
-        }
-      }
-      return;
-    }
-    for (int col = 0; col < pixel_count; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      dp[3] = src_scan[3];
-      src_scan += 4;
-      dp += 4;
-    }
-  }
-  CompositeRow_Argb2Argb(dest_scan, src_cache_scan, pixel_count, blend_type,
-                         clip_scan, dest_alpha_scan, src_alpha_scan);
-}
-
-void CompositeRow_Rgb2Argb_Blend_NoClip_Transform(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int width,
-                                                  int blend_type,
-                                                  int src_Bpp,
-                                                  uint8_t* dest_alpha_scan,
-                                                  uint8_t* src_cache_scan,
-                                                  void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width,
-                                     blend_type, 3, dest_alpha_scan);
-}
-
-void CompositeRow_Rgb2Argb_Blend_Clip_Transform(uint8_t* dest_scan,
-                                                const uint8_t* src_scan,
-                                                int width,
-                                                int blend_type,
-                                                int src_Bpp,
-                                                const uint8_t* clip_scan,
-                                                uint8_t* dest_alpha_scan,
-                                                uint8_t* src_cache_scan,
-                                                void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
-                                   3, clip_scan, dest_alpha_scan);
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int width,
-                                                  int src_Bpp,
-                                                  const uint8_t* clip_scan,
-                                                  uint8_t* dest_alpha_scan,
-                                                  uint8_t* src_cache_scan,
-                                                  void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3,
-                                     clip_scan, dest_alpha_scan);
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(uint8_t* dest_scan,
-                                                    const uint8_t* src_scan,
-                                                    int width,
-                                                    int src_Bpp,
-                                                    uint8_t* dest_alpha_scan,
-                                                    uint8_t* src_cache_scan,
-                                                    void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3,
-                                       dest_alpha_scan);
-}
-
-void CompositeRow_Argb2Rgb_Blend_Transform(uint8_t* dest_scan,
-                                           const uint8_t* src_scan,
-                                           int width,
-                                           int blend_type,
-                                           int dest_Bpp,
-                                           const uint8_t* clip_scan,
-                                           const uint8_t* src_alpha_scan,
-                                           uint8_t* src_cache_scan,
-                                           void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_alpha_scan) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    int blended_colors[3];
-    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int dest_gap = dest_Bpp - 3;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
-      } else {
-        src_alpha = src_scan[3];
-      }
-      src_scan += 4;
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_cache_scan += 3;
-        continue;
-      }
-      if (bNonseparableBlend) {
-        RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
-      }
-      for (int color = 0; color < 3; color++) {
-        int back_color = *dest_scan;
-        int blended = bNonseparableBlend
-                          ? blended_colors[color]
-                          : Blend(blend_type, back_color, *src_cache_scan);
-        *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-        dest_scan++;
-        src_cache_scan++;
-      }
-      dest_scan += dest_gap;
-    }
-    return;
-  }
-  CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type,
-                              dest_Bpp, clip_scan, src_alpha_scan);
-}
-
-void CompositeRow_Argb2Rgb_NoBlend_Transform(uint8_t* dest_scan,
-                                             const uint8_t* src_scan,
-                                             int width,
-                                             int dest_Bpp,
-                                             const uint8_t* clip_scan,
-                                             const uint8_t* src_alpha_scan,
-                                             uint8_t* src_cache_scan,
-                                             void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_alpha_scan) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    int dest_gap = dest_Bpp - 3;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
-      } else {
-        src_alpha = src_scan[3];
-      }
-      src_scan += 4;
-      if (src_alpha == 255) {
-        *dest_scan++ = *src_cache_scan++;
-        *dest_scan++ = *src_cache_scan++;
-        *dest_scan++ = *src_cache_scan++;
-        dest_scan += dest_gap;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += dest_Bpp;
-        src_cache_scan += 3;
-        continue;
-      }
-      for (int color = 0; color < 3; color++) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, src_alpha);
-        dest_scan++;
-        src_cache_scan++;
-      }
-      dest_scan += dest_gap;
-    }
-    return;
-  }
-  CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp,
-                                clip_scan, src_alpha_scan);
-}
-
-void CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(uint8_t* dest_scan,
-                                                 const uint8_t* src_scan,
-                                                 int width,
-                                                 int blend_type,
-                                                 int dest_Bpp,
-                                                 int src_Bpp,
-                                                 uint8_t* src_cache_scan,
-                                                 void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width,
-                                    blend_type, dest_Bpp, 3);
-}
-
-void CompositeRow_Rgb2Rgb_Blend_Clip_Transform(uint8_t* dest_scan,
-                                               const uint8_t* src_scan,
-                                               int width,
-                                               int blend_type,
-                                               int dest_Bpp,
-                                               int src_Bpp,
-                                               const uint8_t* clip_scan,
-                                               uint8_t* src_cache_scan,
-                                               void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
-                                  dest_Bpp, 3, clip_scan);
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   int width,
-                                                   int dest_Bpp,
-                                                   int src_Bpp,
-                                                   uint8_t* src_cache_scan,
-                                                   void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width,
-                                      dest_Bpp, 3);
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(uint8_t* dest_scan,
-                                                 const uint8_t* src_scan,
-                                                 int width,
-                                                 int dest_Bpp,
-                                                 int src_Bpp,
-                                                 const uint8_t* clip_scan,
-                                                 uint8_t* src_cache_scan,
-                                                 void* pIccTransform) {
-  CCodec_IccModule* pIccModule =
-      CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  if (src_Bpp == 3) {
-    pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
-                                  width);
-  } else {
-    uint8_t* dp = src_cache_scan;
-    for (int col = 0; col < width; col++) {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-      src_scan += 4;
-      dp += 3;
-    }
-  }
-  CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp,
-                                    3, clip_scan);
-}
-
-void CompositeRow_8bppPal2Gray(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               const uint8_t* pPalette,
-                               int pixel_count,
-                               int blend_type,
-                               const uint8_t* clip_scan,
-                               const uint8_t* src_alpha_scan) {
-  if (src_alpha_scan) {
-    if (blend_type) {
-      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      for (int col = 0; col < pixel_count; col++) {
-        uint8_t gray = pPalette[*src_scan];
-        int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-        if (bNonseparableBlend)
-          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        else
-          gray = Blend(blend_type, *dest_scan, gray);
-        if (src_alpha)
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
-        else
-          *dest_scan = gray;
-        dest_scan++;
-        src_scan++;
-      }
-      return;
-    }
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray = pPalette[*src_scan];
-      int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-      if (src_alpha)
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
-      else
-        *dest_scan = gray;
-      dest_scan++;
-      src_scan++;
-    }
-  } else {
-    if (blend_type) {
-      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      for (int col = 0; col < pixel_count; col++) {
-        uint8_t gray = pPalette[*src_scan];
-        if (bNonseparableBlend)
-          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        else
-          gray = Blend(blend_type, *dest_scan, gray);
-        if (clip_scan && clip_scan[col] < 255)
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
-        else
-          *dest_scan = gray;
-        dest_scan++;
-        src_scan++;
-      }
-      return;
-    }
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray = pPalette[*src_scan];
-      if (clip_scan && clip_scan[col] < 255)
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
-      else
-        *dest_scan = gray;
-      dest_scan++;
-      src_scan++;
-    }
-  }
-}
-
-void CompositeRow_8bppPal2Graya(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                const uint8_t* pPalette,
-                                int pixel_count,
-                                int blend_type,
-                                const uint8_t* clip_scan,
-                                uint8_t* dest_alpha_scan,
-                                const uint8_t* src_alpha_scan) {
-  if (src_alpha_scan) {
-    if (blend_type) {
-      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      for (int col = 0; col < pixel_count; col++) {
-        uint8_t gray = pPalette[*src_scan];
-        src_scan++;
-        uint8_t back_alpha = *dest_alpha_scan;
-        if (back_alpha == 0) {
-          int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-          if (src_alpha) {
-            *dest_scan = gray;
-            *dest_alpha_scan = src_alpha;
-          }
-          dest_scan++;
-          dest_alpha_scan++;
-          continue;
-        }
-        uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-        if (src_alpha == 0) {
-          dest_scan++;
-          dest_alpha_scan++;
-          continue;
-        }
-        *dest_alpha_scan =
-            back_alpha + src_alpha - back_alpha * src_alpha / 255;
-        int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
-        if (bNonseparableBlend)
-          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        else
-          gray = Blend(blend_type, *dest_scan, gray);
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-        dest_alpha_scan++;
-        dest_scan++;
-      }
-      return;
-    }
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray = pPalette[*src_scan];
-      src_scan++;
-      uint8_t back_alpha = *dest_alpha_scan;
-      if (back_alpha == 0) {
-        int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-        if (src_alpha) {
-          *dest_scan = gray;
-          *dest_alpha_scan = src_alpha;
-        }
-        dest_scan++;
-        dest_alpha_scan++;
-        continue;
-      }
-      uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col);
-      if (src_alpha == 0) {
-        dest_scan++;
-        dest_alpha_scan++;
-        continue;
-      }
-      *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
-      dest_alpha_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-      dest_scan++;
-    }
-  } else {
-    if (blend_type) {
-      bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      for (int col = 0; col < pixel_count; col++) {
-        uint8_t gray = pPalette[*src_scan];
-        src_scan++;
-        if (!clip_scan || clip_scan[col] == 255) {
-          *dest_scan++ = gray;
-          *dest_alpha_scan++ = 255;
-          continue;
-        }
-        int src_alpha = clip_scan[col];
-        if (src_alpha == 0) {
-          dest_scan++;
-          dest_alpha_scan++;
-          continue;
-        }
-        int back_alpha = *dest_alpha_scan;
-        uint8_t dest_alpha =
-            back_alpha + src_alpha - back_alpha * src_alpha / 255;
-        *dest_alpha_scan++ = dest_alpha;
-        int alpha_ratio = src_alpha * 255 / dest_alpha;
-        if (bNonseparableBlend)
-          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        else
-          gray = Blend(blend_type, *dest_scan, gray);
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-        dest_scan++;
-      }
-      return;
-    }
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray = pPalette[*src_scan];
-      src_scan++;
-      if (!clip_scan || clip_scan[col] == 255) {
-        *dest_scan++ = gray;
-        *dest_alpha_scan++ = 255;
-        continue;
-      }
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 0) {
-        dest_scan++;
-        dest_alpha_scan++;
-        continue;
-      }
-      int back_alpha = *dest_alpha_scan;
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      *dest_alpha_scan++ = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-      dest_scan++;
-    }
-  }
-}
-
-void CompositeRow_1bppPal2Gray(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               int src_left,
-                               const uint8_t* pPalette,
-                               int pixel_count,
-                               int blend_type,
-                               const uint8_t* clip_scan) {
-  int reset_gray = pPalette[0];
-  int set_gray = pPalette[1];
-  if (blend_type) {
-    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray =
-          (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
-              ? set_gray
-              : reset_gray;
-      if (bNonseparableBlend)
-        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      else
-        gray = Blend(blend_type, *dest_scan, gray);
-      if (clip_scan && clip_scan[col] < 255) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
-      } else {
-        *dest_scan = gray;
-      }
-      dest_scan++;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    uint8_t gray =
-        (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
-            ? set_gray
-            : reset_gray;
-    if (clip_scan && clip_scan[col] < 255) {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
-    } else {
-      *dest_scan = gray;
-    }
-    dest_scan++;
-  }
-}
-
-void CompositeRow_1bppPal2Graya(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int src_left,
-                                const uint8_t* pPalette,
-                                int pixel_count,
-                                int blend_type,
-                                const uint8_t* clip_scan,
-                                uint8_t* dest_alpha_scan) {
-  int reset_gray = pPalette[0];
-  int set_gray = pPalette[1];
-  if (blend_type) {
-    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    for (int col = 0; col < pixel_count; col++) {
-      uint8_t gray =
-          (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
-              ? set_gray
-              : reset_gray;
-      if (!clip_scan || clip_scan[col] == 255) {
-        *dest_scan++ = gray;
-        *dest_alpha_scan++ = 255;
-        continue;
-      }
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 0) {
-        dest_scan++;
-        dest_alpha_scan++;
-        continue;
-      }
-      int back_alpha = *dest_alpha_scan;
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      *dest_alpha_scan++ = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      if (bNonseparableBlend)
-        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      else
-        gray = Blend(blend_type, *dest_scan, gray);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-      dest_scan++;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    uint8_t gray =
-        (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
-            ? set_gray
-            : reset_gray;
-    if (!clip_scan || clip_scan[col] == 255) {
-      *dest_scan++ = gray;
-      *dest_alpha_scan++ = 255;
-      continue;
-    }
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 0) {
-      dest_scan++;
-      dest_alpha_scan++;
-      continue;
-    }
-    int back_alpha = *dest_alpha_scan;
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan++ = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
-    dest_scan++;
-  }
-}
-
-void CompositeRow_8bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
-                                      const uint8_t* src_scan,
-                                      uint32_t* pPalette,
-                                      int pixel_count,
-                                      int DestBpp,
-                                      const uint8_t* clip_scan,
-                                      const uint8_t* src_alpha_scan) {
-  if (src_alpha_scan) {
-    int dest_gap = DestBpp - 3;
-    FX_ARGB argb = 0;
-    for (int col = 0; col < pixel_count; col++) {
-      argb = pPalette[*src_scan];
-      int src_r = FXARGB_R(argb);
-      int src_g = FXARGB_G(argb);
-      int src_b = FXARGB_B(argb);
-      src_scan++;
-      uint8_t src_alpha = 0;
-      if (clip_scan) {
-        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
-      } else {
-        src_alpha = *src_alpha_scan++;
-      }
-      if (src_alpha == 255) {
-        *dest_scan++ = src_b;
-        *dest_scan++ = src_g;
-        *dest_scan++ = src_r;
-        dest_scan += dest_gap;
-        continue;
-      }
-      if (src_alpha == 0) {
-        dest_scan += DestBpp;
-        continue;
-      }
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
-      dest_scan++;
-      dest_scan += dest_gap;
-    }
-  } else {
-    FX_ARGB argb = 0;
-    for (int col = 0; col < pixel_count; col++) {
-      argb = pPalette[*src_scan];
-      int src_r = FXARGB_R(argb);
-      int src_g = FXARGB_G(argb);
-      int src_b = FXARGB_B(argb);
-      if (clip_scan && clip_scan[col] < 255) {
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]);
-        dest_scan++;
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]);
-        dest_scan++;
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]);
-        dest_scan++;
-      } else {
-        *dest_scan++ = src_b;
-        *dest_scan++ = src_g;
-        *dest_scan++ = src_r;
-      }
-      if (DestBpp == 4) {
-        dest_scan++;
-      }
-      src_scan++;
-    }
-  }
-}
-
-void CompositeRow_1bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
-                                      const uint8_t* src_scan,
-                                      int src_left,
-                                      uint32_t* pPalette,
-                                      int pixel_count,
-                                      int DestBpp,
-                                      const uint8_t* clip_scan) {
-  int reset_r, reset_g, reset_b;
-  int set_r, set_g, set_b;
-  reset_r = FXARGB_R(pPalette[0]);
-  reset_g = FXARGB_G(pPalette[0]);
-  reset_b = FXARGB_B(pPalette[0]);
-  set_r = FXARGB_R(pPalette[1]);
-  set_g = FXARGB_G(pPalette[1]);
-  set_b = FXARGB_B(pPalette[1]);
-  for (int col = 0; col < pixel_count; col++) {
-    int src_r, src_g, src_b;
-    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
-      src_r = set_r;
-      src_g = set_g;
-      src_b = set_b;
-    } else {
-      src_r = reset_r;
-      src_g = reset_g;
-      src_b = reset_b;
-    }
-    if (clip_scan && clip_scan[col] < 255) {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]);
-      dest_scan++;
-    } else {
-      *dest_scan++ = src_b;
-      *dest_scan++ = src_g;
-      *dest_scan++ = src_r;
-    }
-    if (DestBpp == 4) {
-      dest_scan++;
-    }
-  }
-}
-
-void CompositeRow_8bppRgb2Argb_NoBlend(uint8_t* dest_scan,
-                                       const uint8_t* src_scan,
-                                       int width,
-                                       uint32_t* pPalette,
-                                       const uint8_t* clip_scan,
-                                       const uint8_t* src_alpha_scan) {
-  if (src_alpha_scan) {
-    for (int col = 0; col < width; col++) {
-      FX_ARGB argb = pPalette[*src_scan];
-      src_scan++;
-      int src_r = FXARGB_R(argb);
-      int src_g = FXARGB_G(argb);
-      int src_b = FXARGB_B(argb);
-      uint8_t back_alpha = dest_scan[3];
-      if (back_alpha == 0) {
-        if (clip_scan) {
-          int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
-        } else {
-          FXARGB_SETDIB(dest_scan,
-                        FXARGB_MAKE(*src_alpha_scan, src_r, src_g, src_b));
-        }
-        dest_scan += 4;
-        src_alpha_scan++;
-        continue;
-      }
-      uint8_t src_alpha;
-      if (clip_scan) {
-        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
-      } else {
-        src_alpha = *src_alpha_scan++;
-      }
-      if (src_alpha == 0) {
-        dest_scan += 4;
-        continue;
-      }
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      dest_scan[3] = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-      dest_scan++;
-      dest_scan++;
-    }
-  } else {
-    for (int col = 0; col < width; col++) {
-      FX_ARGB argb = pPalette[*src_scan];
-      int src_r = FXARGB_R(argb);
-      int src_g = FXARGB_G(argb);
-      int src_b = FXARGB_B(argb);
-      if (!clip_scan || clip_scan[col] == 255) {
-        *dest_scan++ = src_b;
-        *dest_scan++ = src_g;
-        *dest_scan++ = src_r;
-        *dest_scan++ = 255;
-        src_scan++;
-        continue;
-      }
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 0) {
-        dest_scan += 4;
-        src_scan++;
-        continue;
-      }
-      int back_alpha = dest_scan[3];
-      uint8_t dest_alpha =
-          back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      dest_scan[3] = dest_alpha;
-      int alpha_ratio = src_alpha * 255 / dest_alpha;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-      dest_scan++;
-      dest_scan++;
-      src_scan++;
-    }
-  }
-}
-
-void CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan,
-                                       const uint8_t* src_scan,
-                                       int src_left,
-                                       int width,
-                                       uint32_t* pPalette,
-                                       const uint8_t* clip_scan) {
-  int reset_r, reset_g, reset_b;
-  int set_r, set_g, set_b;
-  reset_r = FXARGB_R(pPalette[0]);
-  reset_g = FXARGB_G(pPalette[0]);
-  reset_b = FXARGB_B(pPalette[0]);
-  set_r = FXARGB_R(pPalette[1]);
-  set_g = FXARGB_G(pPalette[1]);
-  set_b = FXARGB_B(pPalette[1]);
-  for (int col = 0; col < width; col++) {
-    int src_r, src_g, src_b;
-    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
-      src_r = set_r;
-      src_g = set_g;
-      src_b = set_b;
-    } else {
-      src_r = reset_r;
-      src_g = reset_g;
-      src_b = reset_b;
-    }
-    if (!clip_scan || clip_scan[col] == 255) {
-      *dest_scan++ = src_b;
-      *dest_scan++ = src_g;
-      *dest_scan++ = src_r;
-      *dest_scan++ = 255;
-      continue;
-    }
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      continue;
-    }
-    int back_alpha = dest_scan[3];
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-    dest_scan++;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-    dest_scan++;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-    dest_scan++;
-    dest_scan++;
-  }
-}
-
-void CompositeRow_1bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
-                                       const uint8_t* src_scan,
-                                       int src_left,
-                                       int width,
-                                       uint32_t* pPalette,
-                                       const uint8_t* clip_scan,
-                                       uint8_t* dest_alpha_scan) {
-  int reset_r, reset_g, reset_b;
-  int set_r, set_g, set_b;
-  reset_r = FXARGB_R(pPalette[0]);
-  reset_g = FXARGB_G(pPalette[0]);
-  reset_b = FXARGB_B(pPalette[0]);
-  set_r = FXARGB_R(pPalette[1]);
-  set_g = FXARGB_G(pPalette[1]);
-  set_b = FXARGB_B(pPalette[1]);
-  for (int col = 0; col < width; col++) {
-    int src_r, src_g, src_b;
-    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
-      src_r = set_r;
-      src_g = set_g;
-      src_b = set_b;
-    } else {
-      src_r = reset_r;
-      src_g = reset_g;
-      src_b = reset_b;
-    }
-    if (!clip_scan || clip_scan[col] == 255) {
-      *dest_scan++ = src_b;
-      *dest_scan++ = src_g;
-      *dest_scan++ = src_r;
-      *dest_alpha_scan++ = 255;
-      continue;
-    }
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 0) {
-      dest_scan += 3;
-      dest_alpha_scan++;
-      continue;
-    }
-    int back_alpha = *dest_alpha_scan;
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan++ = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-    dest_scan++;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-    dest_scan++;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-    dest_scan++;
-  }
-}
-
-void CompositeRow_ByteMask2Argb(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int mask_alpha,
-                                int src_r,
-                                int src_g,
-                                int src_b,
-                                int pixel_count,
-                                int blend_type,
-                                const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
-      dest_scan += 4;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, *dest_scan, src_b);
-      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_g);
-      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_r);
-      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-    } else {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-    }
-    dest_scan += 2;
-  }
-}
-
-void CompositeRow_ByteMask2Rgba(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int mask_alpha,
-                                int src_r,
-                                int src_g,
-                                int src_b,
-                                int pixel_count,
-                                int blend_type,
-                                const uint8_t* clip_scan,
-                                uint8_t* dest_alpha_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    uint8_t back_alpha = *dest_alpha_scan;
-    if (back_alpha == 0) {
-      *dest_scan++ = src_b;
-      *dest_scan++ = src_g;
-      *dest_scan++ = src_r;
-      *dest_alpha_scan++ = src_alpha;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += 3;
-      dest_alpha_scan++;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan++ = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
-      dest_scan++;
-    } else if (blend_type) {
-      int blended = Blend(blend_type, *dest_scan, src_b);
-      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_g);
-      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_r);
-      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-    } else {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-      dest_scan++;
-    }
-  }
-}
-
-void CompositeRow_ByteMask2Rgb(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               int mask_alpha,
-                               int src_r,
-                               int src_g,
-                               int src_b,
-                               int pixel_count,
-                               int blend_type,
-                               int Bpp,
-                               const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    if (src_alpha == 0) {
-      dest_scan += Bpp;
-      continue;
-    }
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, *dest_scan, src_b);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_g);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_r);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-    } else {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
-    }
-    dest_scan += Bpp - 2;
-  }
-}
-
-void CompositeRow_ByteMask2Mask(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int mask_alpha,
-                                int pixel_count,
-                                const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    uint8_t back_alpha = *dest_scan;
-    if (!back_alpha) {
-      *dest_scan = src_alpha;
-    } else if (src_alpha) {
-      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    }
-    dest_scan++;
-  }
-}
-
-void CompositeRow_ByteMask2Gray(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int mask_alpha,
-                                int src_gray,
-                                int pixel_count,
-                                const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    if (src_alpha) {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
-    }
-    dest_scan++;
-  }
-}
-
-void CompositeRow_ByteMask2Graya(uint8_t* dest_scan,
-                                 const uint8_t* src_scan,
-                                 int mask_alpha,
-                                 int src_gray,
-                                 int pixel_count,
-                                 const uint8_t* clip_scan,
-                                 uint8_t* dest_alpha_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    uint8_t back_alpha = *dest_alpha_scan;
-    if (back_alpha == 0) {
-      *dest_scan++ = src_gray;
-      *dest_alpha_scan++ = src_alpha;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan++;
-      dest_alpha_scan++;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan++ = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
-    dest_scan++;
-  }
-}
-
-void CompositeRow_BitMask2Argb(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               int mask_alpha,
-                               int src_r,
-                               int src_g,
-                               int src_b,
-                               int src_left,
-                               int pixel_count,
-                               int blend_type,
-                               const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
-    FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
-    for (int col = 0; col < pixel_count; col++) {
-      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
-        FXARGB_SETDIB(dest_scan, argb);
-      }
-      dest_scan += 4;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan += 4;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
-      dest_scan += 4;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
-      dest_scan++;
-      *dest_scan =
-          FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, *dest_scan, src_b);
-      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_g);
-      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_r);
-      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
-    } else {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
-    }
-    dest_scan += 2;
-  }
-}
-
-void CompositeRow_BitMask2Rgb(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
-                              int mask_alpha,
-                              int src_r,
-                              int src_g,
-                              int src_b,
-                              int src_left,
-                              int pixel_count,
-                              int blend_type,
-                              int Bpp,
-                              const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
-    for (int col = 0; col < pixel_count; col++) {
-      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
-        dest_scan[2] = src_r;
-        dest_scan[1] = src_g;
-        dest_scan[0] = src_b;
-      }
-      dest_scan += Bpp;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan += Bpp;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    if (src_alpha == 0) {
-      dest_scan += Bpp;
-      continue;
-    }
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, *dest_scan, src_b);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_g);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-      dest_scan++;
-      blended = Blend(blend_type, *dest_scan, src_r);
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
-    } else {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
-      dest_scan++;
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
-    }
-    dest_scan += Bpp - 2;
-  }
-}
-
-void CompositeRow_BitMask2Mask(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               int mask_alpha,
-                               int src_left,
-                               int pixel_count,
-                               const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan++;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    uint8_t back_alpha = *dest_scan;
-    if (!back_alpha) {
-      *dest_scan = src_alpha;
-    } else if (src_alpha) {
-      *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    }
-    dest_scan++;
-  }
-}
-
-void CompositeRow_BitMask2Gray(uint8_t* dest_scan,
-                               const uint8_t* src_scan,
-                               int mask_alpha,
-                               int src_gray,
-                               int src_left,
-                               int pixel_count,
-                               const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan++;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    if (src_alpha) {
-      *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
-    }
-    dest_scan++;
-  }
-}
-
-void CompositeRow_BitMask2Graya(uint8_t* dest_scan,
-                                const uint8_t* src_scan,
-                                int mask_alpha,
-                                int src_gray,
-                                int src_left,
-                                int pixel_count,
-                                const uint8_t* clip_scan,
-                                uint8_t* dest_alpha_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan++;
-      dest_alpha_scan++;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    uint8_t back_alpha = *dest_alpha_scan;
-    if (back_alpha == 0) {
-      *dest_scan++ = src_gray;
-      *dest_alpha_scan++ = src_alpha;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan++;
-      dest_alpha_scan++;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    *dest_alpha_scan++ = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
-    dest_scan++;
-  }
-}
-
-void CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan,
-                                         const uint8_t* src_scan,
-                                         int pixel_count,
-                                         int blend_type,
-                                         const uint8_t* clip_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  for (int col = 0; col < pixel_count; col++) {
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      if (clip_scan) {
-        int src_alpha = clip_scan[col] * src_scan[3] / 255;
-        dest_scan[3] = src_alpha;
-        dest_scan[0] = src_scan[2];
-        dest_scan[1] = src_scan[1];
-        dest_scan[2] = src_scan[0];
-      } else {
-        FXARGB_RGBORDERCOPY(dest_scan, src_scan);
-      }
-      dest_scan += 4;
-      src_scan += 4;
-      continue;
-    }
-    uint8_t src_alpha;
-    if (clip_scan) {
-      src_alpha = clip_scan[col] * src_scan[3] / 255;
-    } else {
-      src_alpha = src_scan[3];
-    }
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      src_scan += 4;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      if (blend_type) {
-        int blended = bNonseparableBlend
-                          ? blended_colors[color]
-                          : Blend(blend_type, dest_scan[index], *src_scan);
-        blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
-        dest_scan[index] =
-            FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
-      } else {
-        dest_scan[index] =
-            FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
-      }
-      src_scan++;
-    }
-    dest_scan += 4;
-    src_scan++;
-  }
-}
-
-void CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan,
-                                                     const uint8_t* src_scan,
-                                                     int width,
-                                                     int blend_type,
-                                                     int src_Bpp) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      if (src_Bpp == 4) {
-        FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
-      } else {
-        FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2],
-                                                     src_scan[1], src_scan[0]));
-      }
-      dest_scan += 4;
-      src_scan += src_Bpp;
-      continue;
-    }
-    dest_scan[3] = 0xff;
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, dest_scan[index], src_color);
-      dest_scan[index] = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
-      src_scan++;
-    }
-    dest_scan += 4;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Argb2Rgb_Blend_RgbByteOrder(uint8_t* dest_scan,
-                                              const uint8_t* src_scan,
-                                              int width,
-                                              int blend_type,
-                                              int dest_Bpp,
-                                              const uint8_t* clip_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  for (int col = 0; col < width; col++) {
-    uint8_t src_alpha;
-    if (clip_scan) {
-      src_alpha = src_scan[3] * (*clip_scan++) / 255;
-    } else {
-      src_alpha = src_scan[3];
-    }
-    if (src_alpha == 0) {
-      dest_scan += dest_Bpp;
-      src_scan += 4;
-      continue;
-    }
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      int back_color = dest_scan[index];
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, back_color, *src_scan);
-      dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-      src_scan++;
-    }
-    dest_scan += dest_Bpp;
-    src_scan++;
-  }
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan,
-                                                       const uint8_t* src_scan,
-                                                       int width,
-                                                       int src_Bpp) {
-  for (int col = 0; col < width; col++) {
-    if (src_Bpp == 4) {
-      FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
-    } else {
-      FXARGB_SETRGBORDERDIB(
-          dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
-    }
-    dest_scan += 4;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan,
-                                                    const uint8_t* src_scan,
-                                                    int width,
-                                                    int blend_type,
-                                                    int dest_Bpp,
-                                                    int src_Bpp) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      int back_color = dest_scan[index];
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, back_color, src_color);
-      dest_scan[index] = blended;
-      src_scan++;
-    }
-    dest_scan += dest_Bpp;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
-                                                const uint8_t* src_scan,
-                                                int width,
-                                                int dest_Bpp,
-                                                const uint8_t* clip_scan) {
-  for (int col = 0; col < width; col++) {
-    uint8_t src_alpha;
-    if (clip_scan) {
-      src_alpha = src_scan[3] * (*clip_scan++) / 255;
-    } else {
-      src_alpha = src_scan[3];
-    }
-    if (src_alpha == 255) {
-      dest_scan[2] = *src_scan++;
-      dest_scan[1] = *src_scan++;
-      dest_scan[0] = *src_scan++;
-      dest_scan += dest_Bpp;
-      src_scan++;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += dest_Bpp;
-      src_scan += 4;
-      continue;
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      dest_scan[index] =
-          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, src_alpha);
-      src_scan++;
-    }
-    dest_scan += dest_Bpp;
-    src_scan++;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan,
-                                                      const uint8_t* src_scan,
-                                                      int width,
-                                                      int dest_Bpp,
-                                                      int src_Bpp) {
-  for (int col = 0; col < width; col++) {
-    dest_scan[2] = src_scan[0];
-    dest_scan[1] = src_scan[1];
-    dest_scan[0] = src_scan[2];
-    dest_scan += dest_Bpp;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   int width,
-                                                   int blend_type,
-                                                   int src_Bpp,
-                                                   const uint8_t* clip_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    int src_alpha = *clip_scan++;
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      dest_scan[2] = *src_scan++;
-      dest_scan[1] = *src_scan++;
-      dest_scan[0] = *src_scan++;
-      src_scan += src_gap;
-      dest_scan += 4;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      src_scan += src_Bpp;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      int src_color = *src_scan;
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, dest_scan[index], src_color);
-      blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
-      dest_scan[index] =
-          FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
-      src_scan++;
-    }
-    dest_scan += 4;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int width,
-                                                  int blend_type,
-                                                  int dest_Bpp,
-                                                  int src_Bpp,
-                                                  const uint8_t* clip_scan) {
-  int blended_colors[3];
-  bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    uint8_t src_alpha = *clip_scan++;
-    if (src_alpha == 0) {
-      dest_scan += dest_Bpp;
-      src_scan += src_Bpp;
-      continue;
-    }
-    if (bNonseparableBlend) {
-      uint8_t dest_scan_o[3];
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
-    }
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      int src_color = *src_scan;
-      int back_color = dest_scan[index];
-      int blended = bNonseparableBlend
-                        ? blended_colors[color]
-                        : Blend(blend_type, back_color, src_color);
-      dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-      src_scan++;
-    }
-    dest_scan += dest_Bpp;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan,
-                                                     const uint8_t* src_scan,
-                                                     int width,
-                                                     int src_Bpp,
-                                                     const uint8_t* clip_scan) {
-  int src_gap = src_Bpp - 3;
-  for (int col = 0; col < width; col++) {
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 255) {
-      dest_scan[2] = *src_scan++;
-      dest_scan[1] = *src_scan++;
-      dest_scan[0] = *src_scan++;
-      dest_scan[3] = 255;
-      dest_scan += 4;
-      src_scan += src_gap;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      src_scan += src_Bpp;
-      continue;
-    }
-    int back_alpha = dest_scan[3];
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    for (int color = 0; color < 3; color++) {
-      int index = 2 - color;
-      dest_scan[index] =
-          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
-      src_scan++;
-    }
-    dest_scan += 4;
-    src_scan += src_gap;
-  }
-}
-
-void CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan,
-                                                    const uint8_t* src_scan,
-                                                    int width,
-                                                    int dest_Bpp,
-                                                    int src_Bpp,
-                                                    const uint8_t* clip_scan) {
-  for (int col = 0; col < width; col++) {
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 255) {
-      dest_scan[2] = src_scan[0];
-      dest_scan[1] = src_scan[1];
-      dest_scan[0] = src_scan[2];
-    } else if (src_alpha) {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], *src_scan, src_alpha);
-      src_scan++;
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], *src_scan, src_alpha);
-      src_scan++;
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], *src_scan, src_alpha);
-      dest_scan += dest_Bpp;
-      src_scan += src_Bpp - 2;
-      continue;
-    }
-    dest_scan += dest_Bpp;
-    src_scan += src_Bpp;
-  }
-}
-
-void CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   FX_ARGB* pPalette,
-                                                   int pixel_count,
-                                                   int DestBpp,
-                                                   const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    FX_ARGB argb = pPalette ? pPalette[*src_scan] : (*src_scan) * 0x010101;
-    int src_r = FXARGB_R(argb);
-    int src_g = FXARGB_G(argb);
-    int src_b = FXARGB_B(argb);
-    if (clip_scan && clip_scan[col] < 255) {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
-    } else {
-      dest_scan[2] = src_b;
-      dest_scan[1] = src_g;
-      dest_scan[0] = src_r;
-    }
-    dest_scan += DestBpp;
-    src_scan++;
-  }
-}
-
-void CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   int src_left,
-                                                   FX_ARGB* pPalette,
-                                                   int pixel_count,
-                                                   int DestBpp,
-                                                   const uint8_t* clip_scan) {
-  int reset_r, reset_g, reset_b;
-  int set_r, set_g, set_b;
-  if (pPalette) {
-    reset_r = FXARGB_R(pPalette[0]);
-    reset_g = FXARGB_G(pPalette[0]);
-    reset_b = FXARGB_B(pPalette[0]);
-    set_r = FXARGB_R(pPalette[1]);
-    set_g = FXARGB_G(pPalette[1]);
-    set_b = FXARGB_B(pPalette[1]);
-  } else {
-    reset_r = reset_g = reset_b = 0;
-    set_r = set_g = set_b = 255;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    int src_r, src_g, src_b;
-    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
-      src_r = set_r;
-      src_g = set_g;
-      src_b = set_b;
-    } else {
-      src_r = reset_r;
-      src_g = reset_g;
-      src_b = reset_b;
-    }
-    if (clip_scan && clip_scan[col] < 255) {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
-    } else {
-      dest_scan[2] = src_b;
-      dest_scan[1] = src_g;
-      dest_scan[0] = src_r;
-    }
-    dest_scan += DestBpp;
-  }
-}
-
-void CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
-                                                    const uint8_t* src_scan,
-                                                    int width,
-                                                    FX_ARGB* pPalette,
-                                                    const uint8_t* clip_scan) {
-  for (int col = 0; col < width; col++) {
-    int src_r, src_g, src_b;
-    if (pPalette) {
-      FX_ARGB argb = pPalette[*src_scan];
-      src_r = FXARGB_R(argb);
-      src_g = FXARGB_G(argb);
-      src_b = FXARGB_B(argb);
-    } else {
-      src_r = src_g = src_b = *src_scan;
-    }
-    if (!clip_scan || clip_scan[col] == 255) {
-      dest_scan[2] = src_b;
-      dest_scan[1] = src_g;
-      dest_scan[0] = src_r;
-      dest_scan[3] = 255;
-      src_scan++;
-      dest_scan += 4;
-      continue;
-    }
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      src_scan++;
-      continue;
-    }
-    int back_alpha = dest_scan[3];
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
-    dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
-    dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
-    dest_scan += 4;
-    src_scan++;
-  }
-}
-
-void CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan,
-                                                    const uint8_t* src_scan,
-                                                    int src_left,
-                                                    int width,
-                                                    FX_ARGB* pPalette,
-                                                    const uint8_t* clip_scan) {
-  int reset_r, reset_g, reset_b;
-  int set_r, set_g, set_b;
-  if (pPalette) {
-    reset_r = FXARGB_R(pPalette[0]);
-    reset_g = FXARGB_G(pPalette[0]);
-    reset_b = FXARGB_B(pPalette[0]);
-    set_r = FXARGB_R(pPalette[1]);
-    set_g = FXARGB_G(pPalette[1]);
-    set_b = FXARGB_B(pPalette[1]);
-  } else {
-    reset_r = reset_g = reset_b = 0;
-    set_r = set_g = set_b = 255;
-  }
-  for (int col = 0; col < width; col++) {
-    int src_r, src_g, src_b;
-    if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
-      src_r = set_r;
-      src_g = set_g;
-      src_b = set_b;
-    } else {
-      src_r = reset_r;
-      src_g = reset_g;
-      src_b = reset_b;
-    }
-    if (!clip_scan || clip_scan[col] == 255) {
-      dest_scan[2] = src_b;
-      dest_scan[1] = src_g;
-      dest_scan[0] = src_r;
-      dest_scan[3] = 255;
-      dest_scan += 4;
-      continue;
-    }
-    int src_alpha = clip_scan[col];
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      continue;
-    }
-    int back_alpha = dest_scan[3];
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
-    dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
-    dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
-    dest_scan += 4;
-  }
-}
-
-void CompositeRow_ByteMask2Argb_RgbByteOrder(uint8_t* dest_scan,
-                                             const uint8_t* src_scan,
-                                             int mask_alpha,
-                                             int src_r,
-                                             int src_g,
-                                             int src_b,
-                                             int pixel_count,
-                                             int blend_type,
-                                             const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      FXARGB_SETRGBORDERDIB(dest_scan,
-                            FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
-      dest_scan += 4;
-      continue;
-    }
-    if (src_alpha == 0) {
-      dest_scan += 4;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
-      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
-      dest_scan[2] =
-          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
-      dest_scan[1] =
-          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
-      dest_scan[0] =
-          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, dest_scan[2], src_b);
-      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
-      blended = Blend(blend_type, dest_scan[1], src_g);
-      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio);
-      blended = Blend(blend_type, dest_scan[0], src_r);
-      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
-    } else {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
-    }
-    dest_scan += 4;
-  }
-}
-
-void CompositeRow_ByteMask2Rgb_RgbByteOrder(uint8_t* dest_scan,
-                                            const uint8_t* src_scan,
-                                            int mask_alpha,
-                                            int src_r,
-                                            int src_g,
-                                            int src_b,
-                                            int pixel_count,
-                                            int blend_type,
-                                            int Bpp,
-                                            const uint8_t* clip_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
-    } else {
-      src_alpha = mask_alpha * src_scan[col] / 255;
-    }
-    if (src_alpha == 0) {
-      dest_scan += Bpp;
-      continue;
-    }
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
-      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
-      dest_scan[2] =
-          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
-      dest_scan[1] =
-          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
-      dest_scan[0] =
-          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, dest_scan[2], src_b);
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, src_alpha);
-      blended = Blend(blend_type, dest_scan[1], src_g);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, src_alpha);
-      blended = Blend(blend_type, dest_scan[0], src_r);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, src_alpha);
-    } else {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
-    }
-    dest_scan += Bpp;
-  }
-}
-
-void CompositeRow_BitMask2Argb_RgbByteOrder(uint8_t* dest_scan,
-                                            const uint8_t* src_scan,
-                                            int mask_alpha,
-                                            int src_r,
-                                            int src_g,
-                                            int src_b,
-                                            int src_left,
-                                            int pixel_count,
-                                            int blend_type,
-                                            const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
-    FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
-    for (int col = 0; col < pixel_count; col++) {
-      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
-        FXARGB_SETRGBORDERDIB(dest_scan, argb);
-      }
-      dest_scan += 4;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan += 4;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    uint8_t back_alpha = dest_scan[3];
-    if (back_alpha == 0) {
-      FXARGB_SETRGBORDERDIB(dest_scan,
-                            FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
-      dest_scan += 4;
-      continue;
-    }
-    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
-    dest_scan[3] = dest_alpha;
-    int alpha_ratio = src_alpha * 255 / dest_alpha;
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
-      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
-      dest_scan[2] =
-          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
-      dest_scan[1] =
-          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
-      dest_scan[0] =
-          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
-    } else if (blend_type) {
-      int blended = Blend(blend_type, dest_scan[2], src_b);
-      blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
-      blended = Blend(blend_type, dest_scan[1], src_g);
-      blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio);
-      blended = Blend(blend_type, dest_scan[0], src_r);
-      blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
-    } else {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
-    }
-    dest_scan += 4;
-  }
-}
-
-void CompositeRow_BitMask2Rgb_RgbByteOrder(uint8_t* dest_scan,
-                                           const uint8_t* src_scan,
-                                           int mask_alpha,
-                                           int src_r,
-                                           int src_g,
-                                           int src_b,
-                                           int src_left,
-                                           int pixel_count,
-                                           int blend_type,
-                                           int Bpp,
-                                           const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
-    for (int col = 0; col < pixel_count; col++) {
-      if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
-        dest_scan[2] = src_b;
-        dest_scan[1] = src_g;
-        dest_scan[0] = src_r;
-      }
-      dest_scan += Bpp;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan += Bpp;
-      continue;
-    }
-    int src_alpha;
-    if (clip_scan) {
-      src_alpha = mask_alpha * clip_scan[col] / 255;
-    } else {
-      src_alpha = mask_alpha;
-    }
-    if (src_alpha == 0) {
-      dest_scan += Bpp;
-      continue;
-    }
-    if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
-      int blended_colors[3];
-      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
-                         static_cast<uint8_t>(src_g),
-                         static_cast<uint8_t>(src_r)};
-      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
-      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
-      dest_scan[2] =
-          FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
-      dest_scan[1] =
-          FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
-      dest_scan[0] =
-          FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
-    } else if (blend_type) {
-      int back_color = dest_scan[2];
-      int blended = Blend(blend_type, back_color, src_b);
-      dest_scan[2] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-      back_color = dest_scan[1];
-      blended = Blend(blend_type, back_color, src_g);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-      back_color = dest_scan[0];
-      blended = Blend(blend_type, back_color, src_r);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
-    } else {
-      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
-      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
-      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
-    }
-    dest_scan += Bpp;
-  }
-}
-
-bool ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
-                                       int alpha_flag,
-                                       uint32_t mask_color,
-                                       int& mask_alpha,
-                                       int& mask_red,
-                                       int& mask_green,
-                                       int& mask_blue,
-                                       int& mask_black,
-                                       CCodec_IccModule* pIccModule,
-                                       void* pIccTransform) {
-  if (alpha_flag >> 8) {
-    mask_alpha = alpha_flag & 0xff;
-    mask_red = FXSYS_GetCValue(mask_color);
-    mask_green = FXSYS_GetMValue(mask_color);
-    mask_blue = FXSYS_GetYValue(mask_color);
-    mask_black = FXSYS_GetKValue(mask_color);
-  } else {
-    mask_alpha = FXARGB_A(mask_color);
-    mask_red = FXARGB_R(mask_color);
-    mask_green = FXARGB_G(mask_color);
-    mask_blue = FXARGB_B(mask_color);
-  }
-  if (dest_format == FXDIB_8bppMask) {
-    return true;
-  }
-  if ((dest_format & 0xff) == 8) {
-    if (pIccTransform) {
-      mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color)
-                                     : FXARGB_TODIB(mask_color);
-      uint8_t* gray_p = (uint8_t*)&mask_color;
-      pIccModule->TranslateScanline(pIccTransform, gray_p, gray_p, 1);
-      mask_red = dest_format & 0x0400 ? FX_CCOLOR(gray_p[0]) : gray_p[0];
-    } else {
-      if (alpha_flag >> 8) {
-        uint8_t r, g, b;
-        AdobeCMYK_to_sRGB1(mask_red, mask_green, mask_blue, mask_black, r, g,
-                           b);
-        mask_red = FXRGB2GRAY(r, g, b);
-      } else {
-        mask_red = FXRGB2GRAY(mask_red, mask_green, mask_blue);
-      }
-      if (dest_format & 0x0400) {
-        mask_red = FX_CCOLOR(mask_red);
-      }
-    }
-  } else {
-    uint8_t* mask_color_p = (uint8_t*)&mask_color;
-    mask_color =
-        (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color);
-    if (pIccTransform) {
-      pIccModule->TranslateScanline(pIccTransform, mask_color_p, mask_color_p,
-                                    1);
-      mask_red = mask_color_p[2];
-      mask_green = mask_color_p[1];
-      mask_blue = mask_color_p[0];
-    } else if (alpha_flag >> 8) {
-      AdobeCMYK_to_sRGB1(mask_color_p[0], mask_color_p[1], mask_color_p[2],
-                         mask_color_p[3], mask_color_p[2], mask_color_p[1],
-                         mask_color_p[0]);
-      mask_red = mask_color_p[2];
-      mask_green = mask_color_p[1];
-      mask_blue = mask_color_p[0];
-    }
-  }
-  return true;
-}
-
-void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
-                                          FXDIB_Format dest_format,
-                                          uint32_t*& pDestPalette,
-                                          uint32_t* pSrcPalette,
-                                          CCodec_IccModule* pIccModule,
-                                          void* pIccTransform) {
-  bool isSrcCmyk = !!(src_format & 0x0400);
-  bool isDstCmyk = !!(dest_format & 0x0400);
-  pDestPalette = nullptr;
-  if (pIccTransform) {
-    if (pSrcPalette) {
-      if ((dest_format & 0xff) == 8) {
-        int pal_count = 1 << (src_format & 0xff);
-        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-        pDestPalette = (uint32_t*)gray_pal;
-        for (int i = 0; i < pal_count; i++) {
-          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
-                                     : FXARGB_TODIB(pSrcPalette[i]);
-          pIccModule->TranslateScanline(pIccTransform, gray_pal,
-                                        (const uint8_t*)&color, 1);
-          gray_pal++;
-        }
-      } else {
-        int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(uint32_t, palsize);
-        for (int i = 0; i < palsize; i++) {
-          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
-                                     : FXARGB_TODIB(pSrcPalette[i]);
-          pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color,
-                                        (const uint8_t*)&color, 1);
-          pDestPalette[i] =
-              isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-        }
-      }
-    } else {
-      int pal_count = 1 << (src_format & 0xff);
-      uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-      if (pal_count == 2) {
-        gray_pal[0] = 0;
-        gray_pal[1] = 255;
-      } else {
-        for (int i = 0; i < pal_count; i++) {
-          gray_pal[i] = i;
-        }
-      }
-      if ((dest_format & 0xff) == 8) {
-        pIccModule->TranslateScanline(pIccTransform, gray_pal, gray_pal,
-                                      pal_count);
-        pDestPalette = (uint32_t*)gray_pal;
-      } else {
-        pDestPalette = FX_Alloc(uint32_t, pal_count);
-        for (int i = 0; i < pal_count; i++) {
-          pIccModule->TranslateScanline(
-              pIccTransform, (uint8_t*)&pDestPalette[i], &gray_pal[i], 1);
-          pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(pDestPalette[i])
-                                      : FXARGB_TODIB(pDestPalette[i]);
-        }
-        FX_Free(gray_pal);
-      }
-    }
-  } else {
-    if (pSrcPalette) {
-      if ((dest_format & 0xff) == 8) {
-        int pal_count = 1 << (src_format & 0xff);
-        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-        pDestPalette = (uint32_t*)gray_pal;
-        if (isSrcCmyk) {
-          for (int i = 0; i < pal_count; i++) {
-            FX_CMYK cmyk = pSrcPalette[i];
-            uint8_t r, g, b;
-            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
-                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
-                               g, b);
-            *gray_pal++ = FXRGB2GRAY(r, g, b);
-          }
-        } else {
-          for (int i = 0; i < pal_count; i++) {
-            FX_ARGB argb = pSrcPalette[i];
-            *gray_pal++ =
-                FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
-          }
-        }
-      } else {
-        int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(uint32_t, palsize);
-        if (isDstCmyk == isSrcCmyk) {
-          FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t));
-        } else {
-          for (int i = 0; i < palsize; i++) {
-            FX_CMYK cmyk = pSrcPalette[i];
-            uint8_t r, g, b;
-            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
-                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
-                               g, b);
-            pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
-          }
-        }
-      }
-    } else {
-      if ((dest_format & 0xff) == 8) {
-        int pal_count = 1 << (src_format & 0xff);
-        uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-        if (pal_count == 2) {
-          gray_pal[0] = 0;
-          gray_pal[1] = 255;
-        } else {
-          for (int i = 0; i < pal_count; i++) {
-            gray_pal[i] = i;
-          }
-        }
-        pDestPalette = (uint32_t*)gray_pal;
-      } else {
-        int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(uint32_t, palsize);
-        if (palsize == 2) {
-          pDestPalette[0] = isSrcCmyk ? 255 : 0xff000000;
-          pDestPalette[1] = isSrcCmyk ? 0 : 0xffffffff;
-        } else {
-          for (int i = 0; i < palsize; i++) {
-            pDestPalette[i] = isSrcCmyk ? FX_CCOLOR(i) : (i * 0x10101);
-          }
-        }
-        if (isSrcCmyk != isDstCmyk) {
-          for (int i = 0; i < palsize; i++) {
-            FX_CMYK cmyk = pDestPalette[i];
-            uint8_t r, g, b;
-            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
-                               FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
-                               g, b);
-            pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
-          }
-        }
-      }
-    }
-  }
-}
-
-}  // namespace
-
-CFX_ScanlineCompositor::CFX_ScanlineCompositor() {
-  m_pSrcPalette = nullptr;
-  m_pCacheScanline = nullptr;
-  m_CacheSize = 0;
-  m_bRgbByteOrder = false;
-  m_BlendType = FXDIB_BLEND_NORMAL;
-  m_pIccTransform = nullptr;
-}
-
-CFX_ScanlineCompositor::~CFX_ScanlineCompositor() {
-  FX_Free(m_pSrcPalette);
-  FX_Free(m_pCacheScanline);
-}
-
-bool CFX_ScanlineCompositor::Init(FXDIB_Format dest_format,
-                                  FXDIB_Format src_format,
-                                  int32_t width,
-                                  uint32_t* pSrcPalette,
-                                  uint32_t mask_color,
-                                  int blend_type,
-                                  bool bClip,
-                                  bool bRgbByteOrder,
-                                  int alpha_flag,
-                                  void* pIccTransform) {
-  m_SrcFormat = src_format;
-  m_DestFormat = dest_format;
-  m_BlendType = blend_type;
-  m_bRgbByteOrder = bRgbByteOrder;
-  CCodec_IccModule* pIccModule = nullptr;
-  if (CFX_GEModule::Get()->GetCodecModule()) {
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  }
-  if (!pIccModule) {
-    pIccTransform = nullptr;
-  }
-  m_pIccTransform = pIccTransform;
-  if ((dest_format & 0xff) == 1) {
-    return false;
-  }
-  if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
-    return ScanlineCompositor_InitSourceMask(
-        dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed,
-        m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform);
-  }
-  if (!pIccTransform && (~src_format & 0x0400) && (dest_format & 0x0400)) {
-    return false;
-  }
-  if ((m_SrcFormat & 0xff) <= 8) {
-    if (dest_format == FXDIB_8bppMask) {
-      return true;
-    }
-    ScanlineCompositor_InitSourcePalette(src_format, dest_format, m_pSrcPalette,
-                                         pSrcPalette, pIccModule,
-                                         pIccTransform);
-    m_Transparency =
-        (dest_format == FXDIB_Argb ? 1 : 0) + (dest_format & 0x0200 ? 2 : 0) +
-        (dest_format & 0x0400 ? 4 : 0) + ((src_format & 0xff) == 1 ? 8 : 0);
-    return true;
-  }
-  m_Transparency = (src_format & 0x0200 ? 0 : 1) +
-                   (dest_format & 0x0200 ? 0 : 2) +
-                   (blend_type == FXDIB_BLEND_NORMAL ? 4 : 0) +
-                   (bClip ? 8 : 0) + (src_format & 0x0400 ? 16 : 0) +
-                   (dest_format & 0x0400 ? 32 : 0) + (pIccTransform ? 64 : 0);
-  return true;
-}
-
-void CFX_ScanlineCompositor::CompositeRgbBitmapLine(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int width,
-    const uint8_t* clip_scan,
-    const uint8_t* src_extra_alpha,
-    uint8_t* dst_extra_alpha) {
-  int src_Bpp = (m_SrcFormat & 0xff) >> 3;
-  int dest_Bpp = (m_DestFormat & 0xff) >> 3;
-  if (m_bRgbByteOrder) {
-    switch (m_Transparency) {
-      case 0:
-      case 4:
-      case 8:
-      case 12:
-        CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width,
-                                            m_BlendType, clip_scan);
-        break;
-      case 1:
-        CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp);
-        break;
-      case 2:
-      case 10:
-        CompositeRow_Argb2Rgb_Blend_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan);
-        break;
-      case 3:
-        CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp);
-        break;
-      case 5:
-        CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(dest_scan, src_scan,
-                                                          width, src_Bpp);
-        break;
-      case 6:
-      case 14:
-        CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, width,
-                                                   dest_Bpp, clip_scan);
-        break;
-      case 7:
-        CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp);
-        break;
-      case 9:
-        CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan);
-        break;
-      case 11:
-        CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(dest_scan, src_scan, width,
-                                                     m_BlendType, dest_Bpp,
-                                                     src_Bpp, clip_scan);
-        break;
-      case 13:
-        CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, src_Bpp, clip_scan);
-        break;
-      case 15:
-        CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan);
-        break;
-    }
-    return;
-  }
-  if (m_DestFormat == FXDIB_8bppMask) {
-    if (m_SrcFormat & 0x0200) {
-      if (m_SrcFormat == FXDIB_Argb) {
-        CompositeRow_AlphaToMask(dest_scan, src_scan, width, clip_scan, 4);
-      } else {
-        CompositeRow_AlphaToMask(dest_scan, src_extra_alpha, width, clip_scan,
-                                 1);
-      }
-    } else {
-      CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
-    }
-  } else if ((m_DestFormat & 0xff) == 8) {
-    if (m_DestFormat & 0x0400) {
-      for (int i = 0; i < width; i++) {
-        *dest_scan = ~*dest_scan;
-        dest_scan++;
-      }
-    }
-    if (m_SrcFormat & 0x0200) {
-      if (m_DestFormat & 0x0200) {
-        CompositeRow_Argb2Graya(dest_scan, src_scan, width, m_BlendType,
-                                clip_scan, src_extra_alpha, dst_extra_alpha,
-                                m_pIccTransform);
-      } else {
-        CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType,
-                               clip_scan, src_extra_alpha, m_pIccTransform);
-      }
-    } else {
-      if (m_DestFormat & 0x0200) {
-        CompositeRow_Rgb2Graya(dest_scan, src_scan, src_Bpp, width, m_BlendType,
-                               clip_scan, dst_extra_alpha, m_pIccTransform);
-      } else {
-        CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType,
-                              clip_scan, m_pIccTransform);
-      }
-    }
-    if (m_DestFormat & 0x0400) {
-      for (int i = 0; i < width; i++) {
-        *dest_scan = ~*dest_scan;
-        dest_scan++;
-      }
-    }
-  } else {
-    int dest_Size = width * dest_Bpp + 4;
-    if (dest_Size > m_CacheSize) {
-      m_pCacheScanline = FX_Realloc(uint8_t, m_pCacheScanline, dest_Size);
-      if (!m_pCacheScanline) {
-        return;
-      }
-      m_CacheSize = dest_Size;
-    }
-    switch (m_Transparency) {
-      case 0:
-      case 4:
-      case 8:
-      case 4 + 8: {
-        CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType,
-                               clip_scan, dst_extra_alpha, src_extra_alpha);
-      } break;
-      case 64:
-      case 4 + 64:
-      case 8 + 64:
-      case 4 + 8 + 64: {
-        CompositeRow_Argb2Argb_Transform(
-            dest_scan, src_scan, width, m_BlendType, clip_scan, dst_extra_alpha,
-            src_extra_alpha, m_pCacheScanline, m_pIccTransform);
-      } break;
-      case 1:
-        CompositeRow_Rgb2Argb_Blend_NoClip(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha);
-        break;
-      case 1 + 64:
-        CompositeRow_Rgb2Argb_Blend_NoClip_Transform(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 8:
-        CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan, width,
-                                         m_BlendType, src_Bpp, clip_scan,
-                                         dst_extra_alpha);
-        break;
-      case 1 + 8 + 64:
-        CompositeRow_Rgb2Argb_Blend_Clip_Transform(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan,
-            dst_extra_alpha, m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 4:
-        CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width,
-                                             src_Bpp, dst_extra_alpha);
-        break;
-      case 1 + 4 + 64:
-        CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(
-            dest_scan, src_scan, width, src_Bpp, dst_extra_alpha,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 4 + 8:
-        CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan, width, src_Bpp,
-                                           clip_scan, dst_extra_alpha);
-        break;
-      case 1 + 4 + 8 + 64:
-        CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(
-            dest_scan, src_scan, width, src_Bpp, clip_scan, dst_extra_alpha,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-      case 2:
-      case 2 + 8:
-        CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan, width, m_BlendType,
-                                    dest_Bpp, clip_scan, src_extra_alpha);
-        break;
-      case 2 + 64:
-      case 2 + 8 + 64:
-        CompositeRow_Argb2Rgb_Blend_Transform(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan,
-            src_extra_alpha, m_pCacheScanline, m_pIccTransform);
-        break;
-      case 2 + 4:
-      case 2 + 4 + 8:
-        CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan, width, dest_Bpp,
-                                      clip_scan, src_extra_alpha);
-        break;
-      case 2 + 4 + 64:
-      case 2 + 4 + 8 + 64:
-        CompositeRow_Argb2Rgb_NoBlend_Transform(
-            dest_scan, src_scan, width, dest_Bpp, clip_scan, src_extra_alpha,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 2:
-        CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan, width,
-                                          m_BlendType, dest_Bpp, src_Bpp);
-        break;
-      case 1 + 2 + 64:
-        CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 2 + 8:
-        CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_scan, width, m_BlendType,
-                                        dest_Bpp, src_Bpp, clip_scan);
-        break;
-      case 1 + 2 + 8 + 64:
-        CompositeRow_Rgb2Rgb_Blend_Clip_Transform(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp,
-            clip_scan, m_pCacheScanline, m_pIccTransform);
-        break;
-      case 1 + 2 + 4:
-        CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan, width,
-                                            dest_Bpp, src_Bpp);
-        break;
-      case 1 + 2 + 4 + 64:
-        CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp, m_pCacheScanline,
-            m_pIccTransform);
-        break;
-      case 1 + 2 + 4 + 8:
-        CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan, width, dest_Bpp,
-                                          src_Bpp, clip_scan);
-        break;
-      case 1 + 2 + 4 + 8 + 64:
-        CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan,
-            m_pCacheScanline, m_pIccTransform);
-        break;
-    }
-  }
-}
-
-void CFX_ScanlineCompositor::CompositePalBitmapLine(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int src_left,
-    int width,
-    const uint8_t* clip_scan,
-    const uint8_t* src_extra_alpha,
-    uint8_t* dst_extra_alpha) {
-  if (m_bRgbByteOrder) {
-    if (m_SrcFormat == FXDIB_1bppRgb) {
-      if (m_DestFormat == FXDIB_8bppRgb) {
-        return;
-      }
-      if (m_DestFormat == FXDIB_Argb) {
-        CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan);
-      } else {
-        CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, src_left, m_pSrcPalette, width,
-            (m_DestFormat & 0xff) >> 3, clip_scan);
-      }
-    } else {
-      if (m_DestFormat == FXDIB_8bppRgb) {
-        return;
-      }
-      if (m_DestFormat == FXDIB_Argb) {
-        CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, width, m_pSrcPalette, clip_scan);
-      } else {
-        CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, m_pSrcPalette, width,
-            (m_DestFormat & 0xff) >> 3, clip_scan);
-      }
-    }
-    return;
-  }
-  if (m_DestFormat == FXDIB_8bppMask) {
-    CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
-    return;
-  }
-  if ((m_DestFormat & 0xff) == 8) {
-    if (m_Transparency & 8) {
-      if (m_DestFormat & 0x0200) {
-        CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left,
-                                   (const uint8_t*)m_pSrcPalette, width,
-                                   m_BlendType, clip_scan, dst_extra_alpha);
-      } else {
-        CompositeRow_1bppPal2Gray(dest_scan, src_scan, src_left,
-                                  (const uint8_t*)m_pSrcPalette, width,
-                                  m_BlendType, clip_scan);
-      }
-    } else {
-      if (m_DestFormat & 0x0200)
-        CompositeRow_8bppPal2Graya(
-            dest_scan, src_scan, (const uint8_t*)m_pSrcPalette, width,
-            m_BlendType, clip_scan, dst_extra_alpha, src_extra_alpha);
-      else
-        CompositeRow_8bppPal2Gray(dest_scan, src_scan,
-                                  (const uint8_t*)m_pSrcPalette, width,
-                                  m_BlendType, clip_scan, src_extra_alpha);
-    }
-  } else {
-    switch (m_Transparency) {
-      case 1 + 2:
-        CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width,
-                                          m_pSrcPalette, clip_scan,
-                                          src_extra_alpha);
-        break;
-      case 1 + 2 + 8:
-        CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width,
-                                          m_pSrcPalette, clip_scan);
-        break;
-      case 0:
-        CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette,
-                                         width, (m_DestFormat & 0xff) >> 3,
-                                         clip_scan, src_extra_alpha);
-        break;
-      case 0 + 8:
-        CompositeRow_1bppRgb2Rgb_NoBlend(dest_scan, src_scan, src_left,
-                                         m_pSrcPalette, width,
-                                         (m_DestFormat & 0xff) >> 3, clip_scan);
-        break;
-      case 0 + 2:
-        CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette,
-                                         width, (m_DestFormat & 0xff) >> 3,
-                                         clip_scan, src_extra_alpha);
-        break;
-      case 0 + 2 + 8:
-        CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width,
-                                          m_pSrcPalette, clip_scan,
-                                          dst_extra_alpha);
-        break;
-        break;
-    }
-  }
-}
-
-void CFX_ScanlineCompositor::CompositeByteMaskLine(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   int width,
-                                                   const uint8_t* clip_scan,
-                                                   uint8_t* dst_extra_alpha) {
-  if (m_DestFormat == FXDIB_8bppMask) {
-    CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width,
-                               clip_scan);
-  } else if ((m_DestFormat & 0xff) == 8) {
-    if (m_DestFormat & 0x0200) {
-      CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                  width, clip_scan, dst_extra_alpha);
-    } else {
-      CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                 width, clip_scan);
-    }
-  } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb) {
-      CompositeRow_ByteMask2Argb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          width, m_BlendType, clip_scan);
-    } else {
-      CompositeRow_ByteMask2Rgb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
-    }
-    return;
-  } else if (m_DestFormat == FXDIB_Argb) {
-    CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                               clip_scan);
-  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
-    CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                              m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                              (m_DestFormat & 0xff) >> 3, clip_scan);
-  } else if (m_DestFormat == FXDIB_Rgba) {
-    CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                               clip_scan, dst_extra_alpha);
-  }
-}
-
-void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int src_left,
-                                                  int width,
-                                                  const uint8_t* clip_scan,
-                                                  uint8_t* dst_extra_alpha) {
-  if (m_DestFormat == FXDIB_8bppMask) {
-    CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width,
-                              clip_scan);
-  } else if ((m_DestFormat & 0xff) == 8) {
-    if (m_DestFormat & 0x0200) {
-      CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                 src_left, width, clip_scan, dst_extra_alpha);
-    } else {
-      CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                src_left, width, clip_scan);
-    }
-  } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb) {
-      CompositeRow_BitMask2Argb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          src_left, width, m_BlendType, clip_scan);
-    } else {
-      CompositeRow_BitMask2Rgb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
-    }
-    return;
-  } else if (m_DestFormat == FXDIB_Argb) {
-    CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                              m_MaskGreen, m_MaskBlue, src_left, width,
-                              m_BlendType, clip_scan);
-  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
-    CompositeRow_BitMask2Rgb(
-        dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-        src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
-  }
-}
-
 bool CFX_DIBitmap::CompositeBitmap(
     int dest_left,
     int dest_top,
diff --git a/core/fxge/dib/fx_dib_main.cpp b/core/fxge/dib/fx_dib_main.cpp
index 7ee2ee58ee..0d9e79c27e 100644
--- a/core/fxge/dib/fx_dib_main.cpp
+++ b/core/fxge/dib/fx_dib_main.cpp
@@ -1083,39 +1083,6 @@ CFX_DIBExtractor::CFX_DIBExtractor(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
 
 CFX_DIBExtractor::~CFX_DIBExtractor() {}
 
-CFX_FilteredDIB::CFX_FilteredDIB() {}
-
-CFX_FilteredDIB::~CFX_FilteredDIB() {}
-
-void CFX_FilteredDIB::LoadSrc(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
-  m_pSrc = pSrc;
-  m_Width = pSrc->GetWidth();
-  m_Height = pSrc->GetHeight();
-  FXDIB_Format format = GetDestFormat();
-  m_bpp = (uint8_t)format;
-  m_AlphaFlag = (uint8_t)(format >> 8);
-  m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
-  m_pPalette.reset(GetDestPalette());
-  m_Scanline.resize(m_Pitch);
-}
-
-const uint8_t* CFX_FilteredDIB::GetScanline(int line) const {
-  TranslateScanline(m_pSrc->GetScanline(line), &m_Scanline);
-  return m_Scanline.data();
-}
-
-void CFX_FilteredDIB::DownSampleScanline(int line,
-                                         uint8_t* dest_scan,
-                                         int dest_bpp,
-                                         int dest_width,
-                                         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_pIccTransform = nullptr;
diff --git a/core/fxge/fx_dib.h b/core/fxge/fx_dib.h
index 85af766992..f768afddaa 100644
--- a/core/fxge/fx_dib.h
+++ b/core/fxge/fx_dib.h
@@ -15,6 +15,7 @@
 #include "core/fxcrt/fx_coordinates.h"
 #include "core/fxge/dib/cfx_dibitmap.h"
 #include "core/fxge/dib/cfx_dibsource.h"
+#include "core/fxge/dib/cfx_scanlinecompositor.h"
 #include "third_party/base/stl_util.h"
 
 typedef uint32_t FX_ARGB;
@@ -142,64 +143,6 @@ class IFX_ScanlineComposer {
                        uint32_t* pSrcPalette) = 0;
 };
 
-class CFX_ScanlineCompositor {
- public:
-  CFX_ScanlineCompositor();
-
-  ~CFX_ScanlineCompositor();
-
-  bool Init(FXDIB_Format dest_format,
-            FXDIB_Format src_format,
-            int32_t width,
-            uint32_t* pSrcPalette,
-            uint32_t mask_color,
-            int blend_type,
-            bool bClip,
-            bool bRgbByteOrder = false,
-            int alpha_flag = 0,
-            void* pIccTransform = nullptr);
-
-  void CompositeRgbBitmapLine(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
-                              int width,
-                              const uint8_t* clip_scan,
-                              const uint8_t* src_extra_alpha = nullptr,
-                              uint8_t* dst_extra_alpha = nullptr);
-
-  void CompositePalBitmapLine(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
-                              int src_left,
-                              int width,
-                              const uint8_t* clip_scan,
-                              const uint8_t* src_extra_alpha = nullptr,
-                              uint8_t* dst_extra_alpha = nullptr);
-
-  void CompositeByteMaskLine(uint8_t* dest_scan,
-                             const uint8_t* src_scan,
-                             int width,
-                             const uint8_t* clip_scan,
-                             uint8_t* dst_extra_alpha = nullptr);
-
-  void CompositeBitMaskLine(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
-                            int src_left,
-                            int width,
-                            const uint8_t* clip_scan,
-                            uint8_t* dst_extra_alpha = nullptr);
-
- protected:
-  int m_Transparency;
-  FXDIB_Format m_SrcFormat, m_DestFormat;
-  uint32_t* m_pSrcPalette;
-
-  int m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, m_MaskBlack;
-  int m_BlendType;
-  void* m_pIccTransform;
-  uint8_t* m_pCacheScanline;
-  int m_CacheSize;
-  bool m_bRgbByteOrder;
-};
-
 class CFX_BitmapComposer : public IFX_ScanlineComposer {
  public:
   CFX_BitmapComposer();