diff --git a/core/fxge/agg/fx_agg_driver.cpp b/core/fxge/agg/fx_agg_driver.cpp
index 98bce9b..6726877 100644
--- a/core/fxge/agg/fx_agg_driver.cpp
+++ b/core/fxge/agg/fx_agg_driver.cpp
@@ -200,10 +200,10 @@
                                          FX_BOOL bGroupKnockout) {
   m_pBitmap = pBitmap;
   m_DitherBits = dither_bits;
-  m_pClipRgn = NULL;
-  m_pPlatformBitmap = NULL;
-  m_pPlatformGraphics = NULL;
-  m_pDwRenderTartget = NULL;
+  m_pClipRgn = nullptr;
+  m_pPlatformBitmap = nullptr;
+  m_pPlatformGraphics = nullptr;
+  m_pDwRenderTartget = nullptr;
   m_bRgbByteOrder = bRgbByteOrder;
   m_pOriDevice = pOriDevice;
   m_bGroupKnockout = bGroupKnockout;
@@ -277,7 +277,7 @@
 }
 
 void CFX_AggDeviceDriver::SaveState() {
-  CFX_ClipRgn* pClip = NULL;
+  CFX_ClipRgn* pClip = nullptr;
   if (m_pClipRgn) {
     pClip = new CFX_ClipRgn(*m_pClipRgn);
   }
@@ -287,12 +287,12 @@
 void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
   if (m_StateStack.GetSize() == 0) {
     delete m_pClipRgn;
-    m_pClipRgn = NULL;
+    m_pClipRgn = nullptr;
     return;
   }
   CFX_ClipRgn* pSavedClip = m_StateStack[m_StateStack.GetSize() - 1];
   delete m_pClipRgn;
-  m_pClipRgn = NULL;
+  m_pClipRgn = nullptr;
   if (bKeepSaved) {
     if (pSavedClip) {
       m_pClipRgn = new CFX_ClipRgn(*pSavedClip);
@@ -370,7 +370,7 @@
                                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   CAgg_PathData path_data;
-  path_data.BuildPath(pPathData, NULL);
+  path_data.BuildPath(pPathData, nullptr);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
@@ -1028,13 +1028,13 @@
       return;
     }
     uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
-    uint8_t* dest_scan_extra_alpha = NULL;
+    uint8_t* dest_scan_extra_alpha = nullptr;
     CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
     if (pAlphaMask) {
       dest_scan_extra_alpha =
           pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y;
     }
-    uint8_t* ori_scan = NULL;
+    uint8_t* ori_scan = nullptr;
     if (m_pOriDevice) {
       ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
     }
@@ -1045,19 +1045,19 @@
     while (1) {
       int x = span->x;
       ASSERT(span->len > 0);
-      uint8_t* dest_pos = NULL;
-      uint8_t* dest_extra_alpha_pos = NULL;
-      uint8_t* ori_pos = NULL;
+      uint8_t* dest_pos = nullptr;
+      uint8_t* dest_extra_alpha_pos = nullptr;
+      uint8_t* ori_pos = nullptr;
       if (Bpp) {
-        ori_pos = ori_scan ? ori_scan + x * Bpp : NULL;
+        ori_pos = ori_scan ? ori_scan + x * Bpp : nullptr;
         dest_pos = dest_scan + x * Bpp;
         dest_extra_alpha_pos =
-            dest_scan_extra_alpha ? dest_scan_extra_alpha + x : NULL;
+            dest_scan_extra_alpha ? dest_scan_extra_alpha + x : nullptr;
       } else {
         dest_pos = dest_scan + x / 8;
-        ori_pos = ori_scan ? ori_scan + x / 8 : NULL;
+        ori_pos = ori_scan ? ori_scan + x / 8 : nullptr;
       }
-      uint8_t* clip_pos = NULL;
+      uint8_t* clip_pos = nullptr;
       if (m_pClipMask) {
         clip_pos = m_pClipMask->GetBuffer() +
                    (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x -
@@ -1085,10 +1085,10 @@
                FX_BOOL bFullCover,
                FX_BOOL bRgbByteOrder,
                int alpha_flag = 0,
-               void* pIccTransform = NULL) {
+               void* pIccTransform = nullptr) {
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
-    composite_span = NULL;
+    composite_span = nullptr;
     m_bRgbByteOrder = bRgbByteOrder;
     m_pOriDevice = pOriDevice;
     if (m_pClipRgn) {
@@ -1098,7 +1098,7 @@
       m_ClipBox.right = m_pDevice->GetWidth();
       m_ClipBox.bottom = m_pDevice->GetHeight();
     }
-    m_pClipMask = NULL;
+    m_pClipMask = nullptr;
     if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
       m_pClipMask = m_pClipRgn->GetMask();
     }
@@ -1106,10 +1106,10 @@
     FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
     FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
     m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
-    CCodec_IccModule* pIccModule = NULL;
+    CCodec_IccModule* pIccModule = nullptr;
     if (!CFX_GEModule::Get()->GetCodecModule() ||
         !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-      pIccTransform = NULL;
+      pIccTransform = nullptr;
     } else {
       pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
@@ -1216,7 +1216,7 @@
     FX_BOOL bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
-  CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
+  CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : nullptr;
   CFX_Renderer render;
   if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
@@ -1270,7 +1270,7 @@
       rasterizer.clip_box(0.0f, 0.0f,
                           (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                           (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
-      RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1,
+      RasterizeStroke(rasterizer, path_data.m_PathData, nullptr, pGraphState, 1,
                       FALSE, fill_mode & FX_STROKE_TEXT_MODE);
       int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 |
                       FXGETFLAG_ALPHA_STROKE(alpha_flag);
@@ -1319,7 +1319,7 @@
   uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() +
                  x * pBitmap->GetBPP() / 8;
   if (pBitmap->GetFormat() == FXDIB_Argb) {
-    FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
+    FXARGB_SETRGBORDERDIB(pos, argb);
   } else {
     int alpha = FXARGB_A(argb);
     pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
@@ -1365,9 +1365,6 @@
     }
     return;
   }
-  src_r = FX_GAMMA(src_r);
-  src_g = FX_GAMMA(src_g);
-  src_b = FX_GAMMA(src_b);
   for (int row = rect.top; row < rect.bottom; row++) {
     uint8_t* dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
     if (bAlpha) {
@@ -1392,14 +1389,11 @@
       }
     } else {
       for (int col = 0; col < width; col++) {
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_r, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
         dest_scan++;
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_g, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
         dest_scan++;
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
         dest_scan++;
         if (Bpp == 4) {
           dest_scan++;
@@ -1422,7 +1416,7 @@
   }
   pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
                           pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
-                          src_left, src_top, NULL);
+                          src_left, src_top, nullptr);
   if (width == 0 || height == 0) {
     return;
   }
@@ -1477,21 +1471,11 @@
         uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
         uint8_t* src_scan =
             (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
-        if (src_format == FXDIB_Argb) {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]),
-                                                 FX_GAMMA(src_scan[1]),
-                                                 FX_GAMMA(src_scan[2])));
-            dest_scan += 4;
-            src_scan += 3;
-          }
-        } else {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
-                                                 src_scan[2]));
-            dest_scan += 4;
-            src_scan += 3;
-          }
+        for (int col = 0; col < width; col++) {
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
+                                               src_scan[2]));
+          dest_scan += 4;
+          src_scan += 3;
         }
       }
     } else if (src_format == FXDIB_Rgb32) {
@@ -1566,7 +1550,7 @@
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-    pIccTransform = NULL;
+    pIccTransform = nullptr;
   }
   if (!m_pClipRgn) {
     if (m_bRgbByteOrder) {
@@ -1639,7 +1623,7 @@
       draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(),
       (const CFX_DIBitmap*)m_pClipRgn->GetMask(), fill_color,
       draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top,
-      FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
+      FXDIB_BLEND_NORMAL, nullptr, m_bRgbByteOrder, alpha_flag, pIccTransform);
   return TRUE;
 }
 
