FX Bool considered harmful, part 3

core/src/fpdfapi/fpdf_page/fpdf_page_colors.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/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "pageint.h"
@@ skipping 22 matching lines @@
         return 1;
     return 4;
 }
 
 }  // namespace
 
 CPDF_DeviceCS::CPDF_DeviceCS(CPDF_Document* pDoc, int family)
         : CPDF_ColorSpace(pDoc, family, ComponentsForFamily(family)) {
 }
 
-FX_BOOL CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         R = pBuf[0];
         if (R < 0) {
             R = 0;
         } else if (R > 1) {
             R = 1;
         }
         G = pBuf[1];
         if (G < 0) {
@@ skipping 20 matching lines @@
             AdobeCMYK_to_sRGB(pBuf[0], pBuf[1], pBuf[2], pBuf[3], R, G, B);
         } else {
             FX_FLOAT k = pBuf[3];
             R = 1.0f - FX_MIN(1.0f, pBuf[0] + k);
             G = 1.0f - FX_MIN(1.0f, pBuf[1] + k);
             B = 1.0f - FX_MIN(1.0f, pBuf[2] + k);
         }
     } else {
         ASSERT(m_Family == PDFCS_PATTERN);
         R = G = B = 0;
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_DeviceCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (m_Family != PDFCS_DEVICECMYK) {
-        return FALSE;
+        return false;
     }
     c = pBuf[0];
     m = pBuf[1];
     y = pBuf[2];
     k = pBuf[3];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_DeviceCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         pBuf[0] = R;
         pBuf[1] = G;
         pBuf[2] = B;
-        return TRUE;
+        return true;
     }
     if (m_Family == PDFCS_DEVICEGRAY) {
         if (R == G && R == B) {
             *pBuf = R;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (m_Family == PDFCS_DEVICECMYK) {
         sRGB_to_AdobeCMYK(R, G, B, pBuf[0], pBuf[1], pBuf[2], pBuf[3]);
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DeviceCS::v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
+bool CPDF_DeviceCS::v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         AdobeCMYK_to_sRGB(c, m, y, k, pBuf[0], pBuf[1], pBuf[2]);
-        return TRUE;
+        return true;
     }
     if (m_Family == PDFCS_DEVICECMYK) {
         pBuf[0] = c;
         pBuf[1] = m;
         pBuf[2] = y;
         pBuf[3] = k;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 static void ReverseRGB(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels)
 {
     if (pDestBuf == pSrcBuf)
         for (int i = 0; i < pixels; i ++) {
             uint8_t temp = pDestBuf[2];
             pDestBuf[2] = pDestBuf[0];
             pDestBuf[0] = temp;
             pDestBuf += 3;
         }
     else
         for (int i = 0; i < pixels; i ++) {
             *pDestBuf ++ = pSrcBuf[2];
             *pDestBuf ++ = pSrcBuf[1];
             *pDestBuf ++ = pSrcBuf[0];
             pSrcBuf += 3;
         }
 }
-void CPDF_DeviceCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_DeviceCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (bTransMask && m_Family == PDFCS_DEVICECMYK) {
         for (int i = 0; i < pixels; i ++) {
             int k = 255 - pSrcBuf[3];
             pDestBuf[0] = ((255 - pSrcBuf[0]) * k) / 255;
             pDestBuf[1] = ((255 - pSrcBuf[1]) * k) / 255;
             pDestBuf[2] = ((255 - pSrcBuf[2]) * k) / 255;
             pDestBuf += 3;
             pSrcBuf += 4;
         }
@@ skipping 104 matching lines @@
     R = RGB_Conversion(RGB.a);
     G = RGB_Conversion(RGB.b);
     B = RGB_Conversion(RGB.c);
 }
 class CPDF_CalGray : public CPDF_ColorSpace
 {
 public:
     explicit CPDF_CalGray(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_CALGRAY, 1) {
     }
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL     SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool        SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
 private:
     FX_FLOAT m_WhitePoint[3];
     FX_FLOAT m_BlackPoint[3];
     FX_FLOAT m_Gamma;
 };
 
-FX_BOOL CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
     int i;
     for (i = 0; i < 3; i ++) {
         m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
     for (i = 0; i < 3; i ++) {
         m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     m_Gamma = pDict->GetNumber(FX_BSTRC("Gamma"));
     if (m_Gamma == 0) {
         m_Gamma = 1.0f;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalGray::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_CalGray::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     R = G = B = *pBuf;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalGray::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_CalGray::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     if (R == G && R == B) {
         *pBuf = R;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-void CPDF_CalGray::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_CalGray::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     for (int i = 0; i < pixels; i ++) {
         *pDestBuf ++ = pSrcBuf[i];
         *pDestBuf ++ = pSrcBuf[i];
         *pDestBuf ++ = pSrcBuf[i];
     }
 }
 class CPDF_CalRGB : public CPDF_ColorSpace
 {
 public:
     explicit CPDF_CalRGB(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_CALRGB, 3) {
     }
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
     FX_FLOAT m_WhitePoint[3];
     FX_FLOAT m_BlackPoint[3];
     FX_FLOAT m_Gamma[3];
     FX_FLOAT m_Matrix[9];
-    FX_BOOL m_bGamma;
-    FX_BOOL m_bMatrix;
+    bool m_bGamma;
+    bool m_bMatrix;
 };
-FX_BOOL CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     if (!pDict)
-        return FALSE;
+        return false;
 
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
     int i;
     for (i = 0; i < 3; i ++) {
         m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
     for (i = 0; i < 3; i ++) {
         m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     pParam = pDict->GetArray(FX_BSTRC("Gamma"));
     if (pParam) {
-        m_bGamma = TRUE;
+        m_bGamma = true;
         for (i = 0; i < 3; i ++) {
             m_Gamma[i] = pParam->GetNumber(i);
         }
     } else {
-        m_bGamma = FALSE;
+        m_bGamma = false;
     }
     pParam = pDict->GetArray(FX_BSTRC("Matrix"));
     if (pParam) {
-        m_bMatrix = TRUE;
+        m_bMatrix = true;
         for (i = 0; i < 9; i ++) {
             m_Matrix[i] = pParam->GetNumber(i);
         }
     } else {
-        m_bMatrix = FALSE;
+        m_bMatrix = false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     FX_FLOAT A_ = pBuf[0];
     FX_FLOAT B_ = pBuf[1];
     FX_FLOAT C_ = pBuf[2];
     if (m_bGamma) {
         A_ = (FX_FLOAT)FXSYS_pow(A_, m_Gamma[0]);
         B_ = (FX_FLOAT)FXSYS_pow(B_, m_Gamma[1]);
         C_ = (FX_FLOAT)FXSYS_pow(C_, m_Gamma[2]);
     }
     FX_FLOAT X, Y, Z;
     if (m_bMatrix) {
         X = m_Matrix[0] * A_ + m_Matrix[3] * B_ + m_Matrix[6] * C_;
         Y = m_Matrix[1] * A_ + m_Matrix[4] * B_ + m_Matrix[7] * C_;
         Z = m_Matrix[2] * A_ + m_Matrix[5] * B_ + m_Matrix[8] * C_;
     } else {
         X = A_;
         Y = B_;
         Z = C_;
     }
     XYZ_to_sRGB_WhitePoint(X, Y, Z, R, G, B, m_WhitePoint[0], m_WhitePoint[1], m_WhitePoint[2]);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalRGB::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_CalRGB::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     pBuf[0] = R;
     pBuf[1] = G;
     pBuf[2] = B;
-    return TRUE;
+    return true;
 }
-void CPDF_CalRGB::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_CalRGB::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (bTransMask) {
         FX_FLOAT Cal[3];
         FX_FLOAT R, G, B;
         for(int i = 0; i < pixels; i ++) {
             Cal[0] = ((FX_FLOAT)pSrcBuf[2]) / 255;
             Cal[1] = ((FX_FLOAT)pSrcBuf[1]) / 255;
             Cal[2] = ((FX_FLOAT)pSrcBuf[0]) / 255;
             GetRGB(Cal, R, G, B);
             pDestBuf[0] = FXSYS_round(B * 255);
             pDestBuf[1] = FXSYS_round(G * 255);
             pDestBuf[2] = FXSYS_round(R * 255);
             pSrcBuf += 3;
             pDestBuf += 3;
         }
     }
     ReverseRGB(pDestBuf, pSrcBuf, pixels);
 }
 class CPDF_LabCS : public CPDF_ColorSpace
 {
 public:
     explicit CPDF_LabCS(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_LAB, 3) {
     }
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL     GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL     SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool        GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool        SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const;
+                            int image_height, bool bTransMask = false) const;
 
     FX_FLOAT m_WhitePoint[3];
     FX_FLOAT m_BlackPoint[3];
     FX_FLOAT m_Ranges[4];
 };
-FX_BOOL CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     if (!pDict) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
     int i;
     for (i = 0; i < 3; i ++) {
         m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
     for (i = 0; i < 3; i ++) {
         m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
     }
     pParam = pDict->GetArray(FX_BSTRC("Range"));
     const FX_FLOAT def_ranges[4] = { -100 * 1.0f, 100 * 1.0f, -100 * 1.0f, 100 * 1.0f};
     for (i = 0; i < 4; i ++) {
         m_Ranges[i] = pParam ? pParam->GetNumber(i) : def_ranges[i];
     }
-    return TRUE;
+    return true;
 }
 void CPDF_LabCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 {
     assert(iComponent < 3);
     value = 0;
     if (iComponent == 0) {
         min = 0;
         max = 100 * 1.0f;
     } else {
         min = m_Ranges[iComponent * 2 - 2];
         max = m_Ranges[iComponent * 2 - 1];
         if (value < min) {
             value = min;
         } else if (value > max) {
             value = max;
         }
     }
 }
-FX_BOOL CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     FX_FLOAT Lstar = pBuf[0];
     FX_FLOAT astar = pBuf[1];
     FX_FLOAT bstar = pBuf[2];
     FX_FLOAT M = (Lstar + 16.0f) / 116.0f;
     FX_FLOAT L = M + astar / 500.0f;
     FX_FLOAT N = M - bstar / 200.0f;
     FX_FLOAT X, Y, Z;
     if (L < 0.2069f) {
         X = 0.957f * 0.12842f * (L - 0.1379f);
     } else {
         X = 0.957f * L * L * L;
     }
     if (M < 0.2069f) {
         Y = 0.12842f * (M - 0.1379f);
     } else {
         Y = M * M * M;
     }
     if (N < 0.2069f) {
         Z = 1.0889f * 0.12842f * (N - 0.1379f);
     } else {
         Z = 1.0889f * N * N * N;
     }
     XYZ_to_sRGB(X, Y, Z, R, G, B);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_LabCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_LabCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
-    return FALSE;
+    return false;
 }
-void CPDF_LabCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_LabCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     for (int i = 0; i < pixels; i ++) {
         FX_FLOAT lab[3];
         FX_FLOAT R, G, B;
         lab[0] = (pSrcBuf[0] * 100 / 255.0f);
         lab[1] = (FX_FLOAT)(pSrcBuf[1] - 128);
         lab[2] = (FX_FLOAT)(pSrcBuf[2] - 128);
         GetRGB(lab, R, G, B);
         pDestBuf[0] = (int32_t)(B * 255);
         pDestBuf[1] = (int32_t)(G * 255);
         pDestBuf[2] = (int32_t)(R * 255);
         pDestBuf += 3;
         pSrcBuf += 3;
     }
 }
 CPDF_IccProfile::CPDF_IccProfile(const uint8_t* pData, FX_DWORD dwSize):
-    m_bsRGB(FALSE),
+    m_bsRGB(false),
     m_pTransform(NULL),
     m_nSrcComponents(0)
 {
     if (dwSize == 3144 && FXSYS_memcmp(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0) {
-        m_bsRGB = TRUE;
+        m_bsRGB = true;
         m_nSrcComponents = 3;
     }
     else if (CPDF_ModuleMgr::Get()->GetIccModule()) {
         m_pTransform = CPDF_ModuleMgr::Get()->GetIccModule()->CreateTransform_sRGB(pData, dwSize, m_nSrcComponents);
     }
 }
 CPDF_IccProfile::~CPDF_IccProfile()
 {
     if (m_pTransform) {
         CPDF_ModuleMgr::Get()->GetIccModule()->DestroyTransform(m_pTransform);
     }
 }
 class CPDF_ICCBasedCS : public CPDF_ColorSpace
 {
 public:
     explicit CPDF_ICCBasedCS(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_ICCBASED, 0),
           m_pAlterCS(nullptr),
           m_pProfile(nullptr),
           m_pCache(nullptr),
           m_pRanges(nullptr),
-          m_bOwn(FALSE) {
+          m_bOwn(false) {
     }
     ~CPDF_ICCBasedCS() override;
 
-    FX_BOOL     v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL     SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
-    FX_BOOL     v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool        v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool        SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool        v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const override;
+    void EnableStdConversion(bool bEnabled) override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
     CPDF_ColorSpace* m_pAlterCS;
     CPDF_IccProfile* m_pProfile;
     uint8_t* m_pCache;
     FX_FLOAT* m_pRanges;
-    FX_BOOL     m_bOwn;
+    bool        m_bOwn;
 };
 
 CPDF_ICCBasedCS::~CPDF_ICCBasedCS()
 {
     if (m_pCache) {
         FX_Free(m_pCache);
     }
     if (m_pRanges) {
         FX_Free(m_pRanges);
     }
     if (m_pAlterCS && m_bOwn) {
         m_pAlterCS->ReleaseCS();
     }
     if (m_pProfile && m_pDocument) {
         m_pDocument->GetPageData()->ReleaseIccProfile(m_pProfile);
     }
 }
 
-FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Stream* pStream = pArray->GetStream(1);
     if (pStream == NULL) {
-        return FALSE;
+        return false;
     }
     m_pProfile = pDoc->LoadIccProfile(pStream);
     if (!m_pProfile) {
-        return FALSE;
+        return false;
     }
     m_nComponents = m_pProfile->GetComponents(); //Try using the nComponents from ICC profile
     CPDF_Dictionary* pDict = pStream->GetDict();
     if (m_pProfile->m_pTransform == NULL) { // No valid ICC profile or using sRGB
         CPDF_Object* pAlterCSObj = pDict ? pDict->GetElementValue(FX_BSTRC("Alternate")) : NULL;
         if (pAlterCSObj) {
             CPDF_ColorSpace* pAlterCS = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
             if (pAlterCS) {
                 if (m_nComponents == 0) { // NO valid ICC profile
                     if (pAlterCS->CountComponents() > 0) { // Use Alternative colorspace
                         m_nComponents = pAlterCS->CountComponents();
                         m_pAlterCS = pAlterCS;
-                        m_bOwn = TRUE;
+                        m_bOwn = true;
                     }
                     else { // No valid alternative colorspace
                         pAlterCS->ReleaseCS();
                         int32_t nDictComponents = pDict ? pDict->GetInteger(FX_BSTRC("N")) : 0;
                         if (nDictComponents != 1 && nDictComponents != 3 && nDictComponents != 4) {
-                            return FALSE;
+                            return false;
                         }
                         m_nComponents = nDictComponents;
                     }
 
                 }
                 else { // Using sRGB
                     if (pAlterCS->CountComponents() != m_nComponents) {
                         pAlterCS->ReleaseCS();
                     }
                     else {
                         m_pAlterCS = pAlterCS;
-                        m_bOwn = TRUE;
+                        m_bOwn = true;
                     }
                 }
             }
         }
         if (!m_pAlterCS) {
             if (m_nComponents == 1) {
                 m_pAlterCS = GetStockCS(PDFCS_DEVICEGRAY);
             }
             else if (m_nComponents == 3) {
                 m_pAlterCS = GetStockCS(PDFCS_DEVICERGB);
             }
             else if (m_nComponents == 4) {
                 m_pAlterCS = GetStockCS(PDFCS_DEVICECMYK);
             }
         }
     }
     CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
     m_pRanges = FX_Alloc2D(FX_FLOAT, m_nComponents, 2);
     for (int i = 0; i < m_nComponents * 2; i ++) {
         if (pRanges) {
             m_pRanges[i] = pRanges->GetNumber(i);
         } else if (i % 2) {
             m_pRanges[i] = 1.0f;
         } else {
             m_pRanges[i] = 0;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pProfile && m_pProfile->m_bsRGB) {
         R = pBuf[0];
         G = pBuf[1];
         B = pBuf[2];
-        return TRUE;
+        return true;
     }
     ICodec_IccModule *pIccModule = CPDF_ModuleMgr::Get()->GetIccModule();
     if (m_pProfile->m_pTransform == NULL || pIccModule == NULL) {
         if (m_pAlterCS) {
             m_pAlterCS->GetRGB(pBuf, R, G, B);
         } else {
             R = G = B = 0.0f;
         }
-        return TRUE;
+        return true;
     }
     FX_FLOAT rgb[3];
     pIccModule->SetComponents(m_nComponents);
     pIccModule->Translate(m_pProfile->m_pTransform, pBuf, rgb);
     R = rgb[0];
     G = rgb[1];
     B = rgb[2];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_ICCBasedCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (m_nComponents != 4) {
-        return FALSE;
+        return false;
     }
     c = pBuf[0];
     m = pBuf[1];
     y = pBuf[2];
     k = pBuf[3];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_ICCBasedCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
-    return FALSE;
+    return false;
 }
-void CPDF_ICCBasedCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_ICCBasedCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAlterCS) {
         m_pAlterCS->EnableStdConversion(bEnabled);
     }
 }
-void CPDF_ICCBasedCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_ICCBasedCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (m_pProfile->m_bsRGB) {
         ReverseRGB(pDestBuf, pSrcBuf, pixels);
     } else if (m_pProfile->m_pTransform) {
         int nMaxColors = 1;
         for (int i = 0; i < m_nComponents; i ++) {
             nMaxColors *= 52;
         }
         if (m_nComponents > 3 || image_width * image_height < nMaxColors * 3 / 2) {
             CPDF_ModuleMgr::Get()->GetIccModule()->TranslateScanline(m_pProfile->m_pTransform, pDestBuf, pSrcBuf, pixels);
@@ skipping 34 matching lines @@
 {
 public:
     explicit CPDF_IndexedCS(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_INDEXED, 1),
           m_pBaseCS(nullptr),
           m_pCountedBaseCS(nullptr),
           m_pCompMinMax(nullptr) {
     }
     ~CPDF_IndexedCS() override;
 
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL     GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool        GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
     CPDF_ColorSpace* GetBaseCS() const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pBaseCS;
     CPDF_CountedColorSpace* m_pCountedBaseCS;
     int m_nBaseComponents;
     int m_MaxIndex;
     CFX_ByteString m_Table;
     FX_FLOAT* m_pCompMinMax;
 };
 CPDF_IndexedCS::~CPDF_IndexedCS()
 {
     if (m_pCompMinMax) {
         FX_Free(m_pCompMinMax);
     }
     CPDF_ColorSpace* pCS = m_pCountedBaseCS ? m_pCountedBaseCS->get() : NULL;
     if (pCS && m_pDocument) {
         m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
     }
 }
-FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     if (pArray->GetCount() < 4) {
-        return FALSE;
+        return false;
     }
     CPDF_Object* pBaseObj = pArray->GetElementValue(1);
     if (pBaseObj == m_pArray) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
     if (m_pBaseCS == NULL) {
-        return FALSE;
+        return false;
     }
     m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
     m_nBaseComponents = m_pBaseCS->CountComponents();
     m_pCompMinMax = FX_Alloc2D(FX_FLOAT, m_nBaseComponents, 2);
     FX_FLOAT defvalue;
     for (int i = 0; i < m_nBaseComponents; i ++) {
         m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2], m_pCompMinMax[i * 2 + 1]);
         m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
     }
     m_MaxIndex = pArray->GetInteger(2);
     CPDF_Object* pTableObj = pArray->GetElementValue(3);
     if (pTableObj == NULL) {
-        return FALSE;
+        return false;
     }
     if (pTableObj->GetType() == PDFOBJ_STRING) {
         m_Table = ((CPDF_String*)pTableObj)->GetString();
     } else if (pTableObj->GetType() == PDFOBJ_STREAM) {
         CPDF_StreamAcc acc;
-        acc.LoadAllData((CPDF_Stream*)pTableObj, FALSE);
+        acc.LoadAllData((CPDF_Stream*)pTableObj, false);
         m_Table = CFX_ByteStringC(acc.GetData(), acc.GetSize());
     }
-    return TRUE;
+    return true;
 }
 
-FX_BOOL CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     int index = (int32_t)(*pBuf);
     if (index < 0 || index > m_MaxIndex) {
-        return FALSE;
+        return false;
     }
     if (m_nBaseComponents) {
         if (index == INT_MAX || (index + 1) > INT_MAX / m_nBaseComponents ||
                 (index + 1)*m_nBaseComponents > (int)m_Table.GetLength()) {
             R = G = B = 0;
-            return FALSE;
+            return false;
         }
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> Comps(m_nBaseComponents);
     FX_FLOAT* comps = Comps;
     const uint8_t* pTable = m_Table;
     for (int i = 0; i < m_nBaseComponents; i ++) {
         comps[i] = m_pCompMinMax[i * 2] + m_pCompMinMax[i * 2 + 1] * pTable[index * m_nBaseComponents + i] / 255;
     }
     m_pBaseCS->GetRGB(comps, R, G, B);
-    return TRUE;
+    return true;
 }
 CPDF_ColorSpace*CPDF_IndexedCS::GetBaseCS() const
 {
     return m_pBaseCS;
 }
-void CPDF_IndexedCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_IndexedCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pBaseCS) {
         m_pBaseCS->EnableStdConversion(bEnabled);
     }
 }
 #define MAX_PATTERN_COLORCOMPS  16
 typedef struct _PatternValue {
     CPDF_Pattern*       m_pPattern;
     CPDF_CountedPattern*        m_pCountedPattern;
     int                         m_nComps;
     FX_FLOAT            m_Comps[MAX_PATTERN_COLORCOMPS];
 } PatternValue;
 CPDF_PatternCS::~CPDF_PatternCS()
 {
     CPDF_ColorSpace* pCS = m_pCountedBaseCS ? m_pCountedBaseCS->get() : NULL;
     if (pCS && m_pDocument) {
             m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
     }
 }
-FX_BOOL CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Object* pBaseCS = pArray->GetElementValue(1);
     if (pBaseCS == m_pArray) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseCS, NULL);
     if (m_pBaseCS) {
         if (m_pBaseCS->GetFamily() == PDFCS_PATTERN) {
-            return FALSE;
+            return false;
         }
         m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
         m_nComponents = m_pBaseCS->CountComponents() + 1;
         if (m_pBaseCS->CountComponents() > MAX_PATTERN_COLORCOMPS) {
-            return FALSE;
+            return false;
         }
     } else {
         m_nComponents = 1;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pBaseCS) {
         ASSERT(m_pBaseCS->GetFamily() != PDFCS_PATTERN);
         PatternValue* pvalue = (PatternValue*)pBuf;
         if (m_pBaseCS->GetRGB(pvalue->m_Comps, R, G, B)) {
-            return TRUE;
+            return true;
         }
     }
     R = G = B = 0.75f;
