FX Bool considered harmful, part 3

core/src/fxge/dib/fx_dib_composite.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 const uint8_t _color_sqrt[256] = {
@@ skipping 254 matching lines @@
     }
 }
 void _CompositeRow_Argb2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count, int blend_type, const uint8_t* clip_scan,
                               const uint8_t* src_alpha_scan, uint8_t* dst_alpha_scan, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = NULL;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         if (src_alpha_scan) {
             for (int col = 0; col < pixel_count; col ++) {
                 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) {
@@ skipping 174 matching lines @@
 inline void _CompositeRow_Argb2Gray(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count,
                                     int blend_type, const uint8_t* clip_scan,
                                     const uint8_t* src_alpha_scan, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = NULL;
     uint8_t gray;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        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) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (src_alpha) {
                     if (pIccTransform) {
                         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
@@ skipping 70 matching lines @@
 inline void _CompositeRow_Rgb2Gray(uint8_t* dest_scan, const uint8_t* src_scan, int src_Bpp, int pixel_count,
                                    int blend_type, const uint8_t* clip_scan,
                                    void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = NULL;
     uint8_t gray;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        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 {
                 gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
             }
             if (bNonseparableBlend) {
                 blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
             }
@@ skipping 26 matching lines @@
 void _CompositeRow_Rgb2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int src_Bpp, int pixel_count,
                              int blend_type, const uint8_t* clip_scan,
                              uint8_t* dest_alpha_scan, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = NULL;
     if (pIccTransform) {
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
         int blended_color;
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         for (int col = 0; col < pixel_count; col ++) {
             int back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
                 if (pIccTransform) {
                     pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                 } else {
                     *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
                 }
                 dest_scan ++;
                 dest_alpha_scan++;
@@ skipping 63 matching lines @@
         }
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan ++;
         src_scan += src_Bpp;
     }
 }
 void _CompositeRow_Argb2Argb(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count, int blend_type, const uint8_t* clip_scan,
                              uint8_t* dest_alpha_scan, const uint8_t* src_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     if (dest_alpha_scan == NULL) {
         if (src_alpha_scan == NULL) {
             uint8_t back_alpha = 0;
             for (int col = 0; col < pixel_count; col ++) {
                 back_alpha = dest_scan[3];
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * src_scan[3] / 255;
                         FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) | (src_alpha << 24));
                     } else {
@@ skipping 186 matching lines @@
                 }
                 src_scan ++;
             }
         }
     }
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp,
         uint8_t* dest_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 if (src_Bpp == 4) {
                     FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
                 } else {
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
                 }
@@ skipping 40 matching lines @@
                 src_scan ++;
             }
             src_scan += src_gap;
         }
     }
 }
 inline void _CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp, const uint8_t* clip_scan,
         uint8_t* dest_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             int src_alpha = *clip_scan ++;
             uint8_t back_alpha = dest_scan[3];
             if (back_alpha == 0) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 src_scan += src_gap;