@@ -1675,7 +1659,7 @@
   }
   FX_RECT rect(left, top, left + pBitmap->GetWidth(),
                top + pBitmap->GetHeight());
-  CFX_DIBitmap* pBack = NULL;
+  CFX_DIBitmap* pBack = nullptr;
   if (m_pOriDevice) {
     pBack = m_pOriDevice->Clone(&rect);
     if (!pBack) {
diff --git a/core/fxge/dib/fx_dib_composite.cpp b/core/fxge/dib/fx_dib_composite.cpp
index 18d73d1..282b93d 100644
--- a/core/fxge/dib/fx_dib_composite.cpp
+++ b/core/fxge/dib/fx_dib_composite.cpp
@@ -8,7 +8,9 @@
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/include/fx_ge.h"
 
-const uint8_t _color_sqrt[256] = {
+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,
@@ -31,7 +33,8 @@
     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) {
+
+int Blend(int blend_mode, int back_color, int src_color) {
   switch (blend_mode) {
     case FXDIB_BLEND_NORMAL:
       return src_color;
@@ -40,7 +43,7 @@
     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);
+      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:
@@ -69,7 +72,7 @@
       if (src_color < 128) {
         return (src_color * back_color * 2) / 255;
       }
-      return _BLEND(FXDIB_BLEND_SCREEN, back_color, 2 * src_color - 255);
+      return Blend(FXDIB_BLEND_SCREEN, back_color, 2 * src_color - 255);
     case FXDIB_BLEND_SOFTLIGHT: {
       if (src_color < 128) {
         return back_color -
@@ -77,7 +80,7 @@
                    255;
       }
       return back_color +
-             (2 * src_color - 255) * (_color_sqrt[back_color] - back_color) /
+             (2 * src_color - 255) * (color_sqrt[back_color] - back_color) /
                  255;
     }
     case FXDIB_BLEND_DIFFERENCE:
@@ -88,16 +91,19 @@
   }
   return src_color;
 }
-struct _RGB {
+
+struct RGB {
   int red;
   int green;
   int blue;
 };
-static inline int _Lum(_RGB color) {
+
+int Lum(RGB color) {
   return (color.red * 30 + color.green * 59 + color.blue * 11) / 100;
 }
-static _RGB _ClipColor(_RGB color) {
-  int l = _Lum(color);
+
+RGB ClipColor(RGB color) {
+  int l = Lum(color);
   int n = color.red;
   if (color.green < n) {
     n = color.green;
@@ -124,14 +130,16 @@
   }
   return color;
 }
-static _RGB _SetLum(_RGB color, int l) {
-  int d = l - _Lum(color);
+
+RGB SetLum(RGB color, int l) {
+  int d = l - Lum(color);
   color.red += d;
   color.green += d;
   color.blue += d;
-  return _ClipColor(color);
+  return ClipColor(color);
 }
-static int _Sat(_RGB color) {
+
+int Sat(RGB color) {
   int n = color.red;
   if (color.green < n) {
     n = color.green;
@@ -148,7 +156,8 @@
   }
   return x - n;
 }
-static _RGB _SetSat(_RGB color, int s) {
+
+RGB SetSat(RGB color, int s) {
   int* max = &color.red;
   int* mid = &color.red;
   int* min = &color.red;
@@ -196,13 +205,14 @@
   }
   return color;
 }
-void _RGB_Blend(int blend_mode,
-                const uint8_t* src_scan,
-                uint8_t* dest_scan,
-                int results[3]) {
-  _RGB src;
-  _RGB back;
-  _RGB result = {0, 0, 0};
+
+void RGB_Blend(int blend_mode,
+               const uint8_t* src_scan,
+               uint8_t* dest_scan,
+               int results[3]) {
+  RGB src;
+  RGB back;
+  RGB result = {0, 0, 0};
   src.red = src_scan[2];
   src.green = src_scan[1];
   src.blue = src_scan[0];
@@ -211,26 +221,27 @@
   back.blue = dest_scan[0];
   switch (blend_mode) {
     case FXDIB_BLEND_HUE:
-      result = _SetLum(_SetSat(src, _Sat(back)), _Lum(back));
+      result = SetLum(SetSat(src, Sat(back)), Lum(back));
       break;
     case FXDIB_BLEND_SATURATION:
-      result = _SetLum(_SetSat(back, _Sat(src)), _Lum(back));
+      result = SetLum(SetSat(back, Sat(src)), Lum(back));
       break;
     case FXDIB_BLEND_COLOR:
-      result = _SetLum(src, _Lum(back));
+      result = SetLum(src, Lum(back));
       break;
     case FXDIB_BLEND_LUMINOSITY:
-      result = _SetLum(back, _Lum(src));
+      result = SetLum(back, Lum(src));
       break;
   }
   results[0] = result.blue;
   results[1] = result.green;
   results[2] = result.red;
 }
-inline void _CompositeRow_Argb2Mask(uint8_t* dest_scan,
-                                    const uint8_t* src_scan,
-                                    int pixel_count,
-                                    const uint8_t* clip_scan) {
+
+void CompositeRow_Argb2Mask(uint8_t* dest_scan,
+                            const uint8_t* src_scan,
+                            int pixel_count,
+                            const uint8_t* clip_scan) {
   src_scan += 3;
   for (int col = 0; col < pixel_count; col++) {
     int src_alpha = *src_scan;
@@ -247,10 +258,11 @@
     src_scan += 4;
   }
 }
-void _CompositeRow_Rgba2Mask(uint8_t* dest_scan,
-                             const uint8_t* src_alpha_scan,
-                             int pixel_count,
-                             const uint8_t* clip_scan) {
+
+void CompositeRow_Rgba2Mask(uint8_t* dest_scan,
+                            const uint8_t* src_alpha_scan,
+                            int pixel_count,
+                            const uint8_t* clip_scan) {
   for (int col = 0; col < pixel_count; col++) {
     int src_alpha = *src_alpha_scan++;
     if (clip_scan) {
@@ -265,10 +277,11 @@
     dest_scan++;
   }
 }
-void _CompositeRow_Rgb2Mask(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
-                            int width,
-                            const uint8_t* clip_scan) {
+
+void CompositeRow_Rgb2Mask(uint8_t* dest_scan,
+                           const uint8_t* src_scan,
+                           int width,
+                           const uint8_t* clip_scan) {
   if (clip_scan) {
     for (int i = 0; i < width; i++) {
       *dest_scan = FXDIB_ALPHA_UNION(*dest_scan, *clip_scan);
@@ -279,14 +292,15 @@
     FXSYS_memset(dest_scan, 0xff, width);
   }
 }
-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) {
+
+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();
@@ -336,7 +350,7 @@
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
-          gray = _BLEND(blend_type, *dest_scan, gray);
+          gray = Blend(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
         dst_alpha_scan++;
@@ -483,13 +497,13 @@
   }
 }
 
-inline 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) {
+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)
@@ -512,7 +526,7 @@
           if (bNonseparableBlend)
             gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
           else
-            gray = _BLEND(blend_type, *dest_scan, gray);
+            gray = Blend(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
@@ -533,7 +547,7 @@
           if (bNonseparableBlend)
             gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
           else
-            gray = _BLEND(blend_type, *dest_scan, gray);
+            gray = Blend(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
@@ -579,13 +593,13 @@
   }
 }
 
-inline 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) {
+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) {
@@ -602,7 +616,7 @@
       if (bNonseparableBlend)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
-        gray = _BLEND(blend_type, *dest_scan, gray);
+        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 {
@@ -628,14 +642,15 @@
     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) {
+
+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();
@@ -678,7 +693,7 @@
       if (bNonseparableBlend)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
-        gray = _BLEND(blend_type, *dest_scan, gray);
+        gray = Blend(blend_type, *dest_scan, gray);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
       src_scan += src_Bpp;
@@ -722,13 +737,14 @@
     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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   if (!dest_alpha_scan) {
@@ -764,13 +780,13 @@
         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);
+          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);
+                              : 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 {
@@ -816,13 +832,13 @@
         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);
+          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);
+                              : 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 {
@@ -872,13 +888,13 @@
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (bNonseparableBlend) {
-          _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+          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);
+                              : 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 {
@@ -925,13 +941,13 @@
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (bNonseparableBlend) {
-          _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+          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);
+                              : 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 {
@@ -945,12 +961,13 @@
     }
   }
 }
-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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -967,13 +984,13 @@
       }
       *dest_alpha_scan++ = 0xff;
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+        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);
+                          : Blend(blend_type, *dest_scan, src_color);
         *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         dest_scan++;
         src_scan++;
@@ -996,13 +1013,13 @@
       }
       dest_scan[3] = 0xff;
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+        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);
+                          : Blend(blend_type, *dest_scan, src_color);
         *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         dest_scan++;
         src_scan++;
@@ -1012,13 +1029,14 @@
     }
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -1045,13 +1063,13 @@
       *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+        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);
+                          : 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++;
@@ -1081,13 +1099,13 @@
       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);
+        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);
+                          : 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++;
@@ -1098,12 +1116,13 @@
     }
   }
 }
