Remove typdefs for pointer types in fx_system.h

core/src/fxge/dib/fx_dib_composite.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 const uint8_t g_GammaRamp[256] = {
@@ skipping 209 matching lines @@
             mid = &color.green;
         }
     }
     if (*max > *min) {
         *mid = (*mid - *min) * s / (*max - *min);
         *max = s;
         *min = 0;
     }
     return color;
 }
-void _RGB_Blend(int blend_mode, FX_LPCBYTE src_scan, uint8_t* dest_scan, int results[3])
+void _RGB_Blend(int blend_mode, const uint8_t* src_scan, uint8_t* dest_scan, int results[3])
 {
     _RGB src, back, result;
     src.red = src_scan[2];
     src.green = src_scan[1];
     src.blue = src_scan[0];
     back.red = dest_scan[2];
     back.green = dest_scan[1];
     back.blue = dest_scan[0];
     switch (blend_mode) {
         case FXDIB_BLEND_HUE:
             result = _SetLum(_SetSat(src, _Sat(back)), _Lum(back));
             break;
         case FXDIB_BLEND_SATURATION:
             result = _SetLum(_SetSat(back, _Sat(src)), _Lum(back));
             break;
         case FXDIB_BLEND_COLOR:
             result = _SetLum(src, _Lum(back));
             break;
         case FXDIB_BLEND_LUMINOSITY:
             result = _SetLum(back, _Lum(src));
             break;
     }
     results[0] = result.blue;
     results[1] = result.green;
     results[2] = result.red;
 }
-inline void _CompositeRow_Argb2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, FX_LPCBYTE clip_scan)
+inline 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;
         if (clip_scan) {
             src_alpha = clip_scan[col] * src_alpha / 255;
         }
         uint8_t back_alpha = *dest_scan;
         if (!back_alpha) {
             *dest_scan = src_alpha;
         } else if (src_alpha) {
             *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         }
         dest_scan ++;
         src_scan += 4;
     }
 }
-void _CompositeRow_Rgba2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_alpha_scan, int pixel_count, FX_LPCBYTE 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) {
             src_alpha = clip_scan[col] * src_alpha / 255;
         }
         uint8_t back_alpha = *dest_scan;
         if (!back_alpha) {
             *dest_scan = src_alpha;
         } else if (src_alpha) {
             *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         }
         dest_scan ++;
     }
 }
-void _CompositeRow_Rgb2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, FX_LPCBYTE 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);
             dest_scan ++;
             clip_scan ++;
         }
     } else {
         FXSYS_memset8(dest_scan, 0xff, width);
     }
 }
-void _CompositeRow_Argb2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, int blend_type, FX_LPCBYTE clip_scan,
-                              FX_LPCBYTE src_alpha_scan, FX_LPBYTE 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)
 {
     ICodec_IccModule* pIccModule = NULL;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         if (src_alpha_scan) {
             for (int col = 0; col < pixel_count; col ++) {
@@ skipping 171 matching lines @@
                 pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
             } else {
                 gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
             }
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
             dest_scan ++;
             dst_alpha_scan++;
             src_scan += 4;
         }
 }
-inline void _CompositeRow_Argb2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count,
-                                    int blend_type, FX_LPCBYTE clip_scan,
-                                    FX_LPCBYTE src_alpha_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = NULL;
     uint8_t gray;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         if (src_alpha_scan) {
@@ skipping 68 matching lines @@
                     pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
                 } else {
                     gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                 }
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
             }
             dest_scan ++;
             src_scan += 4;
         }
 }
-inline void _CompositeRow_Rgb2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_Bpp, int pixel_count,
-                                   int blend_type, FX_LPCBYTE clip_scan,
+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)
 {
     ICodec_IccModule* pIccModule = NULL;
     uint8_t gray;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
@@ skipping 25 matching lines @@
         }
         if (clip_scan && clip_scan[col] < 255) {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
         } else {
             *dest_scan = gray;
         }
         dest_scan ++;
         src_scan += src_Bpp;
     }
 }
-void _CompositeRow_Rgb2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_Bpp, int pixel_count,
-                             int blend_type, FX_LPCBYTE clip_scan,
-                             FX_LPBYTE 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)
 {
     ICodec_IccModule* pIccModule = NULL;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
         int blended_color;
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         for (int col = 0; col < pixel_count; col ++) {
             int back_alpha = *dest_alpha_scan;
@@ skipping 67 matching lines @@
         if (pIccTransform) {
             pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
         } else {
             gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
         }
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan ++;
         src_scan += src_Bpp;
     }
 }
-void _CompositeRow_Argb2Argb(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, int blend_type, FX_LPCBYTE clip_scan,
-                             FX_LPBYTE dest_alpha_scan, FX_LPCBYTE 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 == NULL) {
         if (src_alpha_scan == NULL) {
             uint8_t back_alpha = 0;
             for (int col = 0; col < pixel_count; col ++) {
                 back_alpha = dest_scan[3];
                 if (back_alpha == 0) {
                     if (clip_scan) {
@@ skipping 185 matching lines @@
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                     }
                     dest_scan ++;
                     src_scan ++;
                 }
                 src_scan ++;
             }
         }
     }
 }
-void _CompositeRow_Rgb2Argb_Blend_NoClip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int src_Bpp,
-        FX_LPBYTE 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;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 if (src_Bpp == 4) {
                     FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
@@ skipping 39 matching lines @@
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, *dest_scan, src_color);
                 *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             src_scan += src_gap;
         }
     }
 }
-inline void _CompositeRow_Rgb2Argb_Blend_Clip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dest_alpha_scan)
+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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             int src_alpha = *clip_scan ++;
             uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 *dest_scan++ = *src_scan++;
@@ skipping 56 matching lines @@
                               _BLEND(blend_type, *dest_scan, src_color);
                 blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
                 dest_scan ++;
                 src_scan ++;
             }
             src_scan += src_gap;
         }
     }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_Clip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dest_alpha_scan)
+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)
 {
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             int src_alpha = clip_scan[col];
             if (src_alpha == 255) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = 255;
@@ skipping 40 matching lines @@
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             for (int color = 0; color < 3; color ++) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                 dest_scan ++;
                 src_scan ++;
             }
             src_scan += src_gap;
         }
     }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp,
-        FX_LPBYTE dest_alpha_scan)
+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)
 {
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             if (src_Bpp == 4) {
                 FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
             } else {
                 FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
             }
             dest_scan += 4;
             src_scan += src_Bpp;
         }
     } else {
         int src_gap = src_Bpp - 3;
         for (int col = 0; col < width; col ++) {
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             *dest_alpha_scan++ = 0xff;
             src_scan += src_gap;
         }
     }
 }
-inline void _CompositeRow_Argb2Rgb_Blend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan)
+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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     if (src_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
@@ skipping 39 matching lines @@
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, back_color, *src_scan);
                 *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan += dest_gap;
         }
     }
 }
