Merge to XFA: Use stdint.h types throughout PDFium.

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 FX_BYTE g_GammaRamp[256] = {
+const uint8_t g_GammaRamp[256] = {
     0,   0,   0,   0,   0,   0,   0,   1,   1,   1,   1,   1,   1,   1,   1,   1,
     1,   1,   2,   2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   3,
     4,   4,   4,   4,   4,   5,   5,   5,   5,   6,   6,   6,   6,   7,   7,   7,
     8,   8,   8,   8,   9,   9,   9,  10,  10,  10,  11,  11,  12,  12,  12,  13,
     13,  13,  14,  14,  15,  15,  16,  16,  17,  17,  17,  18,  18,  19,  19,  20,
     20,  21,  22,  22,  23,  23,  24,  24,  25,  25,  26,  27,  27,  28,  29,  29,
     30,  30,  31,  32,  32,  33,  34,  35,  35,  36,  37,  37,  38,  39,  40,  41,
     41,  42,  43,  44,  45,  45,  46,  47,  48,  49,  50,  51,  51,  52,  53,  54,
     55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,
     71,  72,  73,  74,  76,  77,  78,  79,  80,  81,  82,  84,  85,  86,  87,  88,
     90,  91,  92,  93,  95,  96,  97,  99, 100, 101, 103, 104, 105, 107, 108, 109,
     111, 112, 114, 115, 116, 118, 119, 121, 122, 124, 125, 127, 128, 130, 131, 133,
     134, 136, 138, 139, 141, 142, 144, 146, 147, 149, 151, 152, 154, 156, 157, 159,
     161, 163, 164, 166, 168, 170, 171, 173, 175, 177, 179, 181, 183, 184, 186, 188,
     190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220,
     222, 224, 226, 229, 231, 233, 235, 237, 239, 242, 244, 246, 248, 250, 253, 255,
 };
-const FX_BYTE g_GammaInverse[256] = {
+const uint8_t g_GammaInverse[256] = {
     0,  13,  22,  28,  34,  38,  42,  46,  50,  53,  56,  59,  61,  64,  66,  69,
     71,  73,  75,  77,  79,  81,  83,  85,  86,  88,  90,  92,  93,  95,  96,  98,
     99, 101, 102, 104, 105, 106, 108, 109, 110, 112, 113, 114, 115, 117, 118, 119,
     120, 121, 122, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
     137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 148, 149, 150, 151,
     152, 153, 154, 155, 155, 156, 157, 158, 159, 159, 160, 161, 162, 163, 163, 164,
     165, 166, 167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 175, 176,
     177, 178, 178, 179, 180, 180, 181, 182, 182, 183, 184, 185, 185, 186, 187, 187,
     188, 189, 189, 190, 190, 191, 192, 192, 193, 194, 194, 195, 196, 196, 197, 197,
     198, 199, 199, 200, 200, 201, 202, 202, 203, 203, 204, 205, 205, 206, 206, 207,
     208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215, 215, 216,
     216, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
     225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233,
     233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
     241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 246, 247, 247, 248,
     248, 249, 249, 250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255,
 };
-const FX_BYTE _color_sqrt[256] = {
+const uint8_t _color_sqrt[256] = {
     0x00, 0x03, 0x07, 0x0B, 0x0F, 0x12, 0x16, 0x19, 0x1D, 0x20, 0x23, 0x26, 0x29, 0x2C, 0x2F, 0x32,
     0x35, 0x37, 0x3A, 0x3C, 0x3F, 0x41, 0x43, 0x46, 0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56,
     0x57, 0x59, 0x5B, 0x5C, 0x5E, 0x60, 0x61, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D,
     0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E,
     0x8F, 0x90, 0x91, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C,
     0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA7, 0xA8,
     0xA9, 0xAA, 0xAA, 0xAB, 0xAC, 0xAD, 0xAD, 0xAE, 0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB3, 0xB4,
     0xB5, 0xB5, 0xB6, 0xB7, 0xB7, 0xB8, 0xB9, 0xBA, 0xBA, 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBE, 0xBF,
     0xC0, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4, 0xC4, 0xC5, 0xC6, 0xC6, 0xC7, 0xC7, 0xC8, 0xC9, 0xC9,
@@ skipping 163 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, FX_BYTE* dest_scan, int results[3])
+void _RGB_Blend(int blend_mode, FX_LPCBYTE 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:
@@ skipping 14 matching lines @@
     results[2] = result.red;
 }
 inline void _CompositeRow_Argb2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int pixel_count, FX_LPCBYTE 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;
         }
-        FX_BYTE back_alpha = *dest_scan;
+        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)
 {
     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;
         }
-        FX_BYTE back_alpha = *dest_scan;
+        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)
 {
@@ skipping 12 matching lines @@
 {
     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 ++) {
-                FX_BYTE back_alpha = *dst_alpha_scan;
+                uint8_t back_alpha = *dst_alpha_scan;
                 if (back_alpha == 0) {
                     int src_alpha = *src_alpha_scan++;
                     if (clip_scan) {
                         src_alpha = clip_scan[col] * src_alpha / 255;
                     }
                     if (src_alpha) {
                         if (pIccTransform) {
                             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                         } else {
                             *dest_scan =  FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                         }
                         *dst_alpha_scan = src_alpha;
                     }
                     dest_scan ++;
                     dst_alpha_scan ++;
                     src_scan += 3;
                     continue;
                 }
-                FX_BYTE src_alpha = *src_alpha_scan++;
+                uint8_t src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan ++;
                     dst_alpha_scan ++;
                     src_scan += 3;
                     continue;
                 }
                 *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
                 int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
-                FX_BYTE gray;
+                uint8_t gray;
                 if (pIccTransform) {
                     pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
                 } else {
                     gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                 }
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
                 gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
                 dest_scan ++;
                 dst_alpha_scan++;
                 src_scan += 3;
             }
         } else
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE back_alpha = *dst_alpha_scan;
+                uint8_t back_alpha = *dst_alpha_scan;
                 if (back_alpha == 0) {
                     int src_alpha = src_scan[3];
                     if (clip_scan) {
                         src_alpha = clip_scan[col] * src_alpha / 255;
                     }
                     if (src_alpha) {
                         if (pIccTransform) {
                             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                         } else {
                             *dest_scan =  FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                         }
                         *dst_alpha_scan = src_alpha;
                     }
                     dest_scan ++;
                     dst_alpha_scan ++;
                     src_scan += 4;
                     continue;
                 }