-inline 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) {
+
+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++) {
@@ -1165,11 +1184,12 @@
     }
   }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int width,
-                                                  int src_Bpp,
-                                                  uint8_t* dest_alpha_scan) {
+
+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++) {
@@ -1192,13 +1212,14 @@
     }
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int dest_gap = dest_Bpp - 3;
@@ -1216,13 +1237,13 @@
         continue;
       }
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+        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);
+                          : Blend(blend_type, back_color, *src_scan);
         *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
         dest_scan++;
         src_scan++;
@@ -1243,13 +1264,13 @@
         continue;
       }
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+        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);
+                          : Blend(blend_type, back_color, *src_scan);
         *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
         dest_scan++;
         src_scan++;
@@ -1259,12 +1280,13 @@
     }
   }
 }
-inline 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) {
+
+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++) {
@@ -1324,26 +1346,27 @@
     }
   }
 }
-inline 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) {
+
+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];
   FX_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);
+      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);
+                        : Blend(blend_type, back_color, src_color);
       *dest_scan = blended;
       dest_scan++;
       src_scan++;
@@ -1352,13 +1375,14 @@
     src_scan += src_gap;
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int dest_gap = dest_Bpp - 3;
@@ -1371,14 +1395,14 @@
       continue;
     }
     if (bNonseparableBlend) {
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      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);
+                        : Blend(blend_type, back_color, src_color);
       *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
       dest_scan++;
       src_scan++;
@@ -1387,11 +1411,12 @@
     src_scan += src_gap;
   }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan,
-                                                 const uint8_t* src_scan,
-                                                 int width,
-                                                 int dest_Bpp,
-                                                 int src_Bpp) {
+
+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;
@@ -1404,12 +1429,13 @@
     src_scan += src_Bpp;
   }
 }
-inline 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) {
+
+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) {
@@ -1432,15 +1458,16 @@
     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) {
+
+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();
@@ -1454,7 +1481,7 @@
         src_scan += 3;
         dp += 4;
       }
-      src_alpha_scan = NULL;
+      src_alpha_scan = nullptr;
     }
   } else {
     if (dest_alpha_scan) {
@@ -1499,13 +1526,13 @@
         *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);
+          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);
+                              : 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 {
@@ -1525,17 +1552,18 @@
       dp += 4;
     }
   }
-  _CompositeRow_Argb2Argb(dest_scan, src_cache_scan, pixel_count, blend_type,
-                          clip_scan, dest_alpha_scan, src_alpha_scan);
+  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) {
+
+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) {
@@ -1549,19 +1577,19 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width,
-                                      blend_type, 3, dest_alpha_scan);
+  CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width,
+                                     blend_type, 3, dest_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1575,18 +1603,18 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width,
-                                    blend_type, 3, clip_scan, dest_alpha_scan);
+  CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
+                                   3, clip_scan, dest_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1600,17 +1628,17 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3,
-                                      clip_scan, dest_alpha_scan);
+  CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3,
+                                     clip_scan, dest_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1624,19 +1652,19 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3,
-                                        dest_alpha_scan);
+  CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3,
+                                       dest_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1661,13 +1689,13 @@
         continue;
       }
       if (bNonseparableBlend) {
-        _RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
+        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);
+                          : Blend(blend_type, back_color, *src_cache_scan);
         *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
         dest_scan++;
         src_cache_scan++;