-    return FALSE;
+    return false;
 }
 CPDF_ColorSpace* CPDF_PatternCS::GetBaseCS() const
 {
     return m_pBaseCS;
 }
 class CPDF_SeparationCS : public CPDF_ColorSpace
 {
 public:
     CPDF_SeparationCS(CPDF_Document* pDoc)
             : CPDF_ColorSpace(pDoc, PDFCS_SEPARATION, 1),
               m_pAltCS(nullptr),
               m_pFunc(nullptr) {
     }
     ~CPDF_SeparationCS() override;
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pAltCS;
     CPDF_Function* m_pFunc;
     enum { None, All, Colorant } m_Type;
 };
 CPDF_SeparationCS::~CPDF_SeparationCS()
 {
     if (m_pAltCS) {
         m_pAltCS->ReleaseCS();
     }
     delete m_pFunc;
 }
 void CPDF_SeparationCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 {
     value = 1.0f;
     min = 0;
     max = 1.0f;
 }
-FX_BOOL CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CFX_ByteString name = pArray->GetString(1);
     if (name == FX_BSTRC("None")) {
         m_Type = None;
     } else {
         m_Type = Colorant;
         CPDF_Object* pAltCS = pArray->GetElementValue(2);
         if (pAltCS == m_pArray) {
-            return FALSE;
+            return false;
         }
         m_pAltCS = Load(pDoc, pAltCS);
         if (!m_pAltCS) {
-            return FALSE;
+            return false;
         }
         CPDF_Object* pFuncObj = pArray->GetElementValue(3);
         if (pFuncObj && pFuncObj->GetType() != PDFOBJ_NAME) {
             m_pFunc = CPDF_Function::Load(pFuncObj);
         }
         if (m_pFunc && m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
             delete m_pFunc;
             m_pFunc = NULL;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_Type == None) {
-        return FALSE;
+        return false;
     }
     if (m_pFunc == NULL) {
         if (m_pAltCS == NULL) {
-            return FALSE;
+            return false;
         }
         int nComps = m_pAltCS->CountComponents();
         CFX_FixedBufGrow<FX_FLOAT, 16> results(nComps);
         for (int i = 0; i < nComps; i ++) {
             results[i] = *pBuf;
         }
         m_pAltCS->GetRGB(results, R, G, B);
-        return TRUE;
+        return true;
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
     int nresults = 0;
     m_pFunc->Call(pBuf, 1, results, nresults);
     if (nresults == 0) {
-        return FALSE;
+        return false;
     }
     if (m_pAltCS) {
         m_pAltCS->GetRGB(results, R, G, B);
-        return TRUE;
+        return true;
     }
     R = G = B = 0;
-    return FALSE;
+    return false;
 }
-void CPDF_SeparationCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_SeparationCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAltCS) {
         m_pAltCS->EnableStdConversion(bEnabled);
     }
 }
 class CPDF_DeviceNCS : public CPDF_ColorSpace
 {
 public:
     CPDF_DeviceNCS(CPDF_Document* pDoc)
             : CPDF_ColorSpace(pDoc, PDFCS_DEVICEN, 0),
               m_pAltCS(nullptr),
               m_pFunc(nullptr) {
     }
     ~CPDF_DeviceNCS() override;
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pAltCS;
     CPDF_Function* m_pFunc;
 };
 CPDF_DeviceNCS::~CPDF_DeviceNCS()
 {
     delete m_pFunc;
     if (m_pAltCS) {
         m_pAltCS->ReleaseCS();
     }
 }
 void CPDF_DeviceNCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 {
     value = 1.0f;
     min = 0;
     max = 1.0f;
 }