@@ skipping 143 matching lines @@
             *dest_scan++ = *src_scan++;
             *dest_alpha_scan++ = 0xff;
             src_scan += src_gap;
         }
     }
 }
 inline void _CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, const uint8_t* clip_scan,
         const uint8_t* src_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     if (src_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
             uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             if (src_alpha == 0) {
@@ skipping 101 matching lines @@
                 dest_scan ++;
                 src_scan ++;
             }
             dest_scan += dest_gap;
         }
     }
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         if (bNonseparableBlend) {
             _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
             int back_color = *dest_scan;
             int src_color = *src_scan;
             int blended = bNonseparableBlend ? blended_colors[color] :
                           _BLEND(blend_type, back_color, src_color);
             *dest_scan = blended;
             dest_scan ++;
             src_scan ++;
         }
         dest_scan += dest_gap;
         src_scan += src_gap;
     }
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_Clip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha = *clip_scan ++;
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += src_Bpp;
             continue;
         }
         if (bNonseparableBlend) {
@@ skipping 70 matching lines @@
     } else {
         if (dest_alpha_scan == NULL) {
             for (int col = 0; col < pixel_count; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
                 dp[3] = src_scan[3];
                 src_scan += 4;
                 dp += 4;
             }
         } else {
             int blended_colors[3];
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             for (int col = 0; col < pixel_count; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
                 uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     if (clip_scan) {
                         int src_alpha = clip_scan[col] * src_scan[3] / 255;
                         *dest_alpha_scan = src_alpha;
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
                         *dest_scan++ = *src_cache_scan++;
@@ skipping 109 matching lines @@
     _CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3, dest_alpha_scan);
 }
 inline void _CompositeRow_Argb2Rgb_Blend_Transform(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, const uint8_t* clip_scan,
         const uint8_t* src_alpha_scan, uint8_t* src_cache_scan, void* pIccTransform)
 {
     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;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int dest_gap = dest_Bpp - 3;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
             uint8_t src_alpha;
             if (clip_scan) {
                 src_alpha = src_scan[3] * (*clip_scan++) / 255;
             } else {
                 src_alpha = src_scan[3];
             }
             src_scan += 4;
@@ skipping 122 matching lines @@
         }
     }
     _CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp, 3, clip_scan);
 }
 inline void _CompositeRow_8bppPal2Gray(uint8_t* dest_scan, const uint8_t* src_scan, const uint8_t* pPalette, int pixel_count,
                                        int blend_type, const uint8_t* clip_scan,
                                        const uint8_t* src_alpha_scan)
 {
     if (src_alpha_scan) {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
                 int src_alpha = *src_alpha_scan++;
                 if (clip_scan) {
                     src_alpha = clip_scan[col] * src_alpha / 255;
                 }
                 if (bNonseparableBlend) {
                     blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
                 }
@@ skipping 17 matching lines @@
             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;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 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 {
@@ skipping 15 matching lines @@
             src_scan ++;
         }
     }
 }
 inline void _CompositeRow_8bppPal2Graya(uint8_t* dest_scan, const uint8_t* src_scan, const uint8_t* pPalette, int pixel_count,
                                         int blend_type, const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan, const uint8_t* src_alpha_scan)
 {
     if (src_alpha_scan) {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
                 src_scan ++;
                 uint8_t back_alpha = *dest_alpha_scan;
                 if (back_alpha == 0) {
                     int src_alpha = *src_alpha_scan ++;
                     if (clip_scan) {
                         src_alpha = clip_scan[col] * src_alpha / 255;
                     }
@@ skipping 53 matching lines @@
                 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;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
                 src_scan ++;
                 if (clip_scan == NULL || clip_scan[col] == 255) {
                     *dest_scan++ = gray;
                     *dest_alpha_scan++ = 255;
                     continue;
                 }
                 int src_alpha = clip_scan[col];
@@ skipping 37 matching lines @@
             dest_scan ++;
         }
     }
 }
 inline void _CompositeRow_1bppPal2Gray(uint8_t* dest_scan, const uint8_t* src_scan, int src_left,
                                        const uint8_t* pPalette, int pixel_count, int blend_type, const uint8_t* clip_scan)
 {
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
             if (bNonseparableBlend) {
                 blended_color = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
             }
             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 {
@@ skipping 13 matching lines @@
         dest_scan ++;
     }
 }
 inline void _CompositeRow_1bppPal2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int src_left,
                                         const uint8_t* pPalette, int pixel_count, int blend_type, const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan)
 {
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
             if (clip_scan == NULL || clip_scan[col] == 255) {
                 *dest_scan++ = gray;
                 *dest_alpha_scan ++ = 255;
                 continue;
             }
             int src_alpha = clip_scan[col];
             if (src_alpha == 0) {
@@ skipping 896 matching lines @@
         uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio);
         dest_scan ++;
     }
 }
 void _CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count, int blend_type, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col ++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (clip_scan) {
                 int src_alpha = clip_scan[col] * src_scan[3] / 255;
                 dest_scan[3] = src_alpha;
                 dest_scan[0] = src_scan[2];
                 dest_scan[1] = src_scan[1];
                 dest_scan[2] = src_scan[0];
             } else {
@@ skipping 36 matching lines @@
             }
             src_scan ++;
         }
         dest_scan += 4;
         src_scan++;
     }
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             if (src_Bpp == 4) {
                 FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
             } else {
                 FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
             }
             dest_scan += 4;