@@ -1676,18 +1704,18 @@
     }
     return;
   }
-  _CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type,
-                               dest_Bpp, clip_scan, src_alpha_scan);
+  CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type,
+                              dest_Bpp, clip_scan, src_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1725,18 +1753,18 @@
     }
     return;
   }
-  _CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp,
-                                 clip_scan, src_alpha_scan);
+  CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp,
+                                clip_scan, src_alpha_scan);
 }
-inline 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) {
+
+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) {
@@ -1750,18 +1778,19 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width,
-                                     blend_type, dest_Bpp, 3);
+  CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width,
+                                    blend_type, dest_Bpp, 3);
 }
-inline 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) {
+
+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) {
@@ -1775,17 +1804,17 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
-                                   dest_Bpp, 3, clip_scan);
+  CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
+                                  dest_Bpp, 3, clip_scan);
 }
-inline 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) {
+
+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) {
@@ -1799,18 +1828,18 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width,
-                                       dest_Bpp, 3);
+  CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width,
+                                      dest_Bpp, 3);
 }
-inline 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) {
+
+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) {
@@ -1824,16 +1853,17 @@
       dp += 3;
     }
   }
-  _CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp,
-                                     3, clip_scan);
+  CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp,
+                                    3, clip_scan);
 }
-inline 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) {
+
+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) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
@@ -1846,7 +1876,7 @@
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
-          gray = _BLEND(blend_type, *dest_scan, gray);
+          gray = Blend(blend_type, *dest_scan, gray);
         if (src_alpha) {
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         } else {
@@ -1879,7 +1909,7 @@
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
-          gray = _BLEND(blend_type, *dest_scan, gray);
+          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 {
@@ -1902,14 +1932,15 @@
     }
   }
 }
-inline 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) {
+
+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) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
@@ -1945,7 +1976,7 @@
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
-          gray = _BLEND(blend_type, *dest_scan, gray);
+          gray = Blend(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_alpha_scan++;
         dest_scan++;
@@ -2009,7 +2040,7 @@
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
-          gray = _BLEND(blend_type, *dest_scan, gray);
+          gray = Blend(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
       }
@@ -2039,13 +2070,14 @@
     }
   }
 }
-inline 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) {
+
+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) {
@@ -2058,7 +2090,7 @@
       if (bNonseparableBlend)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
-        gray = _BLEND(blend_type, *dest_scan, gray);
+        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 {
@@ -2081,14 +2113,15 @@
     dest_scan++;
   }
 }
-inline 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) {
+
+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) {
@@ -2117,7 +2150,7 @@
       if (bNonseparableBlend)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
-        gray = _BLEND(blend_type, *dest_scan, gray);
+        gray = Blend(blend_type, *dest_scan, gray);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
     }
@@ -2147,13 +2180,14 @@
     dest_scan++;
   }
 }
-inline 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) {
+
+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;
@@ -2214,13 +2248,14 @@
     }
   }
 }
-inline 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) {
+
+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]);
@@ -2257,12 +2292,13 @@
     }
   }
 }
-inline 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) {
+
+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];
@@ -2342,99 +2378,12 @@
   }
 }
 
-void _CompositeRow_8bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
-                                        const uint8_t* src_scan,
-                                        int width,
-                                        uint32_t* pPalette,
-                                        const uint8_t* clip_scan,
-                                        uint8_t* dest_alpha_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_alpha_scan;
-      if (back_alpha == 0) {
-        if (clip_scan) {
-          int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
-          *dest_alpha_scan++ = src_alpha;
-        } else {
-          *dest_alpha_scan++ = *src_alpha_scan;
-        }
-        *dest_scan++ = src_b;
-        *dest_scan++ = src_g;
-        *dest_scan++ = src_r;
-        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 += 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;
-      *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++;
-    }
-  } 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_alpha_scan++ = 255;
-        src_scan++;
-        continue;
-      }
-      int src_alpha = clip_scan[col];
-      if (src_alpha == 0) {
-        dest_scan += 3;
-        dest_alpha_scan++;
-        src_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++;
-      src_scan++;
-    }
-  }
-}
-
-inline 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) {
+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]);
@@ -2479,13 +2428,14 @@
     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) {
+
+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]);
@@ -2530,15 +2480,16 @@
     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) {
+
+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) {
@@ -2565,7 +2516,7 @@
       src_scan[0] = src_b;
       src_scan[1] = src_g;
       src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
@@ -2575,15 +2526,15 @@
       *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);
+      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 = 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 = 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 {
@@ -2596,16 +2547,17 @@
     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) {
+
+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) {
@@ -2635,7 +2587,7 @@
       src_scan[0] = src_b;
       src_scan[1] = src_g;
       src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
@@ -2646,15 +2598,15 @@
           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);
+      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 = 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 = 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++;
@@ -2668,16 +2620,17 @@
     }
   }
 }
-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) {
+
+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) {
@@ -2695,20 +2648,20 @@
       src_scan[0] = src_b;
       src_scan[1] = src_g;
       src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      RGB_Blend(blend_type, src_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);
+      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);
+      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);
+      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);
@@ -2720,11 +2673,12 @@
     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) {
+
+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) {
@@ -2741,12 +2695,13 @@
     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) {
+
+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) {
@@ -2760,13 +2715,14 @@
     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) {
+
+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) {
@@ -2792,16 +2748,17 @@
     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) {
+
+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++) {
@@ -2838,7 +2795,7 @@
       src_scan[0] = src_b;
       src_scan[1] = src_g;
       src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
@@ -2848,15 +2805,15 @@
       *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);
+      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 = 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 = 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 {
@@ -2869,103 +2826,18 @@
     dest_scan += 2;
   }
 }