-FX_BOOL CPDF_DeviceNCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_DeviceNCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Object* pObj = pArray->GetElementValue(1);
     if (!pObj) {
-        return FALSE;
+        return false;
     }
     if (pObj->GetType() != PDFOBJ_ARRAY) {
-        return FALSE;
+        return false;
     }
     m_nComponents = ((CPDF_Array*)pObj)->GetCount();
     CPDF_Object* pAltCS = pArray->GetElementValue(2);
     if (!pAltCS || pAltCS == m_pArray) {
-        return FALSE;
+        return false;
     }
     m_pAltCS = Load(pDoc, pAltCS);
     m_pFunc = CPDF_Function::Load(pArray->GetElementValue(3));
     if (m_pAltCS == NULL || m_pFunc == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pFunc == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
     int nresults = 0;
     m_pFunc->Call(pBuf, m_nComponents, results, nresults);
     if (nresults == 0) {
-        return FALSE;
+        return false;
     }
     m_pAltCS->GetRGB(results, R, G, B);
-    return TRUE;
+    return true;
 }
-void CPDF_DeviceNCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_DeviceNCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAltCS) {
         m_pAltCS->EnableStdConversion(bEnabled);
     }
 }
 CPDF_ColorSpace* CPDF_ColorSpace::GetStockCS(int family)
 {
     return CPDF_ModuleMgr::Get()->GetPageModule()->GetStockCS(family);;
 }