-                FX_BYTE src_alpha = src_scan[3];
+                uint8_t src_alpha = src_scan[3];
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan ++;
                     dst_alpha_scan ++;
                     src_scan += 4;
                     continue;
                 }
                 *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
                 int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
-                FX_BYTE gray;
+                uint8_t gray;
                 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 ++;
                 dst_alpha_scan++;
                 src_scan += 4;
             }
         return;
     }
     if (src_alpha_scan) {
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE back_alpha = *dst_alpha_scan;
+            uint8_t back_alpha = *dst_alpha_scan;
             if (back_alpha == 0) {
                 int src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha) {
                     if (pIccTransform) {
                         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                     } else {
                         *dest_scan =  FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                     }
                     *dst_alpha_scan = src_alpha;
                 }
                 dest_scan ++;
                 dst_alpha_scan ++;
                 src_scan += 3;
                 continue;
             }
-            FX_BYTE src_alpha = *src_alpha_scan++;
+            uint8_t src_alpha = *src_alpha_scan++;
             if (clip_scan) {
                 src_alpha = clip_scan[col] * src_alpha / 255;
             }
             if (src_alpha == 0) {
                 dest_scan ++;
                 dst_alpha_scan ++;
                 src_scan += 3;
                 continue;
             }
             *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
             int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
-            FX_BYTE gray;
+            uint8_t gray;
             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 ++;
             dst_alpha_scan++;
             src_scan += 3;
         }
     } else
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE back_alpha = *dst_alpha_scan;
+            uint8_t back_alpha = *dst_alpha_scan;
             if (back_alpha == 0) {
                 int src_alpha = src_scan[3];
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha) {
                     if (pIccTransform) {
                         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                     } else {
                         *dest_scan =  FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                     }
                     *dst_alpha_scan = src_alpha;
                 }
                 dest_scan ++;
                 dst_alpha_scan ++;
                 src_scan += 4;
                 continue;
             }
-            FX_BYTE src_alpha = src_scan[3];
+            uint8_t src_alpha = src_scan[3];
             if (clip_scan) {
                 src_alpha = clip_scan[col] * src_alpha / 255;
             }
             if (src_alpha == 0) {
                 dest_scan ++;
                 dst_alpha_scan ++;
                 src_scan += 4;
                 continue;
             }
             *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
             int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
-            FX_BYTE gray;
+            uint8_t gray;
             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 ++;
             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)
 {
     ICodec_IccModule* pIccModule = NULL;
-    FX_BYTE gray;
+    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) {
             for (int col = 0; col < pixel_count; col ++) {
                 int src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
@@ skipping 70 matching lines @@
             }
             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,
                                    void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = NULL;
-    FX_BYTE gray;
+    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;
         for (int col = 0; col < pixel_count; col ++) {
             if (pIccTransform) {
                 pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
             } else {
@@ skipping 55 matching lines @@
             int src_alpha = 255;
             if (clip_scan) {
                 src_alpha = clip_scan[col];
             }
             if (src_alpha == 0) {
                 dest_scan ++;
                 dest_alpha_scan ++;
                 src_scan += src_Bpp;
                 continue;
             }
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            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;
-            FX_BYTE gray;
+            uint8_t gray;
             if (pIccTransform) {
                 pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
             } else {
                 gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
             }
             if (bNonseparableBlend) {
                 blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
             }
             gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
@@ skipping 18 matching lines @@
             src_scan += src_Bpp;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan ++;
             dest_alpha_scan ++;
             src_scan += src_Bpp;
             continue;
         }
         int back_alpha = *dest_alpha_scan;
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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;
-        FX_BYTE gray;
+        uint8_t gray;
         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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     if (dest_alpha_scan == NULL) {
         if (src_alpha_scan == NULL) {
-            FX_BYTE back_alpha = 0;
+            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) {
                         int src_alpha = clip_scan[col] * src_scan[3] / 255;
                         FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) | (src_alpha << 24));
                     } else {
                         FXARGB_COPY(dest_scan, src_scan);
                     }
                     dest_scan += 4;
                     src_scan += 4;
                     continue;
                 }
-                FX_BYTE src_alpha;
+                uint8_t src_alpha;
                 if (clip_scan == NULL) {
                     src_alpha = src_scan[3];
                 } else {
                     src_alpha = clip_scan[col] * src_scan[3] / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan += 4;
                     src_scan += 4;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 dest_scan[3] = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
                 }
                 for (int color = 0; color < 3; color ++) {
                     if (blend_type) {
                         int blended = bNonseparableBlend ? blended_colors[color] :
                                       _BLEND(blend_type, *dest_scan, *src_scan);
                         blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
                     } else {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                     }
                     dest_scan ++;
                     src_scan ++;
                 }
                 dest_scan ++;
                 src_scan ++;
             }
         } else {
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE back_alpha = dest_scan[3];
+                uint8_t back_alpha = dest_scan[3];
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE((src_alpha << 24), src_scan[2], src_scan[1], *src_scan));
                     } else {
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE((*src_alpha_scan << 24), src_scan[2], src_scan[1], *src_scan));
                     }
                     dest_scan += 4;
                     src_scan += 3;
                     src_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE src_alpha;