-inline void _CompositeRow_Argb2Rgb_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan)
+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)
 {
     int dest_gap = dest_Bpp - 3;
     if (src_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
@@ skipping 40 matching lines @@
             }
             for (int color = 0; color < 3; color ++) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan += dest_gap;
         }
     }
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_NoClip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp)
+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)
 {
     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);
         }
         for (int color = 0; color < 3; color ++) {
             int back_color = *dest_scan;
             int src_color = *src_scan;
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, back_color, src_color);
             *dest_scan = blended;
             dest_scan ++;
             src_scan ++;
         }
         dest_scan += dest_gap;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_Clip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     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 ++) {
         uint8_t src_alpha = *clip_scan ++;
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += src_Bpp;
             continue;
         }
         if (bNonseparableBlend) {
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int src_color = *src_scan;
             int back_color = *dest_scan;
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, back_color, src_color);
             *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
             dest_scan ++;
             src_scan ++;
         }
         dest_scan += dest_gap;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp)
+inline 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_memcpy32(dest_scan, src_scan, width * dest_Bpp);
         return;
     }
     for (int col = 0; col < width; col ++) {
         dest_scan[0] = src_scan[0];
         dest_scan[1] = src_scan[1];
         dest_scan[2] = src_scan[2];
         dest_scan += dest_Bpp;
         src_scan += src_Bpp;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_Clip(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     for (int col = 0; col < width; col ++) {
         int src_alpha = clip_scan[col];
         if (src_alpha == 255) {
             dest_scan[0] = src_scan[0];
             dest_scan[1] = src_scan[1];
             dest_scan[2] = src_scan[2];
         } else if (src_alpha) {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
             dest_scan ++;
             src_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
             dest_scan ++;
             src_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
             dest_scan += dest_Bpp - 2;
             src_scan += src_Bpp - 2;
             continue;
         }
         dest_scan += dest_Bpp;
         src_scan += src_Bpp;
     }
 }
-void _CompositeRow_Argb2Argb_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, int blend_type, FX_LPCBYTE clip_scan,
-                                       FX_LPBYTE dest_alpha_scan, FX_LPCBYTE src_alpha_scan, FX_LPBYTE 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)
 {
-    FX_LPBYTE dp = src_cache_scan;
+    uint8_t* dp = src_cache_scan;
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_alpha_scan) {
         if (dest_alpha_scan == NULL) {
             for (int col = 0; col < pixel_count; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
                 dp[3] = *src_alpha_scan++;
                 src_scan += 3;
                 dp += 4;
             }
             src_alpha_scan = NULL;
@@ skipping 61 matching lines @@
                     }
                     dest_scan ++;
                     src_cache_scan ++;
                 }
             }
             return;
         }
     }
     _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(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int src_Bpp,
-        FX_LPBYTE dest_alpha_scan, FX_LPBYTE 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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width, blend_type, 3, dest_alpha_scan);
 }
-inline void _CompositeRow_Rgb2Argb_Blend_Clip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dest_alpha_scan, FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type, 3, clip_scan, dest_alpha_scan);
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dest_alpha_scan, FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3, clip_scan, dest_alpha_scan);
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp,
-        FX_LPBYTE dest_alpha_scan, FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3, dest_alpha_scan);
 }
-inline void _CompositeRow_Argb2Rgb_Blend_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan, FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_alpha_scan) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
         int blended_colors[3];
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int dest_gap = dest_Bpp - 3;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
@@ skipping 19 matching lines @@
                 *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
                 dest_scan ++;
                 src_cache_scan ++;
             }
             dest_scan += dest_gap;
         }
         return;
     }
     _CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type, dest_Bpp, clip_scan, src_alpha_scan);
 }
-inline void _CompositeRow_Argb2Rgb_NoBlend_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan, FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_alpha_scan) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
         int dest_gap = dest_Bpp - 3;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
             uint8_t src_alpha;
             if (clip_scan) {
@@ skipping 18 matching lines @@
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, src_alpha);
                 dest_scan ++;
                 src_cache_scan ++;
             }
             dest_scan += dest_gap;
         }
         return;
     }
     _CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp, clip_scan, src_alpha_scan);
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp,
-        FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width, blend_type, dest_Bpp, 3);
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_Clip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type, dest_Bpp, 3, clip_scan);
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp,
-        FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width, dest_Bpp, 3);
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan,
-        FX_LPBYTE src_cache_scan, void* pIccTransform)
+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)
 {
     ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (src_Bpp == 3) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
-        FX_LPBYTE dp = src_cache_scan;
+        uint8_t* dp = src_cache_scan;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
             src_scan += 4;
             dp += 3;
         }
     }
     _CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp, 3, clip_scan);
 }
-inline void _CompositeRow_8bppPal2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, FX_LPCBYTE pPalette, int pixel_count,
-                                       int blend_type, FX_LPCBYTE clip_scan,
-                                       FX_LPCBYTE src_alpha_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)
 {
     if (src_alpha_scan) {
         if (blend_type) {
             FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
                 int src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
@@ skipping 51 matching lines @@
             if (clip_scan && clip_scan[col] < 255) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
             } else {
                 *dest_scan = gray;
             }
             dest_scan ++;
             src_scan ++;
         }
     }
 }
-inline void _CompositeRow_8bppPal2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, FX_LPCBYTE pPalette, int pixel_count,
-                                        int blend_type, FX_LPCBYTE clip_scan,
-                                        FX_LPBYTE dest_alpha_scan, FX_LPCBYTE src_alpha_scan)
+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)
 {
     if (src_alpha_scan) {
         if (blend_type) {
             FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
                 src_scan ++;
                 uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
@@ skipping 109 matching lines @@
             }
             int back_alpha = *dest_alpha_scan;
             uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan ++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
             dest_scan ++;
         }
     }
 }
-inline void _CompositeRow_1bppPal2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left,
-                                       FX_LPCBYTE pPalette, int pixel_count, int blend_type, FX_LPCBYTE clip_scan)
+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)
 {
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
             if (bNonseparableBlend) {
                 blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
@@ skipping 11 matching lines @@
     for (int col = 0; col < pixel_count; col ++) {
         uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
         if (clip_scan && clip_scan[col] < 255) {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
         } else {
             *dest_scan = gray;
         }
         dest_scan ++;
     }
 }
-inline void _CompositeRow_1bppPal2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left,
-                                        FX_LPCBYTE pPalette, int pixel_count, int blend_type, FX_LPCBYTE clip_scan,
-                                        FX_LPBYTE dest_alpha_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)
 {
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
         FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
             if (clip_scan == NULL || clip_scan[col] == 255) {
                 *dest_scan++ = gray;
@@ skipping 33 matching lines @@
             continue;
         }
         int back_alpha = *dest_alpha_scan;
         uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan ++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan ++;
     }
 }
-inline void _CompositeRow_8bppRgb2Rgb_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, FX_DWORD* pPalette, int pixel_count,
-        int DestBpp, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan)
+inline void _CompositeRow_8bppRgb2Rgb_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, FX_DWORD* pPalette, int pixel_count,
+        int DestBpp, const uint8_t* clip_scan,
+        const uint8_t* src_alpha_scan)
 {
     if (src_alpha_scan) {
         int dest_gap = DestBpp - 3;
         FX_ARGB argb = 0;
         for (int col = 0; col < pixel_count; col ++) {
             argb = pPalette[*src_scan];
             int src_r = FXARGB_R(argb);
             int src_g = FXARGB_G(argb);
             int src_b = FXARGB_B(argb);
             src_scan ++;
@@ skipping 41 matching lines @@
                 *dest_scan++ = src_g;
                 *dest_scan++ = src_r;
             }
             if (DestBpp == 4) {
                 dest_scan++;
             }
             src_scan ++;
         }
     }
 }