@@ skipping 105 matching lines @@
         return sizeof(PatternValue);
     }
     return m_nComponents * sizeof(FX_FLOAT);
 }
 FX_FLOAT* CPDF_ColorSpace::CreateBuf()
 {
     int size = GetBufSize();
     uint8_t* pBuf = FX_Alloc(uint8_t, size);
     return (FX_FLOAT*)pBuf;
 }
-FX_BOOL CPDF_ColorSpace::sRGB() const
+bool CPDF_ColorSpace::sRGB() const
 {
     if (m_Family == PDFCS_DEVICERGB) {
-        return TRUE;
+        return true;
     }
     if (m_Family != PDFCS_ICCBASED) {
-        return FALSE;
+        return false;
     }
     CPDF_ICCBasedCS* pCS = (CPDF_ICCBasedCS*)this;
     return pCS->m_pProfile->m_bsRGB;
 }
-FX_BOOL CPDF_ColorSpace::GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_ColorSpace::GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (v_GetCMYK(pBuf, c, m, y, k)) {
-        return TRUE;
+        return true;
     }
     FX_FLOAT R, G, B;
     if (!GetRGB(pBuf, R, G, B)) {
-        return FALSE;
+        return false;
     }
     sRGB_to_AdobeCMYK(R, G, B, c, m, y, k);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ColorSpace::SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