-void _CompositeRow_BitMask2Rgba(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,
-                                uint8_t* dest_alpha_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[0] = src_b;
-        dest_scan[1] = src_g;
-        dest_scan[2] = src_r;
-        *dest_alpha_scan = mask_alpha;
-      }
-      dest_scan += 3;
-      dest_alpha_scan++;
-    }
-    return;
-  }
-  for (int col = 0; col < pixel_count; col++) {
-    if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
-      dest_scan += 3;
-      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_scan[3];
-    if (back_alpha == 0) {
-      *dest_scan++ = src_b;
-      *dest_scan++ = src_g;
-      *dest_scan++ = src_r;
-      *dest_alpha_scan++ = mask_alpha;
-      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 src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_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_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) {
+
+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))) {
@@ -2998,20 +2870,20 @@
       src_scan[0] = src_b;
       src_scan[1] = src_g;
       src_scan[2] = src_r;
-      _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      RGB_Blend(blend_type, src_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);
+      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);
+      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);
+      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);
@@ -3023,12 +2895,13 @@
     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) {
+
+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++;
@@ -3049,13 +2922,14 @@
     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) {
+
+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++;
@@ -3073,14 +2947,15 @@
     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) {
+
+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++;
@@ -3111,11 +2986,12 @@
     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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   for (int col = 0; col < pixel_count; col++) {
@@ -3153,14 +3029,14 @@
       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);
+      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);
+                          : 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);
@@ -3174,11 +3050,12 @@
     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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -3201,14 +3078,14 @@
       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);
+      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 = FX_GAMMA(*src_scan);
+      int src_color = *src_scan;
       int blended = bNonseparableBlend
                         ? blended_colors[color]
-                        : _BLEND(blend_type, dest_scan[index], src_color);
+                        : Blend(blend_type, dest_scan[index], src_color);
       dest_scan[index] = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
       src_scan++;
     }
@@ -3216,13 +3093,13 @@
     src_scan += src_gap;
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   for (int col = 0; col < width; col++) {
@@ -3242,27 +3119,26 @@
       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);
+      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 = FX_GAMMA(dest_scan[index]);
+      int back_color = dest_scan[index];
       int blended = bNonseparableBlend
                         ? blended_colors[color]
-                        : _BLEND(blend_type, back_color, *src_scan);
-      dest_scan[index] =
-          FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
+                        : 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++;
   }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int width,
-    int src_Bpp) {
+
+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));
@@ -3274,13 +3150,13 @@
     src_scan += src_Bpp;
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -3290,28 +3166,28 @@
       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);
+      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 = FX_GAMMA(dest_scan[index]);
-      int src_color = FX_GAMMA(*src_scan);
+      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] = FX_GAMMA_INVERSE(blended);
+                        : Blend(blend_type, back_color, src_color);
+      dest_scan[index] = blended;
       src_scan++;
     }
     dest_scan += dest_Bpp;
     src_scan += src_gap;
   }
 }
-inline void _CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int width,
-    int dest_Bpp,
-    const uint8_t* clip_scan) {
+
+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) {
@@ -3320,9 +3196,9 @@
       src_alpha = src_scan[3];
     }
     if (src_alpha == 255) {
-      dest_scan[2] = FX_GAMMA_INVERSE(*src_scan++);
-      dest_scan[1] = FX_GAMMA_INVERSE(*src_scan++);
-      dest_scan[0] = FX_GAMMA_INVERSE(*src_scan++);
+      dest_scan[2] = *src_scan++;
+      dest_scan[1] = *src_scan++;
+      dest_scan[0] = *src_scan++;
       dest_scan += dest_Bpp;
       src_scan++;
       continue;
@@ -3334,20 +3210,20 @@
     }
     for (int color = 0; color < 3; color++) {
       int index = 2 - color;
-      dest_scan[index] = FX_GAMMA_INVERSE(
-          FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[index]), *src_scan, src_alpha));
+      dest_scan[index] =
+          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, src_alpha);
       src_scan++;
     }
     dest_scan += dest_Bpp;
     src_scan++;
   }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int width,
-    int dest_Bpp,
-    int src_Bpp) {
+
+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];
@@ -3356,13 +3232,13 @@
     src_scan += src_Bpp;
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -3370,9 +3246,9 @@
     int src_alpha = *clip_scan++;
     uint8_t back_alpha = dest_scan[3];
     if (back_alpha == 0) {
-      dest_scan[2] = FX_GAMMA(*src_scan++);
-      dest_scan[1] = FX_GAMMA(*src_scan++);
-      dest_scan[0] = FX_GAMMA(*src_scan++);
+      dest_scan[2] = *src_scan++;
+      dest_scan[1] = *src_scan++;
+      dest_scan[0] = *src_scan++;
       src_scan += src_gap;
       dest_scan += 4;
       continue;
@@ -3390,14 +3266,14 @@
       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);
+      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 = FX_GAMMA(*src_scan);
+      int src_color = *src_scan;
       int blended = bNonseparableBlend
                         ? blended_colors[color]
-                        : _BLEND(blend_type, dest_scan[index], src_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);
@@ -3407,14 +3283,14 @@
     src_scan += src_gap;
   }
 }
-inline 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) {
+
+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];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
@@ -3430,36 +3306,35 @@
       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);
+      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 = FX_GAMMA(*src_scan);
-      int back_color = FX_GAMMA(dest_scan[index]);
+      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] =
-          FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
+                        : 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;
   }
 }
-inline 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) {
+
+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] = FX_GAMMA(*src_scan++);
-      dest_scan[1] = FX_GAMMA(*src_scan++);
-      dest_scan[0] = FX_GAMMA(*src_scan++);
+      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;
@@ -3477,20 +3352,20 @@
     for (int color = 0; color < 3; color++) {
       int index = 2 - color;
       dest_scan[index] =
-          FXDIB_ALPHA_MERGE(dest_scan[index], FX_GAMMA(*src_scan), alpha_ratio);
+          FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
       src_scan++;
     }
     dest_scan += 4;
     src_scan += src_gap;
   }
 }
-inline 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) {
+
+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) {
@@ -3498,14 +3373,11 @@
       dest_scan[1] = src_scan[1];
       dest_scan[0] = src_scan[2];
     } else if (src_alpha) {
-      dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(
-          FX_GAMMA(dest_scan[2]), FX_GAMMA(*src_scan), src_alpha));
+      dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], *src_scan, src_alpha);
       src_scan++;
-      dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(
-          FX_GAMMA(dest_scan[1]), FX_GAMMA(*src_scan), src_alpha));
+      dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], *src_scan, src_alpha);
       src_scan++;
-      dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(
-          FX_GAMMA(dest_scan[0]), FX_GAMMA(*src_scan), src_alpha));
+      dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], *src_scan, src_alpha);
       dest_scan += dest_Bpp;
       src_scan += src_Bpp - 2;
       continue;
@@ -3514,13 +3386,13 @@
     src_scan += src_Bpp;
   }
 }
-inline 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) {
+
+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);
@@ -3539,14 +3411,14 @@
     src_scan++;
   }
 }