-inline void _CompositeRow_1bppRgb2Rgb_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left,
-        FX_DWORD* pPalette, int pixel_count, int DestBpp, FX_LPCBYTE clip_scan)
+inline void _CompositeRow_1bppRgb2Rgb_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, int src_left,
+        FX_DWORD* pPalette, int pixel_count, int DestBpp, const uint8_t* clip_scan)
 {
     int reset_r, reset_g, reset_b;
     int set_r, set_g, set_b;
     reset_r = FXARGB_R(pPalette[0]);
     reset_g = FXARGB_G(pPalette[0]);
     reset_b = FXARGB_B(pPalette[0]);
     set_r = FXARGB_R(pPalette[1]);
     set_g = FXARGB_G(pPalette[1]);
     set_b = FXARGB_B(pPalette[1]);
     for (int col = 0; col < pixel_count; col ++) {
@@ skipping 17 matching lines @@
         } else {
             *dest_scan++ = src_b;
             *dest_scan++ = src_g;
             *dest_scan++ = src_r;
         }
         if (DestBpp == 4) {
             dest_scan++;
         }
     }
 }
-inline void _CompositeRow_8bppRgb2Argb_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width,
-        FX_DWORD* pPalette, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_alpha_scan)
+inline void _CompositeRow_8bppRgb2Argb_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, int width,
+        FX_DWORD* pPalette, const uint8_t* clip_scan,
+        const uint8_t* src_alpha_scan)
 {
     if (src_alpha_scan) {
         for (int col = 0; col < width; col ++) {
             FX_ARGB argb = pPalette[*src_scan];
             src_scan ++;
             int src_r = FXARGB_R(argb);
             int src_g = FXARGB_G(argb);
             int src_b = FXARGB_B(argb);
             uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
@@ skipping 55 matching lines @@
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
             dest_scan ++;
             src_scan ++;
         }
 }
-void _CompositeRow_8bppRgb2Rgba_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width,
-                                        FX_DWORD* pPalette, FX_LPCBYTE clip_scan,
-                                        FX_LPBYTE dest_alpha_scan, FX_LPCBYTE src_alpha_scan)
+void _CompositeRow_8bppRgb2Rgba_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, int width,
+                                        FX_DWORD* 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) {
@@ skipping 57 matching lines @@
             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(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left, int width,
-        FX_DWORD* pPalette, FX_LPCBYTE clip_scan)
+inline void _CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, int src_left, int width,
+        FX_DWORD* pPalette, const uint8_t* clip_scan)
 {
     int reset_r, reset_g, reset_b;
     int set_r, set_g, set_b;
     reset_r = FXARGB_R(pPalette[0]);
     reset_g = FXARGB_G(pPalette[0]);
     reset_b = FXARGB_B(pPalette[0]);
     set_r = FXARGB_R(pPalette[1]);
     set_g = FXARGB_G(pPalette[1]);
     set_b = FXARGB_B(pPalette[1]);
     for (int col = 0; col < width; col ++) {
@@ skipping 25 matching lines @@
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         dest_scan ++;
         dest_scan ++;
     }
 }
-void _CompositeRow_1bppRgb2Rgba_NoBlend(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left, int width,
-                                        FX_DWORD* pPalette, FX_LPCBYTE clip_scan,
-                                        FX_LPBYTE dest_alpha_scan)
+void _CompositeRow_1bppRgb2Rgba_NoBlend(uint8_t* dest_scan, const uint8_t* src_scan, int src_left, int width,
+                                        FX_DWORD* pPalette, const uint8_t* clip_scan,
+                                        uint8_t* dest_alpha_scan)
 {
     int reset_r, reset_g, reset_b;
     int set_r, set_g, set_b;
     reset_r = FXARGB_R(pPalette[0]);
     reset_g = FXARGB_G(pPalette[0]);
     reset_b = FXARGB_B(pPalette[0]);
     set_r = FXARGB_R(pPalette[1]);
     set_g = FXARGB_G(pPalette[1]);
     set_b = FXARGB_B(pPalette[1]);
     for (int col = 0; col < width; col ++) {
@@ skipping 25 matching lines @@
         *dest_alpha_scan ++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         dest_scan ++;
     }
 }
-void _CompositeRow_ByteMask2Argb(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b, int pixel_count,
-                                 int blend_type, FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
@@ skipping 35 matching lines @@
         } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         }
         dest_scan += 2;
     }
 }
-void _CompositeRow_ByteMask2Rgba(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b, int pixel_count,
-                                 int blend_type, FX_LPCBYTE clip_scan,
-                                 FX_LPBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         uint8_t back_alpha = *dest_alpha_scan;
         if (back_alpha == 0) {
@@ skipping 40 matching lines @@
         } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
         }
     }
 }
-void _CompositeRow_ByteMask2Rgb(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b, int pixel_count,
-                                int blend_type, int Bpp, FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
@@ skipping 23 matching lines @@
         } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
         }
         dest_scan += Bpp - 2;
     }
 }
-void _CompositeRow_ByteMask2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int pixel_count,
-                                 FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         uint8_t back_alpha = *dest_scan;
         if (!back_alpha) {
             *dest_scan = src_alpha;
         } else if (src_alpha) {
             *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         }
         dest_scan ++;
     }
 }
-void _CompositeRow_ByteMask2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_gray,
-                                 int pixel_count, FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         if (src_alpha) {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
         }
         dest_scan ++;
     }
 }
-void _CompositeRow_ByteMask2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_gray,
-                                  int pixel_count, FX_LPCBYTE clip_scan,
-                                  FX_LPBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         uint8_t back_alpha = *dest_alpha_scan;
         if (back_alpha == 0) {
             *dest_scan ++ = src_gray;
             *dest_alpha_scan ++ = src_alpha;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan ++;
             dest_alpha_scan ++;
             continue;
         }
         uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
         dest_scan ++;
     }
 }
-void _CompositeRow_BitMask2Argb(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b,
-                                int src_left, int pixel_count, int blend_type, FX_LPCBYTE 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 == NULL && mask_alpha == 255) {
         FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
         for (int col = 0; col < pixel_count; col ++) {
             if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
                 FXARGB_SETDIB(dest_scan, argb);
             }
             dest_scan += 4;
         }
         return;
@@ skipping 45 matching lines @@
         } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         }
         dest_scan += 2;
     }
 }
-void _CompositeRow_BitMask2Rgba(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b,
-                                int src_left, int pixel_count, int blend_type, FX_LPCBYTE clip_scan,
-                                FX_LPBYTE dest_alpha_scan)
+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 == NULL && 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;
@@ skipping 53 matching lines @@
         } 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(FX_LPBYTE dest_scan, FX_LPCBYTE 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, FX_LPCBYTE 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 == NULL && mask_alpha == 255) {
         for (int col = 0; col < pixel_count; col ++) {
             if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
                 dest_scan[2] = src_r;
                 dest_scan[1] = src_g;
                 dest_scan[0] = src_b;
             }
             dest_scan += Bpp;
         }