+                uint8_t src_alpha;
                 if (clip_scan == NULL) {
                     src_alpha = *src_alpha_scan ++;
                 } else {
                     src_alpha = clip_scan[col] * (*src_alpha_scan ++) / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan += 4;
                     src_scan += 3;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 dest_scan[3] = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
                 }
                 for (int color = 0; color < 3; color ++) {
                     if (blend_type) {
                         int blended = bNonseparableBlend ? blended_colors[color] :
                                       _BLEND(blend_type, *dest_scan, *src_scan);
                         blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
                     } else {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                     }
                     dest_scan ++;
                     src_scan ++;
                 }
                 dest_scan ++;
             }
         }
     } else {
         if (src_alpha_scan) {
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE back_alpha = *dest_alpha_scan;
+                uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
                         *dest_alpha_scan = src_alpha;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                     } else {
                         *dest_alpha_scan = *src_alpha_scan;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                     }
                     dest_alpha_scan ++;
                     src_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE src_alpha;
+                uint8_t src_alpha;
                 if (clip_scan == NULL) {
                     src_alpha = *src_alpha_scan ++;
                 } else {
                     src_alpha = clip_scan[col] * (*src_alpha_scan ++) / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan += 3;
                     src_scan += 3;
                     dest_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 *dest_alpha_scan ++ = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
                 }
                 for (int color = 0; color < 3; color ++) {
                     if (blend_type) {
                         int blended = bNonseparableBlend ? blended_colors[color] :
                                       _BLEND(blend_type, *dest_scan, *src_scan);
                         blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
                     } else {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                     }
                     dest_scan ++;
                     src_scan ++;
                 }
             }
         } else {
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE back_alpha = *dest_alpha_scan;
+                uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * src_scan[3] / 255;
                         *dest_alpha_scan = src_alpha;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                     } else {
                         *dest_alpha_scan = src_scan[3];
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                         *dest_scan++ = *src_scan++;
                     }
                     dest_alpha_scan ++;
                     src_scan ++;
                     continue;
                 }
-                FX_BYTE src_alpha;
+                uint8_t src_alpha;
                 if (clip_scan == NULL) {
                     src_alpha = src_scan[3];
                 } else {
                     src_alpha = clip_scan[col] * src_scan[3] / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan += 3;
                     src_scan += 4;
                     dest_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 *dest_alpha_scan++ = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
                 }
                 for (int color = 0; color < 3; color ++) {
                     if (blend_type) {
                         int blended = bNonseparableBlend ? blended_colors[color] :
                                       _BLEND(blend_type, *dest_scan, *src_scan);
                         blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
@@ skipping 10 matching lines @@
     }
 }
 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)
 {
     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 ++) {
-            FX_BYTE back_alpha = dest_scan[3];
+            uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 if (src_Bpp == 4) {
                     FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
                 } else {
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
                 }
                 dest_scan += 4;
                 src_scan += src_Bpp;
                 continue;
             }
             dest_scan[3] = 0xff;
             if (bNonseparableBlend) {
                 _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             }
             for (int color = 0; color < 3; color ++) {
                 int src_color = *src_scan;
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, *dest_scan, src_color);
                 *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan ++;
             src_scan += src_gap;
         }
     } else {
         for (int col = 0; col < width; col ++) {
-            FX_BYTE back_alpha = *dest_alpha_scan;
+            uint8_t back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_alpha_scan++ = 0xff;
                 src_scan += src_gap;
                 continue;
             }
             *dest_alpha_scan++ = 0xff;
             if (bNonseparableBlend) {
@@ skipping 13 matching lines @@
 }
 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)
 {
     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 ++;
-            FX_BYTE back_alpha = dest_scan[3];
+            uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 src_scan += src_gap;
                 dest_scan ++;
                 continue;
             }
             if (src_alpha == 0) {
                 dest_scan += 4;
                 src_scan += src_Bpp;
                 continue;
             }
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             dest_scan[3] = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             if (bNonseparableBlend) {
                 _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             }
             for (int color = 0; color < 3; color ++) {
                 int src_color = *src_scan;
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, *dest_scan, src_color);
                 blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan ++;
             src_scan += src_gap;
         }
     } else {
         for (int col = 0; col < width; col ++) {
             int src_alpha = *clip_scan ++;
-            FX_BYTE back_alpha = *dest_alpha_scan;
+            uint8_t back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 src_scan += src_gap;
                 dest_alpha_scan++;
                 continue;
             }
             if (src_alpha == 0) {
                 dest_scan += 3;
                 dest_alpha_scan++;
                 src_scan += src_Bpp;
                 continue;
             }
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             if (bNonseparableBlend) {
                 _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             }
             for (int color = 0; color < 3; color ++) {
                 int src_color = *src_scan;
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, *dest_scan, src_color);
                 blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
@@ skipping 19 matching lines @@
                 *dest_scan++ = 255;
                 src_scan += src_gap;
                 continue;
             }
             if (src_alpha == 0) {
                 dest_scan += 4;
                 src_scan += src_Bpp;
                 continue;
             }
             int back_alpha = dest_scan[3];
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             dest_scan[3] = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             for (int color = 0; color < 3; color ++) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan ++;
             src_scan += src_gap;
         }
     } else {
         for (int col = 0; col < width; col ++) {
             int src_alpha = clip_scan[col];
             if (src_alpha == 255) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_alpha_scan++ = 255;
                 src_scan += src_gap;
                 continue;
             }
             if (src_alpha == 0) {
                 dest_scan += 3;
                 dest_alpha_scan ++;
                 src_scan += src_Bpp;
                 continue;
             }
             int back_alpha = *dest_alpha_scan;
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan ++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             for (int color = 0; color < 3; color ++) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
                 dest_scan ++;
                 src_scan ++;
             }
             src_scan += src_gap;
         }
     }