-inline 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) {
+
+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) {
@@ -3583,12 +3455,12 @@
     dest_scan += DestBpp;
   }
 }
-inline void _CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
-    uint8_t* dest_scan,
-    const uint8_t* src_scan,
-    int width,
-    FX_ARGB* pPalette,
-    const uint8_t* clip_scan) {
+
+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) {
@@ -3600,9 +3472,9 @@
       src_r = src_g = src_b = *src_scan;
     }
     if (!clip_scan || clip_scan[col] == 255) {
-      dest_scan[2] = FX_GAMMA(src_b);
-      dest_scan[1] = FX_GAMMA(src_g);
-      dest_scan[0] = FX_GAMMA(src_r);
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
       dest_scan[3] = 255;
       src_scan++;
       dest_scan += 4;
@@ -3618,23 +3490,20 @@
     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], FX_GAMMA(src_b), alpha_ratio);
-    dest_scan[1] =
-        FXDIB_ALPHA_MERGE(dest_scan[1], FX_GAMMA(src_g), alpha_ratio);
-    dest_scan[0] =
-        FXDIB_ALPHA_MERGE(dest_scan[0], FX_GAMMA(src_r), alpha_ratio);
+    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++;
   }
 }
-inline 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) {
+
+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) {
@@ -3660,9 +3529,9 @@
       src_b = reset_b;
     }
     if (!clip_scan || clip_scan[col] == 255) {
-      dest_scan[2] = FX_GAMMA(src_b);
-      dest_scan[1] = FX_GAMMA(src_g);
-      dest_scan[0] = FX_GAMMA(src_r);
+      dest_scan[2] = src_b;
+      dest_scan[1] = src_g;
+      dest_scan[0] = src_r;
       dest_scan[3] = 255;
       dest_scan += 4;
       continue;
@@ -3676,24 +3545,22 @@
     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], FX_GAMMA(src_b), alpha_ratio);
-    dest_scan[1] =
-        FXDIB_ALPHA_MERGE(dest_scan[1], FX_GAMMA(src_g), alpha_ratio);
-    dest_scan[0] =
-        FXDIB_ALPHA_MERGE(dest_scan[0], FX_GAMMA(src_r), alpha_ratio);
+    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) {
+
+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) {
@@ -3725,7 +3592,7 @@
       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);
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
       dest_scan[1] =
@@ -3733,13 +3600,13 @@
       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);
+      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 = 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 = 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 {
@@ -3750,16 +3617,17 @@
     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) {
+
+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) {
@@ -3781,7 +3649,7 @@
       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);
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
       dest_scan[1] =
@@ -3789,11 +3657,11 @@
       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);
+      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);
+      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);
+      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);
@@ -3803,16 +3671,17 @@
     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) {
+
+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++) {
@@ -3854,7 +3723,7 @@
       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);
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
       dest_scan[1] =
@@ -3862,13 +3731,13 @@
       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);
+      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 = 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 = 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 {
@@ -3879,17 +3748,18 @@
     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) {
+
+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))) {
@@ -3926,7 +3796,7 @@
       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);
+      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
       dest_scan[1] =
@@ -3934,39 +3804,34 @@
       dest_scan[0] =
           FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
     } else if (blend_type) {
-      int back_color = FX_GAMMA(dest_scan[2]);
-      int blended = _BLEND(blend_type, back_color, src_b);
-      dest_scan[2] =
-          FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
-      back_color = FX_GAMMA(dest_scan[1]);
-      blended = _BLEND(blend_type, back_color, src_g);
-      dest_scan[1] =
-          FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
-      back_color = FX_GAMMA(dest_scan[0]);
-      blended = _BLEND(blend_type, back_color, src_r);
-      dest_scan[0] =
-          FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
+      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] = FX_GAMMA_INVERSE(
-          FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), src_b, src_alpha));
-      dest_scan[1] = FX_GAMMA_INVERSE(
-          FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), src_g, src_alpha));
-      dest_scan[0] = FX_GAMMA_INVERSE(
-          FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), src_r, src_alpha));
+      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;
   }
 }
-inline FX_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) {
+
+FX_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);
@@ -4023,15 +3888,16 @@
   }
   return TRUE;
 }
-inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
-                                                  FXDIB_Format dest_format,
-                                                  uint32_t*& pDestPalette,
-                                                  uint32_t* pSrcPalette,
-                                                  CCodec_IccModule* pIccModule,
-                                                  void* pIccTransform) {
+
+void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
+                                          FXDIB_Format dest_format,
+                                          uint32_t*& pDestPalette,
+                                          uint32_t* pSrcPalette,
+                                          CCodec_IccModule* pIccModule,
+                                          void* pIccTransform) {
   FX_BOOL isSrcCmyk = !!(src_format & 0x0400);
   FX_BOOL isDstCmyk = !!(dest_format & 0x0400);
-  pDestPalette = NULL;
+  pDestPalette = nullptr;
   if (pIccTransform) {
     if (pSrcPalette) {
       if ((dest_format & 0xff) == 8) {
@@ -4159,17 +4025,22 @@
     }
   }
 }
+
+}  // namespace
+
 CFX_ScanlineCompositor::CFX_ScanlineCompositor() {
-  m_pSrcPalette = NULL;
-  m_pCacheScanline = NULL;
+  m_pSrcPalette = nullptr;
+  m_pCacheScanline = nullptr;
   m_CacheSize = 0;
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
+
 CFX_ScanlineCompositor::~CFX_ScanlineCompositor() {
   FX_Free(m_pSrcPalette);
   FX_Free(m_pCacheScanline);
 }
+
 FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format,
                                      FXDIB_Format src_format,
                                      int32_t width,
@@ -4189,14 +4060,14 @@
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (!pIccModule) {
-    pIccTransform = NULL;
+    pIccTransform = nullptr;
   }
   m_pIccTransform = pIccTransform;
   if ((dest_format & 0xff) == 1) {
     return FALSE;
   }
   if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
-    return _ScanlineCompositor_InitSourceMask(
+    return ScanlineCompositor_InitSourceMask(
         dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed,
         m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform);
   }
@@ -4207,9 +4078,9 @@
     if (dest_format == FXDIB_8bppMask) {
       return TRUE;
     }
-    _ScanlineCompositor_InitSourcePalette(src_format, dest_format,
-                                          m_pSrcPalette, pSrcPalette,
-                                          pIccModule, pIccTransform);
+    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);
@@ -4222,6 +4093,7 @@
                    (dest_format & 0x0400 ? 32 : 0) + (pIccTransform ? 64 : 0);
   return TRUE;
 }