@@ skipping 38 matching lines @@
         } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
         }
         dest_scan += Bpp - 2;
     }
 }
-void _CompositeRow_BitMask2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_left,
-                                int pixel_count, FX_LPCBYTE 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 ++;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
         uint8_t back_alpha = *dest_scan;
         if (!back_alpha) {
             *dest_scan = src_alpha;
         } else if (src_alpha) {
             *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         }
         dest_scan ++;
     }
 }
-void _CompositeRow_BitMask2Gray(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_gray,
-                                int src_left, int pixel_count, FX_LPCBYTE 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 ++;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
         if (src_alpha) {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha);
         }
         dest_scan ++;
     }
 }
-void _CompositeRow_BitMask2Graya(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_gray,
-                                 int src_left, int pixel_count, FX_LPCBYTE clip_scan,
-                                 FX_LPBYTE 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 ++;
             dest_alpha_scan ++;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
@@ skipping 11 matching lines @@
             dest_alpha_scan ++;
             continue;
         }
         uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
         dest_scan ++;
     }
 }
-void _CompositeRow_Argb2Argb_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, int blend_type, FX_LPCBYTE 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 ++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (clip_scan) {
                 int src_alpha = clip_scan[col] * src_scan[3] / 255;
                 dest_scan[3] = src_alpha;
                 dest_scan[0] = src_scan[2];
@@ skipping 36 matching lines @@
                 dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
             } else {
                 dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
             }
             src_scan ++;
         }
         dest_scan += 4;
         src_scan++;
     }
 }
-void _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE 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;
     for (int col = 0; col < width; col ++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (src_Bpp == 4) {
                 FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
             } else {
@@ skipping 16 matching lines @@
             int src_color = FX_GAMMA(*src_scan);
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, dest_scan[index], src_color);
             dest_scan[index] = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
             src_scan ++;
         }
         dest_scan += 4;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Argb2Rgb_Blend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha;
         if (clip_scan) {
             src_alpha = src_scan[3] * (*clip_scan++) / 255;
         } else {
             src_alpha = src_scan[3];
         }
@@ skipping 14 matching lines @@
             int back_color = FX_GAMMA(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));
             src_scan ++;
         }
         dest_scan += dest_Bpp;
         src_scan ++;
     }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp)
+inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int src_Bpp)
 {
     for (int col = 0; col < width; col ++) {
         if (src_Bpp == 4) {
             FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
         } else {
             FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
         }
         dest_scan += 4;
         src_scan += src_Bpp;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int 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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         if (bNonseparableBlend) {
             uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             int back_color = FX_GAMMA(dest_scan[index]);
             int src_color = FX_GAMMA(*src_scan);
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, back_color, src_color);
             dest_scan[index] = FX_GAMMA_INVERSE(blended);
             src_scan ++;
         }
         dest_scan += dest_Bpp;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha;
         if (clip_scan) {
             src_alpha = src_scan[3] * (*clip_scan++) / 255;
         } else {
             src_alpha = src_scan[3];
         }
         if (src_alpha == 255) {
             dest_scan[2] = FX_GAMMA_INVERSE(*src_scan++);
@@ skipping 10 matching lines @@
         }
         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));
             src_scan ++;
         }
         dest_scan += dest_Bpp;
         src_scan ++;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp)
+inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int dest_Bpp, int src_Bpp)
 {
     for (int col = 0; col < width; col ++) {
         dest_scan[2] = src_scan[0];
         dest_scan[1] = src_scan[1];
         dest_scan[0] = src_scan[2];
         dest_scan += dest_Bpp;
         src_scan += src_Bpp;
     }
 }
-inline void _CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         int src_alpha = *clip_scan ++;
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             dest_scan[2] = FX_GAMMA(*src_scan++);
             dest_scan[1] = FX_GAMMA(*src_scan++);
@@ skipping 23 matching lines @@
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, dest_scan[index], src_color);
             blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
             dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
             src_scan ++;
         }
         dest_scan += 4;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha = *clip_scan ++;
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += src_Bpp;
             continue;
@@ skipping 11 matching lines @@
             int back_color = FX_GAMMA(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));
             src_scan ++;
         }
         dest_scan += dest_Bpp;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     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[3] = 255;
             dest_scan += 4;
@@ skipping 11 matching lines @@
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], FX_GAMMA(*src_scan), alpha_ratio);
             src_scan ++;
         }
         dest_scan += 4;
         src_scan += src_gap;
     }
 }
-inline void _CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, int dest_Bpp, int src_Bpp, FX_LPCBYTE clip_scan)
+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)
 {
     for (int col = 0; col < width; col ++) {
         int src_alpha = clip_scan[col];
         if (src_alpha == 255) {
             dest_scan[2] = src_scan[0];
             dest_scan[1] = src_scan[1];
             dest_scan[0] = src_scan[2];
         } else if (src_alpha) {
             dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), FX_GAMMA(*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));
             src_scan ++;
             dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), FX_GAMMA(*src_scan), src_alpha));
             dest_scan += dest_Bpp;
             src_scan += src_Bpp - 2;
             continue;
         }
         dest_scan += dest_Bpp;
         src_scan += src_Bpp;
     }
 }
-inline void _CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, FX_ARGB* pPalette, int pixel_count,
-        int DestBpp, FX_LPCBYTE clip_scan)
+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)
 {
     for (int col = 0; col < pixel_count; col ++) {
         FX_ARGB argb = pPalette ? pPalette[*src_scan] : (*src_scan) * 0x010101;
         int src_r = FXARGB_R(argb);
         int src_g = FXARGB_G(argb);
         int src_b = FXARGB_B(argb);
         if (clip_scan && clip_scan[col] < 255) {
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
         } else {
             dest_scan[2] = src_b;
             dest_scan[1] = src_g;
             dest_scan[0] = src_r;
         }
         dest_scan += DestBpp;
         src_scan ++;
     }
 }
-inline void _CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left,
-        FX_ARGB* pPalette, int pixel_count, int DestBpp, FX_LPCBYTE clip_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)
 {
     int reset_r, reset_g, reset_b;
     int set_r, set_g, set_b;
     if (pPalette) {
         reset_r = FXARGB_R(pPalette[0]);
         reset_g = FXARGB_G(pPalette[0]);
         reset_b = FXARGB_B(pPalette[0]);
         set_r = FXARGB_R(pPalette[1]);
         set_g = FXARGB_G(pPalette[1]);
         set_b = FXARGB_B(pPalette[1]);
@@ skipping 17 matching lines @@
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]);
         } else {
             dest_scan[2] = src_b;
             dest_scan[1] = src_g;
             dest_scan[0] = src_r;
         }
         dest_scan += DestBpp;
     }
 }