@@ skipping 23 matching lines @@
     }
 }
 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)
 {
     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 ++) {
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             if (src_alpha == 0) {
                 dest_scan += dest_Bpp;
                 src_scan += 4;
                 continue;
             }
             if (bNonseparableBlend) {
                 _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             }
             for (int color = 0; color < 3; color ++) {
                 int back_color = *dest_scan;
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, back_color, *src_scan);
                 *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan += dest_gap;
             src_scan ++;
         }
     } else {
         for (int col = 0; col < width; col ++) {
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
             } else {
                 src_alpha = *src_alpha_scan++;
             }
             if (src_alpha == 0) {
                 dest_scan += dest_Bpp;
                 src_scan += 3;
                 continue;
             }
@@ skipping 11 matching lines @@
             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)
 {
     int dest_gap = dest_Bpp - 3;
     if (src_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             if (src_alpha == 255) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 dest_scan += dest_gap;
                 src_scan ++;
                 continue;
             }
             if (src_alpha == 0) {
                 dest_scan += dest_Bpp;
                 src_scan += 4;
                 continue;
             }
             for (int color = 0; color < 3; color ++) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan += dest_gap;
             src_scan ++;
         }
     } else {
         for (int col = 0; col < width; col ++) {
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
             } else {
                 src_alpha = *src_alpha_scan++;
             }
             if (src_alpha == 255) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 dest_scan += dest_gap;
@@ skipping 36 matching lines @@
         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)
 {
     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 ++) {
-        FX_BYTE src_alpha = *clip_scan ++;
+        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;
@@ skipping 69 matching lines @@
                 pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
                 dp[3] = src_scan[3];
                 src_scan += 4;
                 dp += 4;
             }
         } else {
             int blended_colors[3];
             FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             for (int col = 0; col < pixel_count; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
-                FX_BYTE back_alpha = *dest_alpha_scan;
+                uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * src_scan[3] / 255;
                         *dest_alpha_scan = src_alpha;
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
                     } else {
                         *dest_alpha_scan = src_scan[3];
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
                     }
                     dest_alpha_scan ++;
                     src_scan += 4;
                     continue;
                 }
-                FX_BYTE src_alpha;
+                uint8_t src_alpha;
                 if (clip_scan == NULL) {
                     src_alpha = src_scan[3];
                 } else {
                     src_alpha = clip_scan[col] * src_scan[3] / 255;
                 }
                 src_scan += 4;
                 if (src_alpha == 0) {
                     dest_scan += 3;
                     src_cache_scan += 3;
                     dest_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 *dest_alpha_scan ++ = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     _RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors);
                 }
                 for (int color = 0; color < 3; color ++) {
                     if (blend_type) {
                         int blended = bNonseparableBlend ? blended_colors[color] :
                                       _BLEND(blend_type, *dest_scan, *src_cache_scan);
                         blended = FXDIB_ALPHA_MERGE(*src_cache_scan, blended, back_alpha);
@@ skipping 79 matching lines @@
 {
     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);
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             src_scan += 4;
             if (src_alpha == 0) {
                 dest_scan += dest_Bpp;
                 src_cache_scan += 3;
                 continue;
@@ skipping 18 matching lines @@
 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)
 {
     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);
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             src_scan += 4;
             if (src_alpha == 255) {
                 *dest_scan++ = *src_cache_scan++;
                 *dest_scan++ = *src_cache_scan++;
                 *dest_scan++ = *src_cache_scan++;
@@ skipping 82 matching lines @@
 }
 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)
 {
     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 ++) {
-                FX_BYTE gray = pPalette[*src_scan];
+                uint8_t gray = pPalette[*src_scan];
                 int src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
                 gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
                 if (src_alpha) {
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
                 } else {
                     *dest_scan = gray;
                 }
                 dest_scan ++;
                 src_scan ++;
             }
             return;
         }
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE gray = pPalette[*src_scan];
+            uint8_t gray = pPalette[*src_scan];
             int src_alpha = *src_alpha_scan++;
             if (clip_scan) {
                 src_alpha = clip_scan[col] * src_alpha / 255;
             }
             if (src_alpha) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
             } else {
                 *dest_scan = gray;
             }
             dest_scan ++;
             src_scan ++;
         }
     } else {
         if (blend_type) {
             FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE gray = pPalette[*src_scan];
+                uint8_t gray = pPalette[*src_scan];
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
                 gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
                 if (clip_scan && clip_scan[col] < 255) {
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
                 } else {
                     *dest_scan = gray;
                 }
                 dest_scan ++;
                 src_scan ++;
             }
             return;
         }
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE gray = pPalette[*src_scan];
+            uint8_t gray = pPalette[*src_scan];
             if (clip_scan && clip_scan[col] < 255) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
             } else {
                 *dest_scan = gray;
             }
             dest_scan ++;
             src_scan ++;
         }
     }
 }
 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)
 {
     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 ++) {
-                FX_BYTE gray = pPalette[*src_scan];
+                uint8_t gray = pPalette[*src_scan];
                 src_scan ++;
-                FX_BYTE back_alpha = *dest_alpha_scan;
+                uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     int src_alpha = *src_alpha_scan ++;
                     if (clip_scan) {
                         src_alpha = clip_scan[col] * src_alpha / 255;
                     }
                     if (src_alpha) {
                         *dest_scan = gray;
                         *dest_alpha_scan = src_alpha;
                     }
                     dest_scan ++;
                     dest_alpha_scan ++;
                     continue;
                 }
-                FX_BYTE src_alpha = *src_alpha_scan++;
+                uint8_t src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha == 0) {
                     dest_scan ++;
                     dest_alpha_scan ++;
                     continue;
                 }
                 *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
                 gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
                 dest_alpha_scan ++;
                 dest_scan ++;
             }
             return;
         }
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE gray = pPalette[*src_scan];
+            uint8_t gray = pPalette[*src_scan];
             src_scan ++;
-            FX_BYTE back_alpha = *dest_alpha_scan;
+            uint8_t back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
                 int src_alpha = *src_alpha_scan ++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha) {
                     *dest_scan = gray;
                     *dest_alpha_scan = src_alpha;
                 }
                 dest_scan ++;
                 dest_alpha_scan ++;
                 continue;
             }
