Remove FX_BOOL from core

core/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 "core/fxcodec/fx_codec.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/ge/cfx_cliprgn.h"
@@ skipping 289 matching lines @@
                              int blend_type,
                              const uint8_t* clip_scan,
                              const uint8_t* src_alpha_scan,
                              uint8_t* dst_alpha_scan,
                              void* pIccTransform) {
   CCodec_IccModule* pIccModule = nullptr;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     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) {
             if (pIccTransform) {
@@ skipping 183 matching lines @@
                             int blend_type,
                             const uint8_t* clip_scan,
                             const uint8_t* src_alpha_scan,
                             void* pIccTransform) {
   CCodec_IccModule* pIccModule = nullptr;
   uint8_t gray;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     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);
           else
@@ skipping 75 matching lines @@
                            int pixel_count,
                            int blend_type,
                            const uint8_t* clip_scan,
                            void* pIccTransform) {
   CCodec_IccModule* pIccModule = nullptr;
   uint8_t gray;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     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)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
         gray = Blend(blend_type, *dest_scan, gray);
@@ skipping 29 matching lines @@
                             int pixel_count,
                             int blend_type,
                             const uint8_t* clip_scan,
                             uint8_t* dest_alpha_scan,
                             void* pIccTransform) {
   CCodec_IccModule* pIccModule = nullptr;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
-    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 69 matching lines @@
 }
 
 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) {
     if (!src_alpha_scan) {
       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));
@@ skipping 202 matching lines @@
   }
 }
 
 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) {
     for (int col = 0; col < width; col++) {
       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;
@@ skipping 48 matching lines @@
 }
 
 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) {
     for (int col = 0; col < width; col++) {
       int src_alpha = *clip_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;
@@ skipping 162 matching lines @@
 }
 
 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) {
     for (int col = 0; col < width; col++) {
       uint8_t src_alpha;
       if (clip_scan) {
         src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
       } else {
         src_alpha = *src_alpha_scan++;
       }
       if (src_alpha == 0) {
@@ skipping 112 matching lines @@
   }
 }
 
 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;
   }
 }
 
 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 81 matching lines @@
         pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
         dp[3] = *src_alpha_scan++;
         src_scan += 3;
         dp += 4;
       }
       src_alpha_scan = nullptr;
     }
   } else {
     if (dest_alpha_scan) {
       int blended_colors[3];
-      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++;
@@ skipping 165 matching lines @@
                                            const uint8_t* src_alpha_scan,
                                            uint8_t* src_cache_scan,
                                            void* pIccTransform) {
   CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_alpha_scan) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     int blended_colors[3];
-    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 173 matching lines @@
 
 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;
       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)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
           gray = Blend(blend_type, *dest_scan, gray);
@@ skipping 16 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;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
         if (bNonseparableBlend)
           gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         else
           gray = Blend(blend_type, *dest_scan, gray);
         if (clip_scan && clip_scan[col] < 255) {
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
         } else {
           *dest_scan = gray;
@@ skipping 19 matching lines @@
 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;
       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;
           }
           if (src_alpha) {
@@ 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;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
         src_scan++;
         if (!clip_scan || clip_scan[col] == 255) {
           *dest_scan++ = gray;
           *dest_alpha_scan++ = 255;
           continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
@@ skipping 43 matching lines @@
 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;
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray =
           (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
               ? set_gray
               : reset_gray;
       if (bNonseparableBlend)
         gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
       else
         gray = Blend(blend_type, *dest_scan, gray);
       if (clip_scan && clip_scan[col] < 255) {
@@ skipping 23 matching lines @@
                                 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;
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray =
           (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
               ? set_gray
               : reset_gray;
       if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = gray;
         *dest_alpha_scan++ = 255;
         continue;
       }
@@ skipping 842 matching lines @@
     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 43 matching lines @@
     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]));
       }
@@ skipping 23 matching lines @@
   }
 }
 
 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 36 matching lines @@
   }
 }
 
 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 61 matching lines @@
   }
 }
 
 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] = *src_scan++;
       dest_scan[1] = *src_scan++;
       dest_scan[0] = *src_scan++;
       src_scan += src_gap;
       dest_scan += 4;
@@ skipping 31 matching lines @@
 }
 
 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 493 matching lines @@
       dest_scan[0] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
     } else {
       dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha);
       dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha);
       dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha);
     }
     dest_scan += Bpp;
   }
 }
 