-inline void _CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width,
-        FX_ARGB* pPalette, FX_LPCBYTE clip_scan)
+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)
 {
     for (int col = 0; col < width; col ++) {
         int src_r, src_g, src_b;
         if (pPalette) {
             FX_ARGB argb = pPalette[*src_scan];
             src_r = FXARGB_R(argb);
             src_g = FXARGB_G(argb);
             src_b = FXARGB_B(argb);
         } else {
             src_r = src_g = src_b = *src_scan;
@@ skipping 17 matching lines @@
         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 += 4;
         src_scan ++;
     }
 }
-inline void _CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left, int width,
-        FX_ARGB* pPalette, FX_LPCBYTE clip_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)
 {
     int reset_r, reset_g, reset_b;
     int set_r, set_g, set_b;
     if (pPalette) {
         reset_r = FXARGB_R(pPalette[0]);
         reset_g = FXARGB_G(pPalette[0]);
         reset_b = FXARGB_B(pPalette[0]);
         set_r = FXARGB_R(pPalette[1]);
         set_g = FXARGB_G(pPalette[1]);
         set_b = FXARGB_B(pPalette[1]);
@@ skipping 28 matching lines @@
         int back_alpha = dest_scan[3];
         uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], 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 += 4;
     }
 }
-void _CompositeRow_ByteMask2Argb_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b, int pixel_count,
-        int blend_type, FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
@@ skipping 33 matching lines @@
             blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
         } else {
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
         }
         dest_scan += 4;
     }
 }
-void _CompositeRow_ByteMask2Rgb_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b, int pixel_count,
-        int blend_type, int Bpp, FX_LPCBYTE 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) {
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
@@ skipping 21 matching lines @@
             blended = _BLEND(blend_type, dest_scan[0], src_r);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, src_alpha);
         } else {
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
         }
         dest_scan += Bpp;
     }
 }
-void _CompositeRow_BitMask2Argb_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int src_r, int src_g, int src_b,
-        int src_left, int pixel_count, int blend_type, FX_LPCBYTE 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 == NULL && mask_alpha == 255) {
         FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
         for (int col = 0; col < pixel_count; col ++) {
             if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
                 FXARGB_SETRGBORDERDIB(dest_scan, argb);
             }
             dest_scan += 4;
         }
         return;
@@ skipping 43 matching lines @@
             blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio);
         } else {
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio);
         }
         dest_scan += 4;
     }
 }
-void _CompositeRow_BitMask2Rgb_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE 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, FX_LPCBYTE 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 == NULL && mask_alpha == 255) {
         for (int col = 0; col < pixel_count; col ++) {
             if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
                 dest_scan[2] = src_b;
                 dest_scan[1] = src_g;
                 dest_scan[0] = src_r;
             }
             dest_scan += Bpp;
         }
@@ skipping 62 matching lines @@
         mask_red = FXARGB_R(mask_color);
         mask_green = FXARGB_G(mask_color);
         mask_blue = FXARGB_B(mask_color);
     }
     if (dest_format == FXDIB_8bppMask) {
         return TRUE;
     }
     if ((dest_format & 0xff) == 8) {
         if (pIccTransform) {
             mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color);
-            FX_LPBYTE gray_p = (FX_LPBYTE)&mask_color;
+            uint8_t* gray_p = (uint8_t*)&mask_color;
             pIccModule->TranslateScanline(pIccTransform, gray_p, gray_p, 1);
             mask_red = dest_format & 0x0400 ? FX_CCOLOR(gray_p[0]) : gray_p[0];
         } else {
             if (alpha_flag >> 8) {
                 uint8_t r, g, b;
                 AdobeCMYK_to_sRGB1(mask_red, mask_green, mask_blue, mask_black,
                                    r, g, b);
                 mask_red = FXRGB2GRAY(r, g, b);
             } else {
                 mask_red = FXRGB2GRAY(mask_red, mask_green, mask_blue);
             }
             if (dest_format & 0x0400) {
                 mask_red = FX_CCOLOR(mask_red);
             }
         }
     } else {
-        FX_LPBYTE mask_color_p = (FX_LPBYTE)&mask_color;
+        uint8_t* mask_color_p = (uint8_t*)&mask_color;
         mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color);
         if (pIccTransform) {
             pIccModule->TranslateScanline(pIccTransform, mask_color_p, mask_color_p, 1);
             mask_red = mask_color_p[2];
             mask_green = mask_color_p[1];
             mask_blue = mask_color_p[0];
         } else if (alpha_flag >> 8) {
             AdobeCMYK_to_sRGB1(mask_color_p[0], mask_color_p[1], mask_color_p[2], mask_color_p[3],
                                mask_color_p[2], mask_color_p[1], mask_color_p[0]);
             mask_red = mask_color_p[2];
             mask_green = mask_color_p[1];
             mask_blue = mask_color_p[0];
         }
     }
     return TRUE;
 }
 inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format, FXDIB_Format dest_format,
         FX_DWORD*& pDestPalette, FX_DWORD* pSrcPalette,
         void* icc_module, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
     FX_BOOL isSrcCmyk = src_format & 0x0400 ? TRUE : FALSE;
     FX_BOOL isDstCmyk = dest_format & 0x0400 ? TRUE : FALSE;
     pDestPalette = NULL;
     if (pIccTransform) {
         if (pSrcPalette) {
             if ((dest_format & 0xff) == 8) {
                 int pal_count = 1 << (src_format & 0xff);
-                FX_LPBYTE gray_pal = FX_Alloc(uint8_t, pal_count);
+                uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
                 pDestPalette = (FX_DWORD*)gray_pal;
                 for (int i = 0; i < pal_count; i ++) {
                     FX_DWORD color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i]) : FXARGB_TODIB(pSrcPalette[i]);
-                    pIccModule->TranslateScanline(pIccTransform, gray_pal, (FX_LPCBYTE)&color, 1);
+                    pIccModule->TranslateScanline(pIccTransform, gray_pal, (const uint8_t*)&color, 1);
                     gray_pal ++;
                 }
             } else {
                 int palsize = 1 << (src_format & 0xff);
                 pDestPalette = FX_Alloc(FX_DWORD, palsize);
                 for (int i = 0; i < palsize; i ++) {
                     FX_DWORD color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i]) : FXARGB_TODIB(pSrcPalette[i]);