-            FX_BYTE src_alpha = *src_alpha_scan++;
+            uint8_t src_alpha = *src_alpha_scan++;
             if (clip_scan) {
                 src_alpha = clip_scan[col] * src_alpha / 255;
             }
             if (src_alpha == 0) {
                 dest_scan ++;
                 dest_alpha_scan ++;
                 continue;
             }
             *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
             dest_alpha_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
             dest_scan ++;
         }
     } else {
         if (blend_type) {
             FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
-                FX_BYTE gray = pPalette[*src_scan];
+                uint8_t gray = pPalette[*src_scan];
                 src_scan ++;
                 if (clip_scan == NULL || clip_scan[col] == 255) {
                     *dest_scan++ = gray;
                     *dest_alpha_scan++ = 255;
                     continue;
                 }
                 int src_alpha = clip_scan[col];
                 if (src_alpha == 0) {
                     dest_scan ++;
                     dest_alpha_scan ++;
                     continue;
                 }
                 int back_alpha = *dest_alpha_scan;
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 *dest_alpha_scan ++ = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
                 gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
                 dest_scan ++;
             }
             return;
         }
         for (int col = 0; col < pixel_count; col ++) {
-            FX_BYTE gray = pPalette[*src_scan];
+            uint8_t gray = pPalette[*src_scan];
             src_scan ++;
             if (clip_scan == NULL || clip_scan[col] == 255) {
                 *dest_scan++ = gray;
                 *dest_alpha_scan++ = 255;
                 continue;
             }
             int src_alpha = clip_scan[col];
             if (src_alpha == 0) {
                 dest_scan ++;
                 dest_alpha_scan ++;
                 continue;
             }
             int back_alpha = *dest_alpha_scan;
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            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)
 {
     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 ++) {
-            FX_BYTE gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
+            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;
             }
             gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
             if (clip_scan && clip_scan[col] < 255) {
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
             } else {
                 *dest_scan = gray;
             }
             dest_scan ++;
         }
         return;
     }
     for (int col = 0; col < pixel_count; col ++) {
-        FX_BYTE gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
+        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)
 {
     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 ++) {
-            FX_BYTE gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
+            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;
                 *dest_alpha_scan ++ = 255;
                 continue;
             }
             int src_alpha = clip_scan[col];
             if (src_alpha == 0) {
                 dest_scan ++;
                 dest_alpha_scan ++;
                 continue;
             }
             int back_alpha = *dest_alpha_scan;
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan ++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             if (bNonseparableBlend) {
                 blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
             }
             gray = bNonseparableBlend ? blended_color : _BLEND(blend_type, *dest_scan, gray);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
             dest_scan ++;
         }
         return;
     }
     for (int col = 0; col < pixel_count; col ++) {
-        FX_BYTE gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
+        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;
             *dest_alpha_scan ++ = 255;
             continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
             dest_scan ++;
             dest_alpha_scan ++;
             continue;
         }
         int back_alpha = *dest_alpha_scan;
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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)
 {
     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 ++;
-            FX_BYTE src_alpha = 0;
+            uint8_t src_alpha = 0;
             if (clip_scan) {
                 src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
             } else {
                 src_alpha = *src_alpha_scan++;
             }
             if (src_alpha == 255) {
                 *dest_scan++ = src_b;
                 *dest_scan++ = src_g;
                 *dest_scan++ = src_r;
                 dest_scan += dest_gap;
@@ skipping 80 matching lines @@
         FX_DWORD* pPalette, FX_LPCBYTE clip_scan,
         FX_LPCBYTE 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);
-            FX_BYTE back_alpha = dest_scan[3];
+            uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 if (clip_scan) {
                     int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
                 } else {
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(*src_alpha_scan, src_r, src_g, src_b));
                 }
                 dest_scan += 4;
                 src_alpha_scan ++;
                 continue;
             }
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan == NULL) {
                 src_alpha = *src_alpha_scan ++;
             } else {
                 src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
             }
             if (src_alpha == 0) {
                 dest_scan += 4;
                 continue;
             }
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             dest_scan[3] = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
             dest_scan ++;
         }
@@ skipping 11 matching lines @@
                 src_scan ++;
                 continue;
             }
             int src_alpha = clip_scan[col];
             if (src_alpha == 0) {
                 dest_scan += 4;
                 src_scan ++;
                 continue;
             }
             int back_alpha = dest_scan[3];
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             dest_scan[3] = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
             dest_scan ++;
             src_scan ++;
         }
 }
 void _CompositeRow_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)
 {
     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);
-            FX_BYTE back_alpha = *dest_alpha_scan;
+            uint8_t back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
                 if (clip_scan) {
                     int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255;
                     *dest_alpha_scan ++ = src_alpha;
                 } else {
                     *dest_alpha_scan ++ = *src_alpha_scan;
                 }
                 *dest_scan ++ = src_b;
                 *dest_scan ++ = src_g;
                 *dest_scan ++ = src_r;
                 src_alpha_scan ++;
                 continue;
             }
-            FX_BYTE src_alpha;
+            uint8_t src_alpha;
             if (clip_scan == NULL) {
                 src_alpha = *src_alpha_scan++;
             } else {
                 src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
             }
             if (src_alpha == 0) {
                 dest_scan += 3;
                 dest_alpha_scan ++;
                 continue;
             }
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan ++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
         }
     } else
@@ skipping 11 matching lines @@
                 continue;
             }
             int src_alpha = clip_scan[col];
             if (src_alpha == 0) {
                 dest_scan += 3;
                 dest_alpha_scan ++;
                 src_scan ++;
                 continue;
             }
             int back_alpha = *dest_alpha_scan;
-            FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+            uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
             *dest_alpha_scan ++ = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
             dest_scan ++;
             src_scan ++;
         }
@@ skipping 26 matching lines @@
             *dest_scan++ = src_r;
             *dest_scan++ = 255;
             continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
             dest_scan += 4;
             continue;
         }
         int back_alpha = dest_scan[3];
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         dest_scan ++;
         dest_scan ++;
     }
@@ skipping 28 matching lines @@
             *dest_alpha_scan++ = 255;
             continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
             dest_scan += 3;
             dest_alpha_scan ++;
             continue;
         }
         int back_alpha = *dest_alpha_scan;
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan ++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
         dest_scan ++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         dest_scan ++;
     }
 }
 void _CompositeRow_ByteMask2Argb(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)
 {
     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;
         }
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
             dest_scan += 4;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan += 4;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
         } else if (blend_type) {
@@ skipping 22 matching lines @@
                                  int blend_type, FX_LPCBYTE clip_scan,
                                  FX_LPBYTE 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;
         }