@@ skipping 16 matching lines @@
             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(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha;
         if (clip_scan) {
             src_alpha = src_scan[3] * (*clip_scan++) / 255;
         } else {
             src_alpha = src_scan[3];
         }
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += 4;
@@ skipping 26 matching lines @@
         } else {
             FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
         }
         dest_scan += 4;
         src_scan += src_Bpp;
     }
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         if (bNonseparableBlend) {
             uint8_t dest_scan_o[3];
             dest_scan_o[0] = dest_scan[2];
             dest_scan_o[1] = dest_scan[1];
             dest_scan_o[2] = dest_scan[0];
             _RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
         }
         for (int color = 0; color < 3; color ++) {
@@ skipping 46 matching lines @@
         dest_scan[2] = src_scan[0];
         dest_scan[1] = src_scan[1];
         dest_scan[0] = src_scan[2];
         dest_scan += dest_Bpp;
         src_scan += src_Bpp;
     }
 }
 inline void _CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         int src_alpha = *clip_scan ++;
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
             dest_scan[2] = FX_GAMMA(*src_scan++);
             dest_scan[1] = FX_GAMMA(*src_scan++);
             dest_scan[0] = FX_GAMMA(*src_scan++);
             src_scan += src_gap;
             dest_scan += 4;
@@ skipping 23 matching lines @@
             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(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha = *clip_scan ++;
         if (src_alpha == 0) {
             dest_scan += dest_Bpp;
             src_scan += src_Bpp;
             continue;
         }
         if (bNonseparableBlend) {
             uint8_t dest_scan_o[3];
@@ skipping 435 matching lines @@
             blended = _BLEND(blend_type, back_color, src_r);
             dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(back_color, blended, src_alpha));
         } else {
             dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), src_b, src_alpha));
             dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), src_g, src_alpha));
             dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), src_r, src_alpha));
         }
         dest_scan += Bpp;
     }
 }
-inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int alpha_flag, FX_DWORD mask_color, int& mask_alpha,
+inline bool _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int alpha_flag, FX_DWORD mask_color, int& mask_alpha,
         int& mask_red, int& mask_green, int& mask_blue, int& mask_black,
         void* icc_module, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
     if (alpha_flag >> 8) {
         mask_alpha = alpha_flag & 0xff;
         mask_red = FXSYS_GetCValue(mask_color);
         mask_green = FXSYS_GetMValue(mask_color);
         mask_blue = FXSYS_GetYValue(mask_color);
         mask_black = FXSYS_GetKValue(mask_color);
     } else {
         mask_alpha = FXARGB_A(mask_color);
         mask_red = FXARGB_R(mask_color);
         mask_green = FXARGB_G(mask_color);
         mask_blue = FXARGB_B(mask_color);
     }
     if (dest_format == FXDIB_8bppMask) {
-        return TRUE;
+        return true;
     }
     if ((dest_format & 0xff) == 8) {
         if (pIccTransform) {
             mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color);
             uint8_t* gray_p = (uint8_t*)&mask_color;
             pIccModule->TranslateScanline(pIccTransform, gray_p, gray_p, 1);
             mask_red = dest_format & 0x0400 ? FX_CCOLOR(gray_p[0]) : gray_p[0];
         } else {
             if (alpha_flag >> 8) {
                 uint8_t r, g, b;
@@ skipping 16 matching lines @@
             mask_green = mask_color_p[1];
             mask_blue = mask_color_p[0];
         } else if (alpha_flag >> 8) {
             AdobeCMYK_to_sRGB1(mask_color_p[0], mask_color_p[1], mask_color_p[2], mask_color_p[3],
                                mask_color_p[2], mask_color_p[1], mask_color_p[0]);
             mask_red = mask_color_p[2];
             mask_green = mask_color_p[1];
             mask_blue = mask_color_p[0];
         }
     }
-    return TRUE;
+    return true;
 }
 inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format, FXDIB_Format dest_format,
         FX_DWORD*& pDestPalette, FX_DWORD* pSrcPalette,
         void* icc_module, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
-    FX_BOOL isSrcCmyk = src_format & 0x0400 ? TRUE : FALSE;
-    FX_BOOL isDstCmyk = dest_format & 0x0400 ? TRUE : FALSE;
+    bool isSrcCmyk = src_format & 0x0400 ? true : false;
+    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);
                 uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
                 pDestPalette = (FX_DWORD*)gray_pal;
                 for (int i = 0; i < pal_count; i ++) {
                     FX_DWORD color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i]) : FXARGB_TODIB(pSrcPalette[i]);
                     pIccModule->TranslateScanline(pIccTransform, gray_pal, (const uint8_t*)&color, 1);