-                    pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&color, (FX_LPCBYTE)&color, 1);
+                    pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color, (const uint8_t*)&color, 1);
                     pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
                 }
             }
         } else {
             int pal_count = 1 << (src_format & 0xff);
-            FX_LPBYTE gray_pal = FX_Alloc(uint8_t, pal_count);
+            uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
             if (pal_count == 2) {
                 gray_pal[0] = 0;
                 gray_pal[1] = 255;
             } else {
                 for (int i = 0; i < pal_count; i++) {
                     gray_pal[i] = i;
                 }
             }
             if ((dest_format & 0xff) == 8) {
                 pIccModule->TranslateScanline(pIccTransform, gray_pal, gray_pal, pal_count);
                 pDestPalette = (FX_DWORD*)gray_pal;
             } else {
                 pDestPalette = FX_Alloc(FX_DWORD, pal_count);
                 for (int i = 0; i < pal_count; i ++) {
-                    pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&pDestPalette[i], &gray_pal[i], 1);
+                    pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&pDestPalette[i], &gray_pal[i], 1);
                     pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(pDestPalette[i]) : FXARGB_TODIB(pDestPalette[i]);
                 }
                 FX_Free(gray_pal);
             }
         }
     } else {
         if (pSrcPalette) {
             if ((dest_format & 0xff) == 8) {
                 int pal_count = 1 << (src_format & 0xff);
-                FX_LPBYTE gray_pal = FX_Alloc(uint8_t, pal_count);
+                uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
                 pDestPalette = (FX_DWORD*)gray_pal;
                 if (isSrcCmyk) {
                     for (int i = 0; i < pal_count; i ++) {
                         FX_CMYK cmyk = pSrcPalette[i];
                         uint8_t r, g, b;
                         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk),
                                            r, g, b);
                         *gray_pal ++ = FXRGB2GRAY(r, g, b);
                     }
                 } else
@@ skipping 12 matching lines @@
                         uint8_t r, g, b;
                         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk),
                                            r, g, b);
                         pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
                     }
                 }
             }
         } else {
             if ((dest_format & 0xff) == 8) {
                 int pal_count = 1 << (src_format & 0xff);
-                FX_LPBYTE gray_pal = FX_Alloc(uint8_t, pal_count);
+                uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
                 if (pal_count == 2) {
                     gray_pal[0] = 0;
                     gray_pal[1] = 255;
                 } else {
                     for (int i = 0; i < pal_count; i++) {
                         gray_pal[i] = i;
                     }
                 }
                 pDestPalette = (FX_DWORD*)gray_pal;
             } else {
@@ skipping 77 matching lines @@
     }
     m_Transparency = (src_format & 0x0200 ? 0 : 1)
                      + (dest_format & 0x0200 ? 0 : 2)
                      + (blend_type == FXDIB_BLEND_NORMAL ? 4 : 0)
                      + (bClip ? 8 : 0)
                      + (src_format & 0x0400 ? 16 : 0)
                      + (dest_format & 0x0400 ? 32 : 0)
                      + (pIccTransform ? 64 : 0);
     return TRUE;
 }
-void CFX_ScanlineCompositor::CompositeRgbBitmapLine(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_extra_alpha, FX_LPBYTE dst_extra_alpha)
+void CFX_ScanlineCompositor::CompositeRgbBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int width, const uint8_t* clip_scan,
+        const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
 {
     int src_Bpp = (m_SrcFormat & 0xff) >> 3;
     int dest_Bpp = (m_DestFormat & 0xff) >> 3;
     if (m_bRgbByteOrder) {
         switch (m_Transparency) {
             case 0:
             case 4:
             case 8:
             case 12:
                 _CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width, m_BlendType, clip_scan);
@@ skipping 171 matching lines @@
             case 1+2+4+8:
                 _CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan);
                 break;
             case 1+2+4+8+64:
                 _CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan,
                         m_pCacheScanline, m_pIccTransform);
                 break;
         }
     }
 }
-void CFX_ScanlineCompositor::CompositePalBitmapLine(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left, int width, FX_LPCBYTE clip_scan,
-        FX_LPCBYTE src_extra_alpha, FX_LPBYTE dst_extra_alpha)
+void CFX_ScanlineCompositor::CompositePalBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int src_left, int width, const uint8_t* clip_scan,
+        const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
 {
     if (m_bRgbByteOrder) {
         if (m_SrcFormat == FXDIB_1bppRgb) {
             if (m_DestFormat == FXDIB_8bppRgb) {
                 return;
             } else if(m_DestFormat == FXDIB_Argb) {
                 _CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan);
             } else {
                 _CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, src_left, m_pSrcPalette, width, (m_DestFormat & 0xff) >> 3, clip_scan);
             }
         } else {
             if (m_DestFormat == FXDIB_8bppRgb) {
                 return;
             } else if (m_DestFormat == FXDIB_Argb) {
                 _CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(dest_scan, src_scan, width, m_pSrcPalette, clip_scan);
             } else {
                 _CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, m_pSrcPalette, width, (m_DestFormat & 0xff) >> 3, clip_scan);
             }
         }
         return;
     }
     if (m_DestFormat == FXDIB_8bppMask) {
         _CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
         return;
     } else if ((m_DestFormat & 0xff) == 8) {
         if (m_Transparency & 8) {
             if (m_DestFormat & 0x0200) {
-                _CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left, (FX_LPCBYTE)m_pSrcPalette, width, m_BlendType, clip_scan, dst_extra_alpha);
+                _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, (FX_LPCBYTE)m_pSrcPalette, width, m_BlendType, clip_scan);
+                _CompositeRow_1bppPal2Gray(dest_scan, src_scan, src_left, (const uint8_t*)m_pSrcPalette, width, m_BlendType, clip_scan);
             }
         } else {
             if (m_DestFormat & 0x0200)
-                _CompositeRow_8bppPal2Graya(dest_scan, src_scan, (FX_LPCBYTE)m_pSrcPalette, width, m_BlendType, clip_scan,
+                _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, (FX_LPCBYTE)m_pSrcPalette, width, m_BlendType, clip_scan,
+                _CompositeRow_8bppPal2Gray(dest_scan, src_scan, (const uint8_t*)m_pSrcPalette, width, m_BlendType, clip_scan,
                                            src_extra_alpha);
         }
     } else {
         switch (m_Transparency) {
             case 1+2:
                 _CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width, m_pSrcPalette, clip_scan,
                                                    src_extra_alpha);
                 break;
             case 1+2+8:
                 _CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan);
@@ skipping 10 matching lines @@
                                                   src_extra_alpha);
                 break;
             case 0+2+8:
                 _CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan,
                                                    dst_extra_alpha);
                 break;
                 break;
         }
     }
 }
-void CFX_ScanlineCompositor::CompositeByteMaskLine(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int width, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dst_extra_alpha)
+void CFX_ScanlineCompositor::CompositeByteMaskLine(uint8_t* dest_scan, const uint8_t* src_scan, int width, const uint8_t* clip_scan,
+        uint8_t* dst_extra_alpha)
 {
     if (m_DestFormat == FXDIB_8bppMask) {
         _CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width, clip_scan);
     } else if ((m_DestFormat & 0xff) == 8) {
         if (m_DestFormat & 0x0200) {
             _CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, width, clip_scan, dst_extra_alpha);
         } else {
             _CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, width, clip_scan);
         }
     } else if (m_bRgbByteOrder) {
         if (m_DestFormat == FXDIB_Argb)
             _CompositeRow_ByteMask2Argb_RgbByteOrder(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                     width, m_BlendType, clip_scan);
         else
             _CompositeRow_ByteMask2Rgb_RgbByteOrder(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                                     width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
         return;
     } else if (m_DestFormat == FXDIB_Argb)
         _CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                     width, m_BlendType, clip_scan);
     else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32)
         _CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                    width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
     else if (m_DestFormat == FXDIB_Rgba)
         _CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                     width, m_BlendType, clip_scan, dst_extra_alpha);
 }
-void CFX_ScanlineCompositor::CompositeBitMaskLine(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int src_left, int width, FX_LPCBYTE clip_scan,
-        FX_LPBYTE dst_extra_alpha)
+void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan, const uint8_t* src_scan, int src_left, int width, const uint8_t* clip_scan,
+        uint8_t* dst_extra_alpha)
 {
     if (m_DestFormat == FXDIB_8bppMask) {
         _CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width, clip_scan);
     } else if ((m_DestFormat & 0xff) == 8) {
         if (m_DestFormat & 0x0200)
             _CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, src_left, width, clip_scan,
                                         dst_extra_alpha);
         else {
             _CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, src_left, width, clip_scan);
         }