-        FX_BYTE back_alpha = *dest_alpha_scan;
+        uint8_t back_alpha = *dest_alpha_scan;
         if (back_alpha == 0) {
             *dest_scan ++ = src_b;
             *dest_scan ++ = src_g;
             *dest_scan ++ = src_r;
             *dest_alpha_scan ++ = src_alpha;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan += 3;
             dest_alpha_scan ++;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan ++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
             dest_scan ++;
@@ skipping 29 matching lines @@
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
             continue;
         }
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
         } else if (blend_type) {
@@ skipping 18 matching lines @@
 void _CompositeRow_ByteMask2Mask(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan, int mask_alpha, int pixel_count,
                                  FX_LPCBYTE 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;
         }
-        FX_BYTE back_alpha = *dest_scan;
+        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)
@@ skipping 15 matching lines @@
                                   int pixel_count, FX_LPCBYTE clip_scan,
                                   FX_LPBYTE 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;
         }
-        FX_BYTE back_alpha = *dest_alpha_scan;
+        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;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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)
 {
     if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL && mask_alpha == 255) {
@@ skipping 10 matching lines @@
         if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
             dest_scan += 4;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
             dest_scan += 4;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
         } else if (blend_type) {
@@ skipping 40 matching lines @@
             dest_scan += 3;
             dest_alpha_scan ++;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             *dest_scan ++ = src_b;
             *dest_scan ++ = src_g;
             *dest_scan ++ = src_r;
             *dest_alpha_scan ++ = mask_alpha;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan ++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
             dest_scan ++;
@@ skipping 44 matching lines @@
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
             continue;
         }
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
+            uint8_t src_scan[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
             dest_scan ++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
         } else if (blend_type) {
@@ skipping 22 matching lines @@
         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;
         }
-        FX_BYTE back_alpha = *dest_scan;
+        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)
@@ skipping 24 matching lines @@
             dest_scan ++;
             dest_alpha_scan ++;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
-        FX_BYTE back_alpha = *dest_alpha_scan;
+        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;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col ++) {
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (clip_scan) {
                 int src_alpha = clip_scan[col] * src_scan[3] / 255;
                 dest_scan[3] = src_alpha;
                 dest_scan[0] = src_scan[2];
                 dest_scan[1] = src_scan[1];
                 dest_scan[2] = src_scan[0];
             } else {
                 FXARGB_RGBORDERCOPY(dest_scan, src_scan);
             }
             dest_scan += 4;
             src_scan += 4;
             continue;
         }
-        FX_BYTE src_alpha;
+        uint8_t src_alpha;
         if (clip_scan == NULL) {
             src_alpha = src_scan[3];
         } else {
             src_alpha = clip_scan[col] * src_scan[3] / 255;
         }
         if (src_alpha == 0) {
             dest_scan += 4;
             src_scan += 4;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (bNonseparableBlend) {
-            FX_BYTE dest_scan_o[3];
+            uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             if (blend_type) {
                 int blended = bNonseparableBlend ? blended_colors[color] :
                               _BLEND(blend_type, dest_scan[index], *src_scan);
                 blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha);
                 dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
             } else {
                 dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio);
             }
             src_scan ++;
         }
         dest_scan += 4;
         src_scan++;
     }
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(FX_LPBYTE dest_scan, FX_LPCBYTE 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 ++) {
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (src_Bpp == 4) {
                 FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
             } else {
                 FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
             }
             dest_scan += 4;
             src_scan += src_Bpp;
             continue;
         }
         dest_scan[3] = 0xff;
         if (bNonseparableBlend) {
-            FX_BYTE dest_scan_o[3];
+            uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             int src_color = 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)
 {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < width; col ++) {
-        FX_BYTE src_alpha;
+        uint8_t src_alpha;
         if (clip_scan) {
             src_alpha = src_scan[3] * (*clip_scan++) / 255;
         } else {
             src_alpha = src_scan[3];
         }
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += 4;
             continue;
         }
         if (bNonseparableBlend) {
-            FX_BYTE dest_scan_o[3];
+            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 blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, back_color, *src_scan);
@@ skipping 16 matching lines @@
         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)
 {
     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) {
-            FX_BYTE dest_scan_o[3];
+            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)
 {
     for (int col = 0; col < width; col ++) {
-        FX_BYTE src_alpha;
+        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++);
             dest_scan[1] = FX_GAMMA_INVERSE(*src_scan++);
             dest_scan[0] = FX_GAMMA_INVERSE(*src_scan++);
             dest_scan += dest_Bpp;
@@ skipping 24 matching lines @@
         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)
 {
     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 ++;
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             dest_scan[2] = FX_GAMMA(*src_scan++);
             dest_scan[1] = FX_GAMMA(*src_scan++);
             dest_scan[0] = FX_GAMMA(*src_scan++);
             src_scan += src_gap;
             dest_scan += 4;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan += 4;
             src_scan += src_Bpp;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (bNonseparableBlend) {
-            FX_BYTE dest_scan_o[3];
+            uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             int src_color = FX_GAMMA(*src_scan);
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, dest_scan[index], src_color);
             blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
             dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio);
             src_scan ++;
         }
         dest_scan += 4;
         src_scan += src_gap;
     }
 }
 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)
 {
     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 ++) {
-        FX_BYTE src_alpha = *clip_scan ++;
+        uint8_t src_alpha = *clip_scan ++;
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += src_Bpp;
             continue;
         }
         if (bNonseparableBlend) {
-            FX_BYTE dest_scan_o[3];
+            uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             int src_color = FX_GAMMA(*src_scan);
             int back_color = FX_GAMMA(dest_scan[index]);
             int blended = bNonseparableBlend ? blended_colors[color] :
@@ skipping 18 matching lines @@
             dest_scan += 4;
             src_scan  += src_gap;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan += 4;
             src_scan += src_Bpp;
             continue;
         }
         int back_alpha = dest_scan[3];
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         for (int color = 0; color < 3; color ++) {
             int index = 2 - color;
             dest_scan[index] = FXDIB_ALPHA_MERGE(dest_scan[index], FX_GAMMA(*src_scan), alpha_ratio);
             src_scan ++;
         }
         dest_scan += 4;
         src_scan += src_gap;
     }