@@ skipping 100 matching lines @@
                 }
             }
         }
     }
 }
 CFX_ScanlineCompositor::CFX_ScanlineCompositor()
 {
     m_pSrcPalette = NULL;
     m_pCacheScanline = NULL;
     m_CacheSize = 0;
-    m_bRgbByteOrder = FALSE;
+    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, int32_t width, FX_DWORD* pSrcPalette,
-                                     FX_DWORD mask_color, int blend_type, FX_BOOL bClip, FX_BOOL bRgbByteOrder, int alpha_flag, void* pIccTransform)
+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, bool bClip, 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();
     }
     if (pIccModule == NULL) {
         pIccTransform = NULL;
     }
     m_pIccTransform = pIccTransform;
     if ((dest_format & 0xff) == 1) {
-        return FALSE;
+        return false;
     }
     if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
         return _ScanlineCompositor_InitSourceMask(dest_format, alpha_flag, mask_color,
                 m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, m_MaskBlack,
                 pIccModule, pIccTransform);
     }
     if (pIccTransform == NULL && (~src_format & 0x0400) && (dest_format & 0x0400)) {
-        return FALSE;
+        return false;
     }
     if ((m_SrcFormat & 0xff) <= 8) {
         if (dest_format == FXDIB_8bppMask) {
-            return TRUE;
+            return true;
         }
         _ScanlineCompositor_InitSourcePalette(src_format, dest_format, m_pSrcPalette, pSrcPalette,
                                               pIccModule, pIccTransform);
         m_Transparency = (dest_format == FXDIB_Argb ? 1 : 0)
                          + (dest_format & 0x0200 ? 2 : 0)
                          + (dest_format & 0x0400 ? 4 : 0)
                          + ((src_format & 0xff) == 1 ? 8 : 0);
-        return TRUE;
+        return true;
     }
     m_Transparency = (src_format & 0x0200 ? 0 : 1)
                      + (dest_format & 0x0200 ? 0 : 2)
                      + (blend_type == FXDIB_BLEND_NORMAL ? 4 : 0)
                      + (bClip ? 8 : 0)
                      + (src_format & 0x0400 ? 16 : 0)
                      + (dest_format & 0x0400 ? 32 : 0)
                      + (pIccTransform ? 64 : 0);
-    return TRUE;
+    return true;
 }
 void CFX_ScanlineCompositor::CompositeRgbBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int width, const uint8_t* clip_scan,
         const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
 {
     int src_Bpp = (m_SrcFormat & 0xff) >> 3;
     int dest_Bpp = (m_DestFormat & 0xff) >> 3;
     if (m_bRgbByteOrder) {
         switch (m_Transparency) {
             case 0:
             case 4:
@@ skipping 302 matching lines @@
             _CompositeRow_BitMask2Rgb_RgbByteOrder(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                                    src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
         return;
     } else if (m_DestFormat == FXDIB_Argb)
         _CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                    src_left, width, m_BlendType, clip_scan);
     else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32)
         _CompositeRow_BitMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                   src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
 }
-FX_BOOL CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top,
-                                      int blend_type, const CFX_ClipRgn* pClipRgn, FX_BOOL bRgbByteOrder, void* pIccTransform)
+                                      int blend_type, const CFX_ClipRgn* pClipRgn, bool bRgbByteOrder, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(!pSrcBitmap->IsAlphaMask());
     ASSERT(m_bpp >= 8);
     if (pSrcBitmap->IsAlphaMask() || m_bpp < 8) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
                    src_left, src_top, pClipRgn);
     if (width == 0 || height == 0) {
-        return TRUE;
+        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();
     }
     CFX_ScanlineCompositor compositor;
     if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width, pSrcBitmap->GetPalette(), 0, blend_type,
                          pClipMask != NULL, bRgbByteOrder, 0, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     int dest_Bpp = m_bpp / 8;
     int src_Bpp = pSrcBitmap->GetBPP() / 8;