+bool CPDF_ColorSpace::SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 {
     if (v_SetCMYK(pBuf, c, m, y, k)) {
-        return TRUE;
+        return true;
     }
     FX_FLOAT R, G, B;
     AdobeCMYK_to_sRGB(c, m, y, k, R, G, B);
     return SetRGB(pBuf, R, G, B);
 }
 void CPDF_ColorSpace::GetDefaultColor(FX_FLOAT* buf) const
 {
     if (buf == NULL || m_Family == PDFCS_PATTERN) {
         return;
     }
     FX_FLOAT min, max;
     for (int i = 0; i < m_nComponents; i ++) {
         GetDefaultValue(i, buf[i], min, max);
     }
 }
 int CPDF_ColorSpace::GetMaxIndex() const
 {
     if (m_Family != PDFCS_INDEXED) {
         return 0;
     }
     CPDF_IndexedCS* pCS = (CPDF_IndexedCS*)this;
     return pCS->m_MaxIndex;
 }
-void CPDF_ColorSpace::TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_buf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_ColorSpace::TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_buf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     CFX_FixedBufGrow<FX_FLOAT, 16> srcbuf(m_nComponents);
     FX_FLOAT* src = srcbuf;
     FX_FLOAT R, G, B;
     for (int i = 0; i < pixels; i ++) {
         for (int j = 0; j < m_nComponents; j ++)
             if (m_Family == PDFCS_INDEXED) {
                 src[j] = (FX_FLOAT)(*src_buf ++);
             } else {
                 src[j] = (FX_FLOAT)(*src_buf ++) / 255;
             }
         GetRGB(src, R, G, B);
         *dest_buf ++ = (int32_t)(B * 255);
         *dest_buf ++ = (int32_t)(G * 255);
         *dest_buf ++ = (int32_t)(R * 255);
     }
 }