@@ skipping 102 matching lines @@
             dest_scan += 4;
             continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
             dest_scan += 4;
             src_scan ++;
             continue;
         }
         int back_alpha = dest_scan[3];
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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,
@@ skipping 30 matching lines @@
             dest_scan[3] = 255;
             dest_scan += 4;
             continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
             dest_scan += 4;
             continue;
         }
         int back_alpha = dest_scan[3];
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        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)
 {
     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;
         }
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
             dest_scan += 4;
             continue;
         }
         if (src_alpha == 0) {
             dest_scan += 4;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
-            FX_BYTE dest_scan_o[3];
+            uint8_t src_scan[3];
+            uint8_t dest_scan_o[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             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);
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
@@ skipping 24 matching lines @@
             src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
         } else {
             src_alpha = mask_alpha * src_scan[col] / 255;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
             continue;
         }
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
-            FX_BYTE dest_scan_o[3];
+            uint8_t src_scan[3];
+            uint8_t dest_scan_o[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             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);
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
@@ skipping 29 matching lines @@
         if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) {
             dest_scan += 4;
             continue;
         }
         int src_alpha;
         if (clip_scan) {
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
-        FX_BYTE back_alpha = dest_scan[3];
+        uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
             dest_scan += 4;
             continue;
         }
-        FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+        uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
-            FX_BYTE dest_scan_o[3];
+            uint8_t src_scan[3];
+            uint8_t dest_scan_o[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             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);
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
@@ skipping 39 matching lines @@
             src_alpha = mask_alpha * clip_scan[col] / 255;
         } else {
             src_alpha = mask_alpha;
         }
         if (src_alpha == 0) {
             dest_scan += Bpp;
             continue;
         }
         if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
             int blended_colors[3];
-            FX_BYTE src_scan[3];
-            FX_BYTE dest_scan_o[3];
+            uint8_t src_scan[3];
+            uint8_t dest_scan_o[3];
             src_scan[0] = src_b;
             src_scan[1] = src_g;
             src_scan[2] = src_r;
             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);
             dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
             dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
             dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
@@ skipping 36 matching lines @@
         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;
             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) {
-                FX_BYTE r, g, b;
+                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);
             }
         }
@@ skipping 20 matching lines @@
         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(FX_BYTE, pal_count);
+                FX_LPBYTE 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);
                     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);
                     pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
                 }
             }
         } else {
             int pal_count = 1 << (src_format & 0xff);
-            FX_LPBYTE gray_pal = FX_Alloc(FX_BYTE, pal_count);
+            FX_LPBYTE 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);
                     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(FX_BYTE, pal_count);