-FX_BOOL ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
-                                          int alpha_flag,
-                                          uint32_t mask_color,
-                                          int& mask_alpha,
-                                          int& mask_red,
-                                          int& mask_green,
-                                          int& mask_blue,
-                                          int& mask_black,
-                                          CCodec_IccModule* pIccModule,
-                                          void* pIccTransform) {
+bool ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
+                                       int alpha_flag,
+                                       uint32_t mask_color,
+                                       int& mask_alpha,
+                                       int& mask_red,
+                                       int& mask_green,
+                                       int& mask_blue,
+                                       int& mask_black,
+                                       CCodec_IccModule* pIccModule,
+                                       void* pIccTransform) {
   if (alpha_flag >> 8) {
     mask_alpha = alpha_flag & 0xff;
     mask_red = FXSYS_GetCValue(mask_color);
     mask_green = FXSYS_GetMValue(mask_color);
     mask_blue = FXSYS_GetYValue(mask_color);
     mask_black = FXSYS_GetKValue(mask_color);
   } else {
     mask_alpha = FXARGB_A(mask_color);
     mask_red = FXARGB_R(mask_color);
     mask_green = FXARGB_G(mask_color);
     mask_blue = FXARGB_B(mask_color);
   }
   if (dest_format == FXDIB_8bppMask) {
-    return TRUE;
+    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) {
@@ skipping 20 matching lines @@
       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;
 }
 
 void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
                                           FXDIB_Format dest_format,
                                           uint32_t*& pDestPalette,
                                           uint32_t* pSrcPalette,
                                           CCodec_IccModule* pIccModule,
                                           void* pIccTransform) {
-  FX_BOOL isSrcCmyk = !!(src_format & 0x0400);
-  FX_BOOL isDstCmyk = !!(dest_format & 0x0400);
+  bool isSrcCmyk = !!(src_format & 0x0400);
+  bool isDstCmyk = !!(dest_format & 0x0400);
   pDestPalette = nullptr;
   if (pIccTransform) {
     if (pSrcPalette) {
       if ((dest_format & 0xff) == 8) {
         int pal_count = 1 << (src_format & 0xff);
         uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
         pDestPalette = (uint32_t*)gray_pal;
         for (int i = 0; i < pal_count; i++) {
           uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
                                      : FXARGB_TODIB(pSrcPalette[i]);
@@ skipping 115 matching lines @@
     }
   }
 }
 
 }  // namespace
 
 CFX_ScanlineCompositor::CFX_ScanlineCompositor() {
   m_pSrcPalette = nullptr;
   m_pCacheScanline = nullptr;
   m_CacheSize = 0;
-  m_bRgbByteOrder = FALSE;
+  m_bRgbByteOrder = false;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 
 CFX_ScanlineCompositor::~CFX_ScanlineCompositor() {
   FX_Free(m_pSrcPalette);
   FX_Free(m_pCacheScanline);
 }
 
-FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format,
-                                     FXDIB_Format src_format,
-                                     int32_t width,
-                                     uint32_t* pSrcPalette,
-                                     uint32_t 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,
+                                  uint32_t* pSrcPalette,
+                                  uint32_t mask_color,
+                                  int blend_type,
+                                  bool bClip,
+                                  bool bRgbByteOrder,
+                                  int alpha_flag,
+                                  void* pIccTransform) {
   m_SrcFormat = src_format;
   m_DestFormat = dest_format;
   m_BlendType = blend_type;
   m_bRgbByteOrder = bRgbByteOrder;
   CCodec_IccModule* pIccModule = nullptr;
   if (CFX_GEModule::Get()->GetCodecModule()) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (!pIccModule) {
     pIccTransform = nullptr;
   }
   m_pIccTransform = pIccTransform;
   if ((dest_format & 0xff) == 1) {
-    return FALSE;
+    return false;
   }
   if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
     return ScanlineCompositor_InitSourceMask(
         dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed,
         m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform);
   }
   if (!pIccTransform && (~src_format & 0x0400) && (dest_format & 0x0400)) {
-    return FALSE;
+    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;
@@ skipping 389 matching lines @@
     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,
-                                      const CFX_DIBSource* pSrcBitmap,
-                                      int src_left,
-                                      int src_top,
-                                      int blend_type,
-                                      const CFX_ClipRgn* pClipRgn,
-                                      FX_BOOL bRgbByteOrder,
-                                      void* pIccTransform) {
+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,
+                                   bool bRgbByteOrder,
+                                   void* pIccTransform) {
   if (!m_pBuffer) {
-    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 = nullptr;
   FX_RECT clip_box;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
     pClipMask = pClipRgn->GetMask().GetObject();
     clip_box = pClipRgn->GetBox();
   }
   CFX_ScanlineCompositor compositor;
   if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width,
                        pSrcBitmap->GetPalette(), 0, blend_type,
                        pClipMask != nullptr, 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
                       : nullptr;
     uint8_t* dst_scan_extra_alpha =
         m_pAlphaMask
             ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
             : nullptr;
     const uint8_t* clip_scan = nullptr;
     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,
-                                    const CFX_DIBSource* pMask,
-                                    uint32_t color,
-                                    int src_left,
-                                    int src_top,
-                                    int blend_type,
-                                    const CFX_ClipRgn* pClipRgn,
-                                    FX_BOOL bRgbByteOrder,
-                                    int alpha_flag,
-                                    void* pIccTransform) {
+bool CFX_DIBitmap::CompositeMask(int dest_left,
+                                 int dest_top,
+                                 int width,
+                                 int height,
+                                 const CFX_DIBSource* pMask,
+                                 uint32_t color,
+                                 int src_left,
+                                 int src_top,
+                                 int blend_type,
+                                 const CFX_ClipRgn* pClipRgn,
+                                 bool bRgbByteOrder,
+                                 int alpha_flag,
+                                 void* pIccTransform) {
   if (!m_pBuffer) {
-    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 = nullptr;
   FX_RECT clip_box;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
     pClipMask = pClipRgn->GetMask().GetObject();
     clip_box = pClipRgn->GetBox();
   }
   int src_bpp = pMask->GetBPP();
   int Bpp = GetBPP() / 8;
   CFX_ScanlineCompositor compositor;
   if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, nullptr, color,
                        blend_type, pClipMask != nullptr, 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
             : nullptr;
     const uint8_t* clip_scan = nullptr;
     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,
-                                    uint32_t color,
-                                    int alpha_flag,
-                                    void* pIccTransform) {
+bool CFX_DIBitmap::CompositeRect(int left,
+                                 int top,
+                                 int width,
+                                 int height,
+                                 uint32_t color,
+                                 int alpha_flag,
+                                 void* pIccTransform) {
   if (!m_pBuffer) {
-    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();
   uint32_t 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 22 matching lines @@
       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 new_width = rect.right / 8 - rect.left / 8;
     int index = 0;
     if (m_pPalette) {
       for (int i = 0; i < 2; i++) {
         if (m_pPalette.get()[i] == color) {
@@ skipping 18 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()) {
     CCodec_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();
+  bool bAlpha = HasAlpha();
   bool bArgb = GetFormat() == FXDIB_Argb;
   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
                        : nullptr;
       if (dest_scan_alpha) {
         FXSYS_memset(dest_scan_alpha, 0xff, width);
       }
       if (Bpp == 4) {
         uint32_t* scan = (uint32_t*)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]));
@@ skipping 39 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 = nullptr;
   m_pScanlineAlphaV = nullptr;
   m_pClipScanV = nullptr;
   m_pAddClipScan = nullptr;
-  m_bRgbByteOrder = FALSE;
+  m_bRgbByteOrder = false;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 
 CFX_BitmapComposer::~CFX_BitmapComposer() {
   FX_Free(m_pScanlineV);
   FX_Free(m_pScanlineAlphaV);
   FX_Free(m_pClipScanV);
   FX_Free(m_pAddClipScan);
 }
 
 void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest,
                                  const CFX_ClipRgn* pClipRgn,
                                  int bitmap_alpha,
                                  uint32_t mask_color,
                                  FX_RECT& dest_rect,
-                                 FX_BOOL bVertical,
-                                 FX_BOOL bFlipX,
-                                 FX_BOOL bFlipY,
-                                 FX_BOOL bRgbByteOrder,
+                                 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 = nullptr;
   if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
     m_pClipMask = pClipRgn->GetMask().GetObject();
   }
   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,
-                                    uint32_t* pSrcPalette) {
+bool CFX_BitmapComposer::SetInfo(int width,
+                                 int height,
+                                 FXDIB_Format src_format,
+                                 uint32_t* pSrcPalette) {
   m_SrcFormat = src_format;
   if (!m_Compositor.Init(m_pBitmap->GetFormat(), src_format, width, pSrcPalette,
                          m_MaskColor, FXDIB_BLEND_NORMAL,
                          m_pClipMask != nullptr || (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) {
@@ skipping 113 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;
     }
   }
 }