+
 void CFX_ScanlineCompositor::CompositeRgbBitmapLine(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
@@ -4237,50 +4109,50 @@
       case 4:
       case 8:
       case 12:
-        _CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width,
-                                             m_BlendType, clip_scan);
+        CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width,
+                                            m_BlendType, clip_scan);
         break;
       case 1:
-        _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(
+        CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(
             dest_scan, src_scan, width, m_BlendType, src_Bpp);
         break;
       case 2:
       case 10:
-        _CompositeRow_Argb2Rgb_Blend_RgbByteOrder(
+        CompositeRow_Argb2Rgb_Blend_RgbByteOrder(
             dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan);
         break;
       case 3:
-        _CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(
+        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);
+        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);
+        CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, width,
+                                                   dest_Bpp, clip_scan);
         break;
       case 7:
-        _CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
             dest_scan, src_scan, width, dest_Bpp, src_Bpp);
         break;
       case 9:
-        _CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(
+        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);
+        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(
+        CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(
             dest_scan, src_scan, width, src_Bpp, clip_scan);
         break;
       case 15:
-        _CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(
+        CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(
             dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan);
         break;
     }
@@ -4289,12 +4161,12 @@
   if (m_DestFormat == FXDIB_8bppMask) {
     if (m_SrcFormat & 0x0200) {
       if (m_SrcFormat == FXDIB_Argb) {
-        _CompositeRow_Argb2Mask(dest_scan, src_scan, width, clip_scan);
+        CompositeRow_Argb2Mask(dest_scan, src_scan, width, clip_scan);
       } else {
-        _CompositeRow_Rgba2Mask(dest_scan, src_extra_alpha, width, clip_scan);
+        CompositeRow_Rgba2Mask(dest_scan, src_extra_alpha, width, clip_scan);
       }
     } else {
-      _CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+      CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
     }
   } else if ((m_DestFormat & 0xff) == 8) {
     if (m_DestFormat & 0x0400) {
@@ -4305,21 +4177,20 @@
     }
     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);
+        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);
+        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);
+        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);
+        CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType,
+                              clip_scan, m_pIccTransform);
       }
     }
     if (m_DestFormat & 0x0400) {
@@ -4342,116 +4213,116 @@
       case 4:
       case 8:
       case 4 + 8: {
-        _CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType,
-                                clip_scan, dst_extra_alpha, src_extra_alpha);
+        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(
+        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(
+        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(
+        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);
+        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(
+        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);
+        CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width,
+                                             src_Bpp, dst_extra_alpha);
         break;
       case 1 + 4 + 64:
-        _CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(
+        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);
+        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(
+        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);
+        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(
+        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);
+        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(
+        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);
+        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(
+        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);
+        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(
+        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);
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan, width,
+                                            dest_Bpp, src_Bpp);
         break;
       case 1 + 2 + 4 + 64:
-        _CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(
+        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);
+        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(
+        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,
@@ -4466,10 +4337,10 @@
         return;
       }
       if (m_DestFormat == FXDIB_Argb) {
-        _CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
+        CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan);
       } else {
-        _CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(
+        CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, src_left, m_pSrcPalette, width,
             (m_DestFormat & 0xff) >> 3, clip_scan);
       }
@@ -4478,10 +4349,10 @@
         return;
       }
       if (m_DestFormat == FXDIB_Argb) {
-        _CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
+        CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, width, m_pSrcPalette, clip_scan);
       } else {
-        _CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(
+        CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, m_pSrcPalette, width,
             (m_DestFormat & 0xff) >> 3, clip_scan);
       }
@@ -4489,106 +4360,108 @@
     return;
   }
   if (m_DestFormat == FXDIB_8bppMask) {
-    _CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+    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,
+        CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left,
                                    (const uint8_t*)m_pSrcPalette, width,
-                                   m_BlendType, clip_scan);
+                                   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(
+        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);
+        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);
+        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);
+        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);
+        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);
+        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);
+        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);
+        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);
+    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);
+      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);
+      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(
+      CompositeRow_ByteMask2Argb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           width, m_BlendType, clip_scan);
     } else {
-      _CompositeRow_ByteMask2Rgb_RgbByteOrder(
+      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,
+    CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                               (m_DestFormat & 0xff) >> 3, clip_scan);
+                               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);
+    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,
@@ -4596,33 +4469,33 @@
                                                   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);
+    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);
+      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);
+      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(
+      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(
+      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);
+    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(
+    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);
   }
@@ -4652,7 +4525,7 @@
   if (width == 0 || height == 0) {
     return TRUE;
   }
-  const CFX_DIBitmap* pClipMask = NULL;
+  const CFX_DIBitmap* pClipMask = nullptr;
   FX_RECT clip_box;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
@@ -4662,7 +4535,7 @@
   CFX_ScanlineCompositor compositor;
   if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width,
                        pSrcBitmap->GetPalette(), 0, blend_type,
-                       pClipMask != NULL, bRgbByteOrder, 0, pIccTransform)) {
+                       pClipMask != nullptr, bRgbByteOrder, 0, pIccTransform)) {
     return FALSE;
   }
   int dest_Bpp = m_bpp / 8;
@@ -4676,12 +4549,12 @@
         pSrcBitmap->GetScanline(src_top + row) + src_left * src_Bpp;
     const uint8_t* src_scan_extra_alpha =
         pSrcAlphaMask ? pSrcAlphaMask->GetScanline(src_top + row) + src_left
-                      : NULL;
+                      : nullptr;
     uint8_t* dst_scan_extra_alpha =
         m_pAlphaMask
             ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