+                FX_LPBYTE 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];
-                        FX_BYTE r, g, b;
+                        uint8_t r, g, b;
                         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk),
                                            r, g, b);
                         *gray_pal ++ = FXRGB2GRAY(r, g, b);
                     }
                 } else
                     for (int i = 0; i < pal_count; i ++) {
                         FX_ARGB argb = pSrcPalette[i];
                         *gray_pal ++ = FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
                     }
             } else {
                 int palsize = 1 << (src_format & 0xff);
                 pDestPalette = FX_Alloc(FX_DWORD, palsize);
                 if (isDstCmyk == isSrcCmyk) {
                     FXSYS_memcpy32(pDestPalette, pSrcPalette, palsize * sizeof(FX_DWORD));
                 } else {
                     for (int i = 0; i < palsize; i ++) {
                         FX_CMYK cmyk = pSrcPalette[i];
-                        FX_BYTE r, g, b;
+                        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(FX_BYTE, pal_count);
+                FX_LPBYTE 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 {
                 int palsize = 1 << (src_format & 0xff);
                 pDestPalette = FX_Alloc(FX_DWORD, palsize);
                 if (palsize == 2) {
                     pDestPalette[0] = isSrcCmyk ? 255 : 0xff000000;
                     pDestPalette[1] = isSrcCmyk ? 0 : 0xffffffff;
                 } else {
                     for (int i = 0; i < palsize; i++) {
                         pDestPalette[i] = isSrcCmyk ? FX_CCOLOR(i) : (i * 0x10101);
                     }
                 }
                 if (isSrcCmyk != isDstCmyk) {
                     for (int i = 0; i < palsize; i ++) {
                         FX_CMYK cmyk = pDestPalette[i];
-                        FX_BYTE r, g, b;
+                        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);
                     }
                 }
             }
         }
     }
 }
 CFX_ScanlineCompositor::CFX_ScanlineCompositor()
 {
     m_pSrcPalette = NULL;
     m_pCacheScanline = NULL;
     m_CacheSize = 0;
     m_bRgbByteOrder = FALSE;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ScanlineCompositor::~CFX_ScanlineCompositor()
 {
     if (m_pSrcPalette) {
         FX_Free(m_pSrcPalette);
     }
     if (m_pCacheScanline) {
         FX_Free(m_pCacheScanline);
     }
 }
-FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_format, FX_INT32 width, FX_DWORD* pSrcPalette,
+FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_format, int32_t width, FX_DWORD* pSrcPalette,
                                      FX_DWORD mask_color, int blend_type, FX_BOOL bClip, FX_BOOL bRgbByteOrder, int alpha_flag, void* pIccTransform)
 {
     m_SrcFormat = src_format;
     m_DestFormat = dest_format;
     m_BlendType = blend_type;
     m_bRgbByteOrder = bRgbByteOrder;
     ICodec_IccModule* pIccModule = NULL;
     if (CFX_GEModule::Get()->GetCodecModule()) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
@@ skipping 113 matching lines @@
         }
         if (m_DestFormat & 0x0400) {
             for (int i = 0; i < width; i ++) {
                 *dest_scan = ~*dest_scan;
                 dest_scan++;
             }
         }
     } else {
         int dest_Size = width * dest_Bpp + 4;
         if (dest_Size > m_CacheSize) {
-            m_pCacheScanline = FX_Realloc(FX_BYTE, m_pCacheScanline, dest_Size);
+            m_pCacheScanline = FX_Realloc(uint8_t, m_pCacheScanline, dest_Size);
             if (!m_pCacheScanline) {
                 return;
             }
             m_CacheSize = dest_Size;
         }
         switch (m_Transparency) {
             case 0:
             case 4:
             case 8:
             case 4+8: {
@@ skipping 276 matching lines @@
     }
     ASSERT(pMask->IsAlphaMask());
     ASSERT(m_bpp >= 8);
     if (!pMask->IsAlphaMask() || m_bpp < 8) {
         return FALSE;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, pClipRgn);
     if (width == 0 || height == 0) {
         return TRUE;
     }
-    int src_alpha = (FX_BYTE)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
+    int src_alpha = (uint8_t)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
     if (src_alpha == 0) {
         return TRUE;
     }
     const CFX_DIBitmap* pClipMask = NULL;
     FX_RECT clip_box;
     if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
         ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
         pClipMask = pClipRgn->GetMask();
         clip_box = pClipRgn->GetBox();
     }
@@ skipping 35 matching lines @@
     }
     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;
     if (m_bpp == 8) {
-        FX_BYTE gray = 255;
+        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) {
-                    FX_BYTE r, g, b;
+                    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 = (FX_BYTE)FXRGB2GRAY((int)color_p[2], color_p[1], color_p[0]);
+                    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;
             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) {
-        ASSERT(!IsCmykImage() && (FX_BYTE)(alpha_flag >> 8) == 0);
+        ASSERT(!IsCmykImage() && (uint8_t)(alpha_flag >> 8) == 0);
         int left_shift = rect.left % 8;
         int right_shift = rect.right % 8;
         int width = rect.right / 8 - rect.left / 8;
         int index = 0;
         if (m_pPalette == NULL) {
-            index = ((FX_BYTE)color == 0xff) ? 1 : 0;
+            index = ((uint8_t)color == 0xff) ? 1 : 0;
         } else {
             for (int i = 0; i < 2; i ++)
                 if (m_pPalette[i] == color) {
                     index = i;
                 }
         }
         for (int row = rect.top; row < rect.bottom; row ++) {
-            FX_BYTE* dest_scan_top = (FX_BYTE*)GetScanline(row) + rect.left / 8;
-            FX_BYTE* dest_scan_top_r = (FX_BYTE*)GetScanline(row) + rect.right / 8;
-            FX_BYTE left_flag =  *dest_scan_top & (255 << (8 - left_shift));
-            FX_BYTE right_flag = *dest_scan_top_r & (255 >> right_shift);
+            uint8_t* dest_scan_top = (uint8_t*)GetScanline(row) + rect.left / 8;
+            uint8_t* dest_scan_top_r = (uint8_t*)GetScanline(row) + rect.right / 8;
+            uint8_t left_flag =  *dest_scan_top & (255 << (8 - left_shift));
+            uint8_t right_flag = *dest_scan_top_r & (255 >> right_shift);
             if (width) {
                 FXSYS_memset8(dest_scan_top + 1, index ? 255 : 0, width - 1);
                 if (!index) {
                     *dest_scan_top &= left_flag;
                     *dest_scan_top_r &= right_flag;
                 } else {
                     *dest_scan_top |= ~left_flag;
                     *dest_scan_top_r |= ~right_flag;
                 }
             } else {
@@ skipping 15 matching lines @@
         pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
     } else {
         if (alpha_flag >> 8 && !IsCmykImage())
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
             return FALSE;
         }
     }
     if(!IsCmykImage()) {
-        color_p[3] = (FX_BYTE)src_alpha;
+        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;
             if (dest_scan_alpha) {
                 FXSYS_memset8(dest_scan_alpha, 0xff, width);
@@ skipping 11 matching lines @@
                 }
             }
         }
         return TRUE;
     }
     for (int row = rect.top; row < rect.bottom; row ++) {
         FX_LPBYTE dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
         if (bAlpha) {
             if (bArgb) {
                 for (int col = 0; col < width; col ++) {
-                    FX_BYTE back_alpha = dest_scan[3];
+                    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;
                     }
-                    FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                    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;
                 for (int col = 0; col < width; col ++) {
-                    FX_BYTE back_alpha = *dest_scan_alpha;
+                    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;
                     }
-                    FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                    uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                     *dest_scan_alpha ++ = dest_alpha;
                     int alpha_ratio = src_alpha * 255 / dest_alpha;
                     for(int comps = 0; comps < Bpp; comps ++) {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], alpha_ratio);
                         dest_scan ++;
                     }
                 }
             }
         } else {
             for (int col = 0; col < width; col ++) {
@@ skipping 60 matching lines @@
     m_BlendType = blend_type;
 }
 FX_BOOL CFX_BitmapComposer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
 {
     m_SrcFormat = src_format;
     if (!m_Compositor.Init(m_pBitmap->GetFormat(), src_format, width, pSrcPalette, m_MaskColor, FXDIB_BLEND_NORMAL,
                            m_pClipMask != NULL || (m_BitmapAlpha < 255), m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform)) {
         return FALSE;
     }
     if (m_bVertical) {
-        m_pScanlineV = FX_Alloc(FX_BYTE, m_pBitmap->GetBPP() / 8 * width + 4);
-        m_pClipScanV = FX_Alloc(FX_BYTE, m_pBitmap->GetHeight());
+        m_pScanlineV = FX_Alloc(uint8_t, m_pBitmap->GetBPP() / 8 * width + 4);
+        m_pClipScanV = FX_Alloc(uint8_t, m_pBitmap->GetHeight());
         if (m_pBitmap->m_pAlphaMask) {
-            m_pScanlineAlphaV = FX_Alloc(FX_BYTE, width + 4);
+            m_pScanlineAlphaV = FX_Alloc(uint8_t, width + 4);
         }
     }
     if (m_BitmapAlpha < 255) {
-        m_pAddClipScan = FX_Alloc(FX_BYTE, m_bVertical ? m_pBitmap->GetHeight() : m_pBitmap->GetWidth());
+        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)
 {
     if (m_BitmapAlpha < 255) {
         if (clip_scan) {
             for (int i = 0; i < dest_width; i ++) {
                 m_pAddClipScan[i] = clip_scan[i] * m_BitmapAlpha / 255;
@@ skipping 89 matching lines @@
     }
     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;
         }
     }
 }