-void CPDF_ColorSpace::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_ColorSpace::EnableStdConversion(bool bEnabled)
 {
     if (bEnabled) {
         m_dwStdConversion ++;
     } else if (m_dwStdConversion) {
         m_dwStdConversion --;
     }
 }
 CPDF_Color::CPDF_Color(int family)
 {
     m_pCS = CPDF_ColorSpace::GetStockCS(family);
@@ skipping 111 matching lines @@
         }
     }
     if (m_pCS == NULL) {
         return;
     }
     m_pBuffer = m_pCS->CreateBuf();
     FXSYS_memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());
     if (m_pCS->GetFamily() == PDFCS_PATTERN) {
         PatternValue* pvalue = (PatternValue*)m_pBuffer;
         if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
-            pvalue->m_pPattern = pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(pvalue->m_pPattern->m_pPatternObj, FALSE, &pvalue->m_pPattern->m_ParentMatrix);
+            pvalue->m_pPattern = pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(pvalue->m_pPattern->m_pPatternObj, false, &pvalue->m_pPattern->m_ParentMatrix);
         }
     }
 }
-FX_BOOL CPDF_Color::GetRGB(int& R, int& G, int& B) const
+bool CPDF_Color::GetRGB(int& R, int& G, int& B) const
 {
     if (m_pCS == NULL || m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT r=0.0f, g=0.0f, b=0.0f;
     if (!m_pCS->GetRGB(m_pBuffer, r, g, b)) {
-        return FALSE;
+        return false;
     }
     R = (int32_t)(r * 255 + 0.5f);
     G = (int32_t)(g * 255 + 0.5f);
     B = (int32_t)(b * 255 + 0.5f);
-    return TRUE;
+    return true;
 }
 CPDF_Pattern* CPDF_Color::GetPattern() const
 {
     if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
         return NULL;
     }
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     return pvalue->m_pPattern;
 }
 CPDF_ColorSpace* CPDF_Color::GetPatternCS() const
 {
     if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
         return NULL;
     }
     return m_pCS->GetBaseCS();
 }
 FX_FLOAT* CPDF_Color::GetPatternColor() const
 {
     if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
         return NULL;
     }
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     return pvalue->m_nComps ? pvalue->m_Comps : NULL;
 }
-FX_BOOL CPDF_Color::IsEqual(const CPDF_Color& other) const
+bool CPDF_Color::IsEqual(const CPDF_Color& other) const
 {
     if (m_pCS != other.m_pCS || m_pCS == NULL) {
-        return FALSE;
+        return false;
     }
     return FXSYS_memcmp(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
 }