@@ skipping 39 matching lines @@
     CFX_ScanlineCompositor compositor;
     if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width, pSrcBitmap->GetPalette(), 0, blend_type,
                          pClipMask != NULL, bRgbByteOrder, 0, pIccTransform)) {
         return FALSE;
     }
     int dest_Bpp = m_bpp / 8;
     int src_Bpp = pSrcBitmap->GetBPP() / 8;
     FX_BOOL bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
     CFX_DIBitmap* pSrcAlphaMask = pSrcBitmap->m_pAlphaMask;
     for (int row = 0; row < height; row ++) {
-        FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
-        FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * src_Bpp;
-        FX_LPCBYTE src_scan_extra_alpha = pSrcAlphaMask ? pSrcAlphaMask->GetScanline(src_top + row) + src_left : NULL;
-        FX_LPBYTE dst_scan_extra_alpha = m_pAlphaMask ? (FX_LPBYTE)m_pAlphaMask->GetScanline(dest_top + row) + dest_left : NULL;
-        FX_LPCBYTE clip_scan = NULL;
+        uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
+        const uint8_t* src_scan = 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;
+        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;
         if (pClipMask) {
             clip_scan = pClipMask->m_pBuffer + (dest_top + row - clip_box.top) * pClipMask->m_Pitch + (dest_left - clip_box.left);
         }
         if (bRgb) {
             compositor.CompositeRgbBitmapLine(dest_scan, src_scan, width, clip_scan, src_scan_extra_alpha, dst_scan_extra_alpha);
         } else {
             compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width, clip_scan, src_scan_extra_alpha, dst_scan_extra_alpha);
         }
     }
     return TRUE;
@@ skipping 25 matching lines @@
         pClipMask = pClipRgn->GetMask();
         clip_box = pClipRgn->GetBox();
     }
     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)) {
         return FALSE;
     }
     for (int row = 0; row < height; row ++) {
-        FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
-        FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
-        FX_LPBYTE dst_scan_extra_alpha = m_pAlphaMask ? (FX_LPBYTE)m_pAlphaMask->GetScanline(dest_top + row) + dest_left : NULL;
-        FX_LPCBYTE clip_scan = NULL;
+        uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
+        const uint8_t* src_scan = pMask->GetScanline(src_top + row);
+        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;
         if (pClipMask) {
             clip_scan = pClipMask->m_pBuffer + (dest_top + row - clip_box.top) * pClipMask->m_Pitch + (dest_left - clip_box.left);
         }
         if (src_bpp == 1) {
             compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width, clip_scan, dst_scan_extra_alpha);
         } else {
             compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width, clip_scan, dst_scan_extra_alpha);
         }
     }
     return TRUE;
@@ skipping 12 matching lines @@
     if (rect.IsEmpty()) {
         return TRUE;
     }
     width = rect.Width();
     FX_DWORD dst_color;
     if (alpha_flag >> 8) {
         dst_color = FXCMYK_TODIB(color);
     } else {
         dst_color = FXARGB_TODIB(color);
     }