-            : NULL;
-    const uint8_t* clip_scan = NULL;
+            : nullptr;
+    const uint8_t* clip_scan = nullptr;
     if (pClipMask) {
       clip_scan = pClipMask->m_pBuffer +
                   (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
@@ -4699,6 +4572,7 @@
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left,
                                     int dest_top,
                                     int width,
@@ -4730,7 +4604,7 @@
   if (src_alpha == 0) {
     return TRUE;
   }
-  const CFX_DIBitmap* pClipMask = NULL;
+  const CFX_DIBitmap* pClipMask = nullptr;
   FX_RECT clip_box;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
@@ -4740,9 +4614,9 @@
   int src_bpp = pMask->GetBPP();
   int Bpp = GetBPP() / 8;
   CFX_ScanlineCompositor compositor;
-  if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, NULL, color,
-                       blend_type, pClipMask != NULL, bRgbByteOrder, alpha_flag,
-                       pIccTransform)) {
+  if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, nullptr, color,
+                       blend_type, pClipMask != nullptr, bRgbByteOrder,
+                       alpha_flag, pIccTransform)) {
     return FALSE;
   }
   for (int row = 0; row < height; row++) {
@@ -4752,8 +4626,8 @@
     uint8_t* dst_scan_extra_alpha =
         m_pAlphaMask
             ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
-            : NULL;
-    const uint8_t* clip_scan = NULL;
+            : nullptr;
+    const uint8_t* clip_scan = nullptr;
     if (pClipMask) {
       clip_scan = pClipMask->m_pBuffer +
                   (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
@@ -4769,6 +4643,7 @@
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::CompositeRect(int left,
                                     int top,
                                     int width,
@@ -4898,7 +4773,7 @@
       uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
       uint8_t* dest_scan_alpha =
           m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left
-                       : NULL;
+                       : nullptr;
       if (dest_scan_alpha) {
         FXSYS_memset(dest_scan_alpha, 0xff, width);
       }
@@ -4977,20 +4852,23 @@
   }
   return TRUE;
 }
+
 CFX_BitmapComposer::CFX_BitmapComposer() {
-  m_pScanlineV = NULL;
-  m_pScanlineAlphaV = NULL;
-  m_pClipScanV = NULL;
-  m_pAddClipScan = NULL;
+  m_pScanlineV = nullptr;
+  m_pScanlineAlphaV = nullptr;
+  m_pClipScanV = nullptr;
+  m_pAddClipScan = nullptr;
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
+
 CFX_BitmapComposer::~CFX_BitmapComposer() {
   FX_Free(m_pScanlineV);
   FX_Free(m_pScanlineAlphaV);
   FX_Free(m_pClipScanV);
   FX_Free(m_pAddClipScan);
 }
+
 void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest,
                                  const CFX_ClipRgn* pClipRgn,
                                  int bitmap_alpha,
@@ -5011,7 +4889,7 @@
   m_DestHeight = dest_rect.Height();
   m_BitmapAlpha = bitmap_alpha;
   m_MaskColor = mask_color;
-  m_pClipMask = NULL;
+  m_pClipMask = nullptr;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     m_pClipMask = pClipRgn->GetMask();
   }
@@ -5030,7 +4908,7 @@
   m_SrcFormat = src_format;
   if (!m_Compositor.Init(m_pBitmap->GetFormat(), src_format, width, pSrcPalette,
                          m_MaskColor, FXDIB_BLEND_NORMAL,
-                         m_pClipMask != NULL || (m_BitmapAlpha < 255),
+                         m_pClipMask != nullptr || (m_BitmapAlpha < 255),
                          m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform)) {
     return FALSE;
   }
@@ -5047,6 +4925,7 @@
   }
   return TRUE;
 }
+
 void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan,
                                    const uint8_t* src_scan,
                                    int dest_width,
@@ -5076,6 +4955,7 @@
                                         dst_extra_alpha);
   }
 }
+
 void CFX_BitmapComposer::ComposeScanline(int line,
                                          const uint8_t* scanline,
                                          const uint8_t* scan_extra_alpha) {
@@ -5083,7 +4963,7 @@
     ComposeScanlineV(line, scanline, scan_extra_alpha);
     return;
   }
-  const uint8_t* clip_scan = NULL;
+  const uint8_t* clip_scan = nullptr;
   if (m_pClipMask)
     clip_scan = m_pClipMask->GetBuffer() +
                 (m_DestTop + line - m_pClipRgn->GetBox().top) *
@@ -5095,10 +4975,11 @@
       m_pBitmap->m_pAlphaMask
           ? (uint8_t*)m_pBitmap->m_pAlphaMask->GetScanline(line + m_DestTop) +
                 m_DestLeft
-          : NULL;
+          : nullptr;
   DoCompose(dest_scan, scanline, m_DestWidth, clip_scan, scan_extra_alpha,
             dest_alpha_scan);
 }
+
 void CFX_BitmapComposer::ComposeScanlineV(int line,
                                           const uint8_t* scanline,
                                           const uint8_t* scan_extra_alpha) {
@@ -5113,7 +4994,7 @@
   uint8_t* dest_alpha_buf = m_pBitmap->m_pAlphaMask
                                 ? m_pBitmap->m_pAlphaMask->GetBuffer() +
                                       dest_x + m_DestTop * dest_alpha_pitch
-                                : NULL;
+                                : nullptr;
   if (m_bFlipY) {
     dest_buf += dest_pitch * (m_DestHeight - 1);
     dest_alpha_buf += dest_alpha_pitch * (m_DestHeight - 1);
@@ -5140,7 +5021,7 @@
       dest_alpha_scan += y_alpha_step;
     }
   }
-  uint8_t* clip_scan = NULL;
+  uint8_t* clip_scan = nullptr;
   if (m_pClipMask) {
     clip_scan = m_pClipScanV;
     int clip_pitch = m_pClipMask->GetPitch();
diff --git a/core/fxge/include/fx_ge.h b/core/fxge/include/fx_ge.h
index 3c25e8d..5e9e841 100644
--- a/core/fxge/include/fx_ge.h
+++ b/core/fxge/include/fx_ge.h
@@ -104,14 +104,7 @@
 
   void IntersectMaskRect(FX_RECT rect, FX_RECT mask_box, CFX_DIBitmapRef Mask);
 };
-#define FX_GAMMA(value) (value)
-#define FX_GAMMA_INVERSE(value) (value)
-inline FX_ARGB ArgbGamma(FX_ARGB argb) {
-  return argb;
-}
-inline FX_ARGB ArgbGammaInverse(FX_ARGB argb) {
-  return argb;
-}
+
 class CFX_PathData {
  public:
   CFX_PathData();
diff --git a/core/fxge/skia/fx_skia_device.cpp b/core/fxge/skia/fx_skia_device.cpp
index 3d08cb5..6646eed 100644
--- a/core/fxge/skia/fx_skia_device.cpp
+++ b/core/fxge/skia/fx_skia_device.cpp
@@ -259,7 +259,7 @@
     return;
   pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
                           pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
-                          src_left, src_top, NULL);
+                          src_left, src_top, nullptr);
   if (width == 0 || height == 0)
     return;
   int Bpp = pBitmap->GetBPP() / 8;
@@ -313,21 +313,11 @@
         uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
         uint8_t* src_scan =
             (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
-        if (src_format == FXDIB_Argb) {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]),
-                                                 FX_GAMMA(src_scan[1]),
-                                                 FX_GAMMA(src_scan[2])));
-            dest_scan += 4;
-            src_scan += 3;
-          }
-        } else {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
-                                                 src_scan[2]));
-            dest_scan += 4;
-            src_scan += 3;
-          }
+        for (int col = 0; col < width; col++) {
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
+                                               src_scan[2]));
+          dest_scan += 4;
+          src_scan += 3;
         }
       }
     } else if (src_format == FXDIB_Rgb32) {