FX_BOOL considered harmful.

core/src/fxge/dib/fx_dib_convert.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_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 const FX_DWORD g_dwWinPalette[256] = {
@@ skipping 85 matching lines @@
     0xff000088, 0xff000077, 0xff000055, 0xff000044, 0xff000022, 0xff000011,
     0xffEEEEEE, 0xffDDDDDD, 0xffBBBBBB, 0xffAAAAAA, 0xff888888, 0xff777777,
     0xff555555, 0xff444444, 0xff222222, 0xff111111, 0xff000000
 };
 class CFX_Palette
 {
 public:
     CFX_Palette();
     ~CFX_Palette();
 public:
-    FX_BOOL      BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
+    bool      BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
     FX_DWORD*    GetPalette() const
     {
         return m_pPalette;
     }
 
     FX_DWORD*    GetColorLut()const
     {
         return m_cLut;
     }
     FX_DWORD*    GetAmountLut()const
@@ skipping 103 matching lines @@
         FX_Free(m_pPalette);
     }
     if (m_cLut) {
         FX_Free(m_cLut);
     }
     if (m_aLut) {
         FX_Free(m_aLut);
     }
     m_lut = 0;
 }
-FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
+bool CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
 {
     if (pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pPalette != NULL) {
         FX_Free(m_pPalette);
     }
     m_pPalette = FX_Alloc(FX_DWORD, 256);
     int bpp    = pBitmap->GetBPP() / 8;
     int width  = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     if (m_cLut) {
         FX_Free(m_cLut);
@@ skipping 26 matching lines @@
         }
     }
     _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
     FX_DWORD* win_mac_pal = NULL;
     if (pal_type == FXDIB_PALETTE_WIN) {
         win_mac_pal = (FX_DWORD*)g_dwWinPalette;
     } else if (pal_type == FXDIB_PALETTE_MAC) {
         win_mac_pal = (FX_DWORD*)g_dwMacPalette;
     }
     _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     uint8_t set_gray, reset_gray;
     set_gray = 0xff;
     reset_gray = 0x00;
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         FXSYS_memset(dest_scan, reset_gray, width);
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = src_left; col < src_left + width; col ++) {
             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                 *dest_scan = set_gray;
             }
             dest_scan ++;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         FXSYS_memcpy(dest_scan, src_scan, width);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
     uint8_t gray[2];
     if (pIccTransform) {
         FX_DWORD plt[2];
         if (pSrcBitmap->IsCmykImage()) {
             plt[0] = FXCMYK_TODIB(src_plt[0]);
             plt[1] = FXCMYK_TODIB(src_plt[1]);
         } else {
@@ skipping 30 matching lines @@
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         FXSYS_memset(dest_scan, gray[0], width);
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = src_left; col < src_left + width; col ++) {
             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                 *dest_scan = gray[1];
             }
             dest_scan ++;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
     uint8_t gray[256];
     if (pIccTransform) {
         FX_DWORD plt[256];
         if (pSrcBitmap->IsCmykImage()) {
             for (int i = 0; i < 256; i ++) {
                 plt[i] = FXCMYK_TODIB(src_plt[i]);
             }
@@ skipping 20 matching lines @@
                 gray[i] = FXRGB2GRAY(FXARGB_R(src_plt[i]), FXARGB_G(src_plt[i]), FXARGB_B(src_plt[i]));
             }
     }
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         for (int col = 0; col < width; col ++) {
             *dest_scan++ = gray[*src_scan++];
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int Bpp = pSrcBitmap->GetBPP() / 8;
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         if (Bpp == 3 || pSrcBitmap->IsCmykImage()) {
             for (int row = 0; row < height; row ++) {
                 uint8_t* dest_scan = dest_buf + row * dest_pitch;
                 const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
@@ skipping 26 matching lines @@
             for (int row = 0; row < height; row ++) {
                 uint8_t* dest_scan = dest_buf + row * dest_pitch;
                 const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
                 for (int col = 0; col < width; col ++) {
                     *dest_scan++ = FXRGB2GRAY(src_scan[2], src_scan[1], src_scan[0]);
                     src_scan += Bpp;
                 }
             }
         }
     }
-    return TRUE;
+    return true;
 }
 inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     if (pSrcBitmap->GetBPP() == 1) {
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             FXSYS_memset(dest_scan, 0, width);
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
             for (int col = src_left; col < src_left + width; col ++) {
                 if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                     *dest_scan = 1;
                 }
                 dest_scan ++;
             }
         }
     } else {
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
             FXSYS_memcpy(dest_scan, src_scan, width);
         }
     }
 }
-FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 {
     _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
     int plt_size = pSrcBitmap->GetPaletteSize();
     if (pIccTransform) {
         FX_DWORD plt[256];
         uint8_t* bgr_ptr = (uint8_t*)plt;
         if (pSrcBitmap->IsCmykImage()) {
             for (int i = 0; i < plt_size; i ++) {
@@ skipping 18 matching lines @@
             for (int i = 0; i < plt_size; i ++) {
                 uint8_t r, g, b;
                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
                                    r, g, b);
                 dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
             }
         } else {
             FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
         }
     }
-    return TRUE;
+    return true;
 }
-inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int dest_pitch, int width, int height,
+inline bool _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int dest_pitch, int width, int height,
         const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt)
 {
     int bpp = pSrcBitmap->GetBPP() / 8;
     int row, col;
     CFX_Palette palette;
     palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
     FX_DWORD* cLut = palette.GetColorLut();
     FX_DWORD* aLut = palette.GetAmountLut();
     if (cLut == NULL || aLut == NULL) {
-        return FALSE;
+        return false;
     }
     int lut = palette.Getlut();
     FX_DWORD* pPalette = palette.GetPalette();
     if (lut > 256) {
         int err, min_err;
         int lut_256 = lut - 256;
         for (row = 0; row < lut_256; row++) {
             min_err = 1000000;
             uint8_t r, g, b;
             _ColorDecode(cLut[row], r, g, b);
@@ skipping 23 matching lines @@
             int b = src_port[0] & 0xf0;
             FX_DWORD clrindex = (r << 4) + g + (b >> 4);
             for (int i = lut_1; i >= 0; i--)
                 if (clrindex == cLut[i]) {
                     *(dest_scan + col) = (uint8_t)(aLut[i]);
                     break;
                 }
         }
     }
     FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 {
-    FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, dst_plt);
+    bool ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, dst_plt);
     if (ret && pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int i = 0; i < 256; i++) {
             FX_ARGB* plt = dst_plt + i;
             FX_ARGB plt_entry = FXARGB_TODIB(*plt);
             pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&plt_entry, (const uint8_t*)&plt_entry, 1);
             *plt = FXARGB_TODIB(plt_entry);
         }
     }
     return ret;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
     uint8_t set_gray, reset_gray;
     set_gray = 0xff;
     reset_gray = 0x00;
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = src_left; col < src_left + width; col ++) {
             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                 dest_scan[0] = set_gray;
                 dest_scan[1] = set_gray;
                 dest_scan[2] = set_gray;
             } else {
                 dest_scan[0] = reset_gray;
                 dest_scan[1] = reset_gray;
                 dest_scan[2] = reset_gray;
             }
             dest_scan += comps;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         uint8_t src_pixel;
         for (int col = 0; col < width; col ++) {
             src_pixel = *src_scan++;
             *dest_scan++ = src_pixel;
             *dest_scan++ = src_pixel;
             *dest_scan   = src_pixel;
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = (dst_format & 0xff) / 8;
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
     FX_DWORD plt[2];
     uint8_t* bgr_ptr = (uint8_t*)plt;
     if (pSrcBitmap->IsCmykImage()) {
         plt[0] = FXCMYK_TODIB(src_plt[0]);
         plt[1] = FXCMYK_TODIB(src_plt[1]);
     } else {
@@ skipping 24 matching lines @@
                 *dest_scan++ = bgr_ptr[4];
                 *dest_scan   = bgr_ptr[5];
             } else {
                 *dest_scan++ = bgr_ptr[0];
                 *dest_scan++ = bgr_ptr[1];
                 *dest_scan   = bgr_ptr[2];
             }
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = (dst_format & 0xff) / 8;
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
     FX_DWORD plt[256];
     uint8_t* bgr_ptr = (uint8_t*)plt;
     if (!pSrcBitmap->IsCmykImage()) {
         for (int i = 0; i < 256; i++) {
             *bgr_ptr++ = FXARGB_B(src_plt[i]);
             *bgr_ptr++ = FXARGB_G(src_plt[i]);
@@ skipping 23 matching lines @@
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         for (int col = 0; col < width; col ++) {
             uint8_t* src_pixel = bgr_ptr + 3 * (*src_scan++);
             *dest_scan++ = *src_pixel++;
             *dest_scan++ = *src_pixel++;
             *dest_scan   = *src_pixel++;
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
         }
     } else {
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
             FXSYS_memcpy(dest_scan, src_scan, width * 3);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
         for (int col = 0; col < width; col ++) {
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             src_scan++;
         }
     }
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                  const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = pSrcBitmap->GetBPP() / 8;
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
             for (int col = 0; col < width; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                 dest_scan += 4;
                 src_scan += comps;
             }
         }
     } else {
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
             for (int col = 0; col < width; col ++) {
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 *dest_scan++ = *src_scan++;
                 dest_scan++;
                 src_scan += comps - 3;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                        const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
             for (int col = 0; col < width; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
                 dest_scan += 4;
                 src_scan += 4;
             }
         }
     } else {
         for (int row = 0; row < height; row ++) {
             uint8_t* dest_scan = dest_buf + row * dest_pitch;
             const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
             for (int col = 0; col < width; col ++) {
                 AdobeCMYK_to_sRGB1(src_scan[0], src_scan[1], src_scan[2], src_scan[3],
                                    dest_scan[2], dest_scan[1], dest_scan[0]);
                 dest_scan += 4;
                 src_scan += 4;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& d_pal, void* pIccTransform)
 {
     FXDIB_Format src_format = pSrcBitmap->GetFormat();
     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         pIccTransform = NULL;
     }
     switch (dest_format) {
         case FXDIB_Invalid:
         case FXDIB_1bppCmyk:
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
-            ASSERT(FALSE);
-            return FALSE;
+            ASSERT(false);
+            return false;
         case FXDIB_8bppMask: {
                 if ((src_format & 0xff) == 1) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) == 8) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) >= 24) {
                     return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_8bppRgb:
         case FXDIB_8bppRgba: {
                 if ((src_format & 0xff) == 8 && pSrcBitmap->GetPalette() == NULL) {
                     return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
                 }
                 d_pal = FX_Alloc(FX_DWORD, 256);
                 if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) && pSrcBitmap->GetPalette()) {
                     return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
                 } else if ((src_format & 0xff) >= 24) {
                     return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_Rgb:
         case FXDIB_Rgba: {
                 if ((src_format & 0xff) == 1) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) == 8) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) == 24) {
                     return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 } else if ((src_format & 0xff) == 32) {
                     return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_Argb:
         case FXDIB_Rgb32: {
                 if ((src_format & 0xff) == 1) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) == 8) {
                     if (pSrcBitmap->GetPalette()) {
                         return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
                 } else if ((src_format & 0xff) >= 24) {
                     if (src_format & 0x0400) {
                         return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                     }
                     return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         default:
-            return FALSE;
+            return false;
     }
-    return FALSE;
+    return false;
 }
 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format, const FX_RECT* pClip, void* pIccTransform) const
 {
     if(dest_format == GetFormat() && pIccTransform == NULL) {
         return Clone(pClip);
     }
     if (pClip) {
         CFX_DIBitmap* pClone = Clone(pClip);
         if (pClone == NULL) {
             return NULL;
         }
         if(!pClone->ConvertFormat(dest_format, pIccTransform)) {
             delete pClone;
             return NULL;
         }
         return pClone;
     }
     CFX_DIBitmap* pClone = new CFX_DIBitmap;
     if(!pClone->Create(m_Width, m_Height, dest_format)) {
         delete pClone;
         return NULL;
     }
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     CFX_DIBitmap* pSrcAlpha = NULL;
     if (m_AlphaFlag & 2) {
         pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
         if (pSrcAlpha == NULL) {
             delete pClone;
             return NULL;
         }
     }
     if (dest_format & 0x0200) {
         if (dest_format == FXDIB_Argb)
@@ skipping 21 matching lines @@
         delete pClone;
         return NULL;
     }
     if (pal_8bpp) {
         pClone->CopyPalette(pal_8bpp);
         FX_Free(pal_8bpp);
         pal_8bpp = NULL;
     }
     return pClone;
 }
-FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransform)
+bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransform)
 {
     FXDIB_Format src_format = GetFormat();
     if (dest_format == src_format && pIccTransform == NULL) {
-        return TRUE;
+        return true;
     }
     if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb && m_pPalette == NULL) {
         m_AlphaFlag = 1;
-        return TRUE;
+        return true;
     }
     if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32 && pIccTransform == NULL) {
         m_AlphaFlag = 2;
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* scanline = m_pBuffer + row * m_Pitch + 3;
             for (int col = 0; col < m_Width; col ++) {
                 *scanline = 0xff;
                 scanline += 4;
             }
         }
-        return TRUE;
+        return true;
     }
     int dest_bpp = dest_format & 0xff;
     int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
     uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
     if (dest_buf == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_DIBitmap* pAlphaMask = NULL;
     if (dest_format == FXDIB_Argb) {
         FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
         if (m_pAlphaMask) {
             for (int row = 0; row < m_Height; row ++) {
                 uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
                 const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
                 for (int col = 0; col < m_Width; col ++) {
                     *pDstScanline = *pSrcScanline++;
                     pDstScanline += 4;
                 }
             }
         }
     } else if (dest_format & 0x0200) {
         if (src_format == FXDIB_Argb) {
             pAlphaMask = GetAlphaMask();
             if (pAlphaMask == NULL) {
                 FX_Free(dest_buf);
-                return FALSE;
+                return false;
             }
         } else {
             if (m_pAlphaMask == NULL) {
                 if (!BuildAlphaMask()) {
                     FX_Free(dest_buf);
-                    return FALSE;
+                    return false;
                 }
                 pAlphaMask = m_pAlphaMask;
                 m_pAlphaMask = NULL;
             } else {
                 pAlphaMask = m_pAlphaMask;
             }
         }
     }
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD* pal_8bpp = NULL;
     ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
     if (!ret) {
         if (pal_8bpp) {
             FX_Free(pal_8bpp);
         }
         if (pAlphaMask != m_pAlphaMask) {
             delete pAlphaMask;
         }
         if (dest_buf) {
             FX_Free(dest_buf);
         }
-        return FALSE;
+        return false;
     }
     if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
         delete m_pAlphaMask;
     }
     m_pAlphaMask = pAlphaMask;
     if (m_pPalette) {
         FX_Free(m_pPalette);
     }
     m_pPalette = pal_8bpp;
     if (!m_bExtBuf) {
         FX_Free(m_pBuffer);
     }
-    m_bExtBuf = FALSE;
+    m_bExtBuf = false;
     m_pBuffer = dest_buf;
     m_bpp = (uint8_t)dest_format;
     m_AlphaFlag = (uint8_t)(dest_format >> 8);
     m_Pitch = dest_pitch;
-    return TRUE;
+    return true;
 }