-    FX_LPBYTE color_p = (FX_LPBYTE)&dst_color;
+    uint8_t* color_p = (uint8_t*)&dst_color;
     if (m_bpp == 8) {
         uint8_t gray = 255;
         if (!IsAlphaMask()) {
             if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() && CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
                 ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
                 pIccModule->TranslateScanline(pIccTransform, &gray, color_p, 1);
             } else {
                 if (alpha_flag >> 8) {
                     uint8_t r, g, b;
                     AdobeCMYK_to_sRGB1(color_p[0], color_p[1], color_p[2], color_p[3],
                                        r, g, b);
                     gray = FXRGB2GRAY(r, g, b);
                 } else {
                     gray = (uint8_t)FXRGB2GRAY((int)color_p[2], color_p[1], color_p[0]);
                 }
             }
             if (IsCmykImage()) {
                 gray = ~gray;
             }
         }
         for (int row = rect.top; row < rect.bottom; row ++) {
-            FX_LPBYTE dest_scan = m_pBuffer + row * m_Pitch + rect.left;
+            uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left;
             if (src_alpha == 255) {
                 FXSYS_memset8(dest_scan, gray, width);
             } else
                 for (int col = 0; col < width; col ++) {
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
                     dest_scan ++;
                 }
         }
         return TRUE;
     } else if (m_bpp == 1) {
@@ skipping 50 matching lines @@
         }
     }
     if(!IsCmykImage()) {
         color_p[3] = (uint8_t)src_alpha;
     }
     int Bpp = m_bpp / 8;
     FX_BOOL bAlpha = HasAlpha();
     FX_BOOL bArgb = GetFormat() == FXDIB_Argb ? TRUE : FALSE;
     if (src_alpha == 255) {
         for (int row = rect.top; row < rect.bottom; row ++) {
-            FX_LPBYTE dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
-            FX_LPBYTE dest_scan_alpha = m_pAlphaMask ? (FX_LPBYTE)m_pAlphaMask->GetScanline(row) + rect.left : NULL;
+            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;
             if (dest_scan_alpha) {
                 FXSYS_memset8(dest_scan_alpha, 0xff, width);
             }
             if (Bpp == 4) {
                 FX_DWORD* scan = (FX_DWORD*)dest_scan;
                 for (int col = 0; col < width; col ++) {
                     *scan ++ = dst_color;
                 }
             } else {
                 for (int col = 0; col < width; col ++) {
                     *dest_scan ++ = color_p[0];
                     *dest_scan ++ = color_p[1];
                     *dest_scan ++ = color_p[2];
                 }
             }
         }
         return TRUE;
     }
     for (int row = rect.top; row < rect.bottom; row ++) {
-        FX_LPBYTE dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
+        uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
         if (bAlpha) {
             if (bArgb) {
                 for (int col = 0; col < width; col ++) {
                     uint8_t back_alpha = dest_scan[3];
                     if (back_alpha == 0) {
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, color_p[2], color_p[1], color_p[0]));
                         dest_scan += 4;
                         continue;
                     }
                     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                     int alpha_ratio = src_alpha * 255 / dest_alpha;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[0], alpha_ratio);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[1], alpha_ratio);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[2], alpha_ratio);
                     dest_scan ++;
                     *dest_scan++ = dest_alpha;
                 }
             } else {
-                FX_LPBYTE dest_scan_alpha = (FX_LPBYTE)m_pAlphaMask->GetScanline(row) + rect.left;
+                uint8_t* dest_scan_alpha = (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left;
                 for (int col = 0; col < width; col ++) {
                     uint8_t back_alpha = *dest_scan_alpha;
                     if (back_alpha == 0) {
                         *dest_scan_alpha++ = src_alpha;
                         FXSYS_memcpy32(dest_scan, color_p, Bpp);
                         dest_scan += Bpp;
                         continue;
                     }
                     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                     *dest_scan_alpha ++ = dest_alpha;
@@ skipping 80 matching lines @@
         m_pClipScanV = FX_Alloc(uint8_t, m_pBitmap->GetHeight());
         if (m_pBitmap->m_pAlphaMask) {
             m_pScanlineAlphaV = FX_Alloc(uint8_t, width + 4);
         }
     }
     if (m_BitmapAlpha < 255) {
         m_pAddClipScan = FX_Alloc(uint8_t, m_bVertical ? m_pBitmap->GetHeight() : m_pBitmap->GetWidth());
     }
     return TRUE;
 }
-void CFX_BitmapComposer::DoCompose(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int dest_width, FX_LPCBYTE clip_scan,
-                                   FX_LPCBYTE src_extra_alpha, FX_LPBYTE dst_extra_alpha)
+void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan, const uint8_t* src_scan, int dest_width, const uint8_t* clip_scan,
+                                   const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
 {
     if (m_BitmapAlpha < 255) {
         if (clip_scan) {
             for (int i = 0; i < dest_width; i ++) {
                 m_pAddClipScan[i] = clip_scan[i] * m_BitmapAlpha / 255;
             }
         } else {
             FXSYS_memset8(m_pAddClipScan, m_BitmapAlpha, dest_width);
         }
         clip_scan = m_pAddClipScan;
     }
     if (m_SrcFormat == FXDIB_8bppMask) {
         m_Compositor.CompositeByteMaskLine(dest_scan, src_scan, dest_width, clip_scan, dst_extra_alpha);
     } else if ((m_SrcFormat & 0xff) == 8) {
         m_Compositor.CompositePalBitmapLine(dest_scan, src_scan, 0, dest_width, clip_scan, src_extra_alpha, dst_extra_alpha);
     } else {
         m_Compositor.CompositeRgbBitmapLine(dest_scan, src_scan, dest_width, clip_scan, src_extra_alpha, dst_extra_alpha);
     }
 }
-void CFX_BitmapComposer::ComposeScanline(int line, FX_LPCBYTE scanline, FX_LPCBYTE scan_extra_alpha)
+void CFX_BitmapComposer::ComposeScanline(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha)
 {
     if (m_bVertical) {
         ComposeScanlineV(line, scanline, scan_extra_alpha);
         return;
     }
-    FX_LPCBYTE clip_scan = NULL;
+    const uint8_t* clip_scan = NULL;
     if (m_pClipMask)
         clip_scan = m_pClipMask->GetBuffer() + (m_DestTop + line - m_pClipRgn->GetBox().top) *
                     m_pClipMask->GetPitch() + (m_DestLeft - m_pClipRgn->GetBox().left);
-    FX_LPBYTE dest_scan = (FX_LPBYTE)m_pBitmap->GetScanline(line + m_DestTop) +
+    uint8_t* dest_scan = (uint8_t*)m_pBitmap->GetScanline(line + m_DestTop) +
                           m_DestLeft * m_pBitmap->GetBPP() / 8;
-    FX_LPBYTE dest_alpha_scan = m_pBitmap->m_pAlphaMask ?
-                                (FX_LPBYTE)m_pBitmap->m_pAlphaMask->GetScanline(line + m_DestTop) + m_DestLeft : NULL;
+    uint8_t* dest_alpha_scan = m_pBitmap->m_pAlphaMask ?
+                                (uint8_t*)m_pBitmap->m_pAlphaMask->GetScanline(line + m_DestTop) + m_DestLeft : NULL;
     DoCompose(dest_scan, scanline, m_DestWidth, clip_scan, scan_extra_alpha, dest_alpha_scan);
 }
-void CFX_BitmapComposer::ComposeScanlineV(int line, FX_LPCBYTE scanline, FX_LPCBYTE scan_extra_alpha)
+void CFX_BitmapComposer::ComposeScanlineV(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha)
 {
     int i;
     int Bpp = m_pBitmap->GetBPP() / 8;
     int dest_pitch = m_pBitmap->GetPitch();
     int dest_alpha_pitch = m_pBitmap->m_pAlphaMask ? m_pBitmap->m_pAlphaMask->GetPitch() : 0;
     int dest_x = m_DestLeft + (m_bFlipX ? (m_DestWidth - line - 1) : line);
-    FX_LPBYTE dest_buf = m_pBitmap->GetBuffer() + dest_x * Bpp + m_DestTop * dest_pitch;
-    FX_LPBYTE dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
+    uint8_t* dest_buf = m_pBitmap->GetBuffer() + dest_x * Bpp + m_DestTop * dest_pitch;
+    uint8_t* dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
                                m_pBitmap->m_pAlphaMask->GetBuffer() + dest_x + m_DestTop * dest_alpha_pitch : NULL;
     if (m_bFlipY) {
         dest_buf += dest_pitch * (m_DestHeight - 1);
         dest_alpha_buf += dest_alpha_pitch * (m_DestHeight - 1);
     }
     int y_step = dest_pitch;
     int y_alpha_step = dest_alpha_pitch;
     if (m_bFlipY) {
         y_step = -y_step;
         y_alpha_step = -y_alpha_step;
     }
-    FX_LPBYTE src_scan = m_pScanlineV;
-    FX_LPBYTE dest_scan = dest_buf;
+    uint8_t* src_scan = m_pScanlineV;
+    uint8_t* dest_scan = dest_buf;
     for (i = 0; i < m_DestHeight; i ++) {
         for (int j = 0; j < Bpp; j ++) {
             *src_scan++ = dest_scan[j];
         }
         dest_scan += y_step;
     }
-    FX_LPBYTE src_alpha_scan = m_pScanlineAlphaV;
-    FX_LPBYTE dest_alpha_scan = dest_alpha_buf;
+    uint8_t* src_alpha_scan = m_pScanlineAlphaV;
+    uint8_t* dest_alpha_scan = dest_alpha_buf;
     if (dest_alpha_scan) {
         for (i = 0; i < m_DestHeight; i ++) {
             *src_alpha_scan++ = *dest_alpha_scan;
             dest_alpha_scan += y_alpha_step;
         }
     }
-    FX_LPBYTE clip_scan = NULL;
+    uint8_t* clip_scan = NULL;
     if (m_pClipMask) {
         clip_scan = m_pClipScanV;
         int clip_pitch = m_pClipMask->GetPitch();
-        FX_LPCBYTE src_clip = m_pClipMask->GetBuffer() + (m_DestTop - m_pClipRgn->GetBox().top) *
+        const uint8_t* src_clip = m_pClipMask->GetBuffer() + (m_DestTop - m_pClipRgn->GetBox().top) *
                               clip_pitch + (dest_x - m_pClipRgn->GetBox().left);
         if (m_bFlipY) {
             src_clip += clip_pitch * (m_DestHeight - 1);
             clip_pitch = -clip_pitch;
         }
         for (i = 0; i < m_DestHeight; i ++) {
             clip_scan[i] = *src_clip;
             src_clip += clip_pitch;
         }
     }
     DoCompose(m_pScanlineV, scanline, m_DestHeight, clip_scan, scan_extra_alpha, m_pScanlineAlphaV);
     src_scan = m_pScanlineV;
     dest_scan = dest_buf;
     for (i = 0; i < m_DestHeight; i ++) {
         for (int j = 0; j < Bpp; j ++) {
             dest_scan[j] = *src_scan++;
         }
         dest_scan += y_step;
     }
     src_alpha_scan = m_pScanlineAlphaV;
     dest_alpha_scan = dest_alpha_buf;
     if (dest_alpha_scan) {
         for (i = 0; i < m_DestHeight; i ++) {
             *dest_alpha_scan = *src_alpha_scan++;
             dest_alpha_scan += y_alpha_step;
         }
     }
 }