-    FX_BOOL bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
+    bool bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
     CFX_DIBitmap* pSrcAlphaMask = pSrcBitmap->m_pAlphaMask;
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * src_Bpp;
         const uint8_t* src_scan_extra_alpha = pSrcAlphaMask ? pSrcAlphaMask->GetScanline(src_top + row) + src_left : NULL;
         uint8_t* dst_scan_extra_alpha = m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left : NULL;
         const uint8_t* clip_scan = NULL;
         if (pClipMask) {
             clip_scan = pClipMask->m_pBuffer + (dest_top + row - clip_box.top) * pClipMask->m_Pitch + (dest_left - clip_box.left);
         }
         if (bRgb) {
             compositor.CompositeRgbBitmapLine(dest_scan, src_scan, width, clip_scan, src_scan_extra_alpha, dst_scan_extra_alpha);
         } else {
             compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width, clip_scan, src_scan_extra_alpha, dst_scan_extra_alpha);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int height,
                                     const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top,
-                                    int blend_type, const CFX_ClipRgn* pClipRgn, FX_BOOL bRgbByteOrder, int alpha_flag, void* pIccTransform)
+                                    int blend_type, const CFX_ClipRgn* pClipRgn, bool bRgbByteOrder, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(pMask->IsAlphaMask());
     ASSERT(m_bpp >= 8);
     if (!pMask->IsAlphaMask() || m_bpp < 8) {
-        return FALSE;
+        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;
+        return true;
     }
     int src_alpha = (uint8_t)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
     if (src_alpha == 0) {
-        return TRUE;
+        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();
     }
     int src_bpp = pMask->GetBPP();
     int Bpp = GetBPP() / 8;
     CFX_ScanlineCompositor compositor;
     if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, NULL, color, blend_type, pClipMask != NULL, bRgbByteOrder, alpha_flag, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
         const uint8_t* src_scan = pMask->GetScanline(src_top + row);
         uint8_t* dst_scan_extra_alpha = m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left : NULL;
         const uint8_t* clip_scan = NULL;
         if (pClipMask) {
             clip_scan = pClipMask->m_pBuffer + (dest_top + row - clip_box.top) * pClipMask->m_Pitch + (dest_left - clip_box.left);
         }
         if (src_bpp == 1) {
             compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width, clip_scan, dst_scan_extra_alpha);
         } else {
             compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width, clip_scan, dst_scan_extra_alpha);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX_DWORD color, int alpha_flag, void* pIccTransform)
+bool CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     int src_alpha = (alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
     if (src_alpha == 0) {
-        return TRUE;
+        return true;
     }
     FX_RECT rect(left, top, left + width, top + height);
     rect.Intersect(0, 0, m_Width, m_Height);
     if (rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     width = rect.Width();
     FX_DWORD dst_color;
     if (alpha_flag >> 8) {
         dst_color = FXCMYK_TODIB(color);
     } else {
         dst_color = FXARGB_TODIB(color);
     }
     uint8_t* color_p = (uint8_t*)&dst_color;
     if (m_bpp == 8) {
@@ skipping 19 matching lines @@
         for (int row = rect.top; row < rect.bottom; row ++) {
             uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left;
             if (src_alpha == 255) {
                 FXSYS_memset(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;
+        return true;
     }
     if (m_bpp == 1) {
         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 = ((uint8_t)color == 0xff) ? 1 : 0;
         } else {
@@ skipping 17 matching lines @@
                     *dest_scan_top_r |= ~right_flag;
                 }
             } else {
                 if (!index) {
                     *dest_scan_top &= left_flag | right_flag;
                 } else {
                     *dest_scan_top |= ~(left_flag | right_flag);
                 }
             }
         }
-        return TRUE;
+        return true;
     }
     ASSERT(m_bpp >= 24);
     if (m_bpp < 24) {
-        return FALSE;
+        return false;
     }
     if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
     } else {
         if (alpha_flag >> 8 && !IsCmykImage())
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
-            return FALSE;
+            return false;
         }
     }
     if(!IsCmykImage()) {
         color_p[3] = (uint8_t)src_alpha;
     }
     int Bpp = m_bpp / 8;
-    FX_BOOL bAlpha = HasAlpha();
-    FX_BOOL bArgb = GetFormat() == FXDIB_Argb ? TRUE : FALSE;
+    bool bAlpha = HasAlpha();
+    bool bArgb = GetFormat() == FXDIB_Argb ? true : false;
     if (src_alpha == 255) {
         for (int row = rect.top; row < rect.bottom; row ++) {
             uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
             uint8_t* dest_scan_alpha = m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left : NULL;
             if (dest_scan_alpha) {
                 FXSYS_memset(dest_scan_alpha, 0xff, width);
             }
             if (Bpp == 4) {
                 FX_DWORD* scan = (FX_DWORD*)dest_scan;
                 for (int col = 0; col < width; col ++) {
                     *scan ++ = dst_color;
                 }
             } else {
                 for (int col = 0; col < width; col ++) {
                     *dest_scan ++ = color_p[0];
                     *dest_scan ++ = color_p[1];
                     *dest_scan ++ = color_p[2];
                 }
             }
         }
-        return TRUE;
+        return true;
     }
     for (int row = rect.top; row < rect.bottom; row ++) {
         uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
         if (bAlpha) {
             if (bArgb) {
                 for (int col = 0; col < width; col ++) {
                     uint8_t back_alpha = dest_scan[3];
                     if (back_alpha == 0) {
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, color_p[2], color_p[1], color_p[0]));
                         dest_scan += 4;
@@ skipping 34 matching lines @@
                     if (comps == 3) {
                         *dest_scan ++ = 255;
                         continue;
                     }
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], src_alpha);
                     dest_scan ++;
                 }
             }
         }
     }
-    return TRUE;
+    return true;
 }
 CFX_BitmapComposer::CFX_BitmapComposer()
 {
     m_pScanlineV = NULL;
     m_pScanlineAlphaV = NULL;
     m_pClipScanV = NULL;
     m_pAddClipScan = NULL;
-    m_bRgbByteOrder = FALSE;
+    m_bRgbByteOrder = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_BitmapComposer::~CFX_BitmapComposer()
 {
     if (m_pScanlineV) {
         FX_Free(m_pScanlineV);
     }
     if (m_pScanlineAlphaV) {
         FX_Free(m_pScanlineAlphaV);
     }
     if (m_pClipScanV) {
         FX_Free(m_pClipScanV);
     }
     if (m_pAddClipScan) {
         FX_Free(m_pAddClipScan);
     }
 }
 void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest, const CFX_ClipRgn* pClipRgn, int bitmap_alpha,
-                                 FX_DWORD mask_color, FX_RECT& dest_rect, FX_BOOL bVertical,
-                                 FX_BOOL bFlipX, FX_BOOL bFlipY, FX_BOOL bRgbByteOrder,
+                                 FX_DWORD mask_color, FX_RECT& dest_rect, bool bVertical,
+                                 bool bFlipX, bool bFlipY, bool bRgbByteOrder,
                                  int alpha_flag, void* pIccTransform, int blend_type)
 {
     m_pBitmap = pDest;
     m_pClipRgn = pClipRgn;
     m_DestLeft = dest_rect.left;
     m_DestTop = dest_rect.top;
     m_DestWidth = dest_rect.Width();
     m_DestHeight = dest_rect.Height();
     m_BitmapAlpha = bitmap_alpha;
     m_MaskColor = mask_color;
     m_pClipMask = NULL;
     if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
         m_pClipMask = pClipRgn->GetMask();
     }
     m_bVertical = bVertical;
     m_bFlipX = bFlipX;
     m_bFlipY = bFlipY;
     m_AlphaFlag = alpha_flag;
     m_pIccTransform = pIccTransform;
     m_bRgbByteOrder = bRgbByteOrder;
     m_BlendType = blend_type;
 }
-FX_BOOL CFX_BitmapComposer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
+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;
+        return false;
     }
     if (m_bVertical) {
         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(uint8_t, width + 4);
         }
     }
     if (m_BitmapAlpha < 255) {
         m_pAddClipScan = FX_Alloc(uint8_t, m_bVertical ? m_pBitmap->GetHeight() : m_pBitmap->GetWidth());
     }
-    return TRUE;
+    return true;
 }
 void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan, const uint8_t* src_scan, int dest_width, const uint8_t* clip_scan,
                                    const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
 {
     if (m_BitmapAlpha < 255) {
         if (clip_scan) {
             for (int i = 0; i < dest_width; i ++) {
                 m_pAddClipScan[i] = clip_scan[i] * m_BitmapAlpha / 255;
             }
         } else {
@@ skipping 87 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;
         }
     }
 }