Remove FX_BOOL from core

core/fxcodec/codec/fx_codec_progress.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/codec/ccodec_progressivedecoder.h"
 
 #include <algorithm>
 
@@ skipping 29 matching lines @@
 CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::CFXCODEC_WeightTable() {}
 
 CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::~CFXCODEC_WeightTable() {}
 
 void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
                                                            int dest_min,
                                                            int dest_max,
                                                            int src_len,
                                                            int src_min,
                                                            int src_max,
-                                                           FX_BOOL bInterpol) {
+                                                           bool bInterpol) {
   double scale, base;
   scale = (FX_FLOAT)src_len / (FX_FLOAT)dest_len;
   if (dest_len < 0) {
     base = (FX_FLOAT)(src_len);
   } else {
     base = 0.0f;
   }
   m_ItemSize =
       (int)(sizeof(int) * 2 +
             sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + 1));
@@ skipping 78 matching lines @@
     }
   }
 }
 
 CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::CFXCODEC_HorzTable() {}
 
 CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::~CFXCODEC_HorzTable() {}
 
 void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
                                                          int src_len,
-                                                         FX_BOOL bInterpol) {
+                                                         bool bInterpol) {
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables.resize(size, 0);
   if (scale > 1) {
     int pre_des_col = 0;
     for (int src_col = 0; src_col < src_len; src_col++) {
       double des_col_f = src_col * scale;
       int des_col = FXSYS_round((FX_FLOAT)des_col_f);
       PixelWeight* pWeight = GetPixelWeight(des_col);
@@ skipping 115 matching lines @@
   m_SrcHeight = 0;
   m_SrcComponents = 0;
   m_SrcBPC = 0;
   m_SrcPassNumber = 0;
   m_clipBox = FX_RECT(0, 0, 0, 0);
   m_imagType = FXCODEC_IMAGE_UNKNOWN;
   m_status = FXCODEC_STATUS_DECODE_FINISH;
   m_TransMethod = -1;
   m_SrcRow = 0;
   m_SrcFormat = FXCodec_Invalid;
-  m_bInterpol = TRUE;
+  m_bInterpol = true;
   m_FrameNumber = 0;
   m_FrameCur = 0;
   m_SrcPaletteNumber = 0;
   m_GifPltNumber = 0;
   m_GifBgIndex = 0;
   m_pGifPalette = nullptr;
   m_GifTransIndex = -1;
   m_GifFrameRect = FX_RECT(0, 0, 0, 0);
-  m_BmpIsTopBottom = FALSE;
+  m_BmpIsTopBottom = false;
 }
 
 CCodec_ProgressiveDecoder::~CCodec_ProgressiveDecoder() {
   m_pFile = nullptr;
   if (m_pJpegContext)
     m_pCodecMgr->GetJpegModule()->Finish(m_pJpegContext);
   if (m_pPngContext)
     m_pCodecMgr->GetPngModule()->Finish(m_pPngContext);
   if (m_pGifContext)
     m_pCodecMgr->GetGifModule()->Finish(m_pGifContext);
   if (m_pBmpContext)
     m_pCodecMgr->GetBmpModule()->Finish(m_pBmpContext);
   if (m_pTiffContext)
     m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
   FX_Free(m_pSrcBuf);
   FX_Free(m_pDecodeBuf);
   FX_Free(m_pSrcPalette);
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
-    CCodec_JpegModule* pJpegModule,
-    FXCODEC_STATUS& err_status) {
+bool CCodec_ProgressiveDecoder::JpegReadMoreData(CCodec_JpegModule* pJpegModule,
+                                                 FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
-    return FALSE;
+    return false;
   }
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
-      return FALSE;
+      return false;
     }
   } else {
     uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
-    return FALSE;
+    return false;
   }
   m_offSet += dwSize;
   pJpegModule->Input(m_pJpegContext, m_pSrcBuf, dwSize + dwAvail);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
-                                                     int width,
-                                                     int height,
-                                                     int bpc,
-                                                     int pass,
-                                                     int* color_type,
-                                                     double* gamma) {
+bool CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
+                                                  int width,
+                                                  int height,
+                                                  int bpc,
+                                                  int pass,
+                                                  int* color_type,
+                                                  double* gamma) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   if (!pCodec->m_pDeviceBitmap) {
     pCodec->m_SrcWidth = width;
     pCodec->m_SrcHeight = height;
     pCodec->m_SrcBPC = bpc;
     pCodec->m_SrcPassNumber = pass;
     switch (*color_type) {
       case 0:
         pCodec->m_SrcComponents = 1;
         break;
       case 4:
         pCodec->m_SrcComponents = 2;
         break;
       case 2:
         pCodec->m_SrcComponents = 3;
         break;
       case 3:
       case 6:
         pCodec->m_SrcComponents = 4;
         break;
       default:
         pCodec->m_SrcComponents = 0;
         break;
     }
     pCodec->m_clipBox = FX_RECT(0, 0, width, height);
-    return FALSE;
+    return false;
   }
   FXDIB_Format format = pCodec->m_pDeviceBitmap->GetFormat();
   switch (format) {
     case FXDIB_1bppMask:
     case FXDIB_1bppRgb:
-      ASSERT(FALSE);
-      return FALSE;
+      ASSERT(false);
+      return false;
     case FXDIB_8bppMask:
     case FXDIB_8bppRgb:
       *color_type = 0;
       break;
     case FXDIB_Rgb:
       *color_type = 2;
       break;
     case FXDIB_Rgb32:
     case FXDIB_Argb:
       *color_type = 6;
       break;
     default:
-      ASSERT(FALSE);
-      return FALSE;
+      ASSERT(false);
+      return false;
   }
   *gamma = kPngGamma;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::PngAskScanlineBufFunc(void* pModule,
-                                                         int line,
-                                                         uint8_t*& src_buf) {
+bool CCodec_ProgressiveDecoder::PngAskScanlineBufFunc(void* pModule,
+                                                      int line,
+                                                      uint8_t*& src_buf) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
   if (!pDIBitmap) {
     ASSERT(false);
-    return FALSE;
+    return false;
   }
   if (line >= pCodec->m_clipBox.top && line < pCodec->m_clipBox.bottom) {
     double scale_y =
         (double)pCodec->m_sizeY / (double)pCodec->m_clipBox.Height();
     int32_t row =
         (int32_t)((line - pCodec->m_clipBox.top) * scale_y) + pCodec->m_startY;
     uint8_t* src_scan = (uint8_t*)pDIBitmap->GetScanline(row);
     uint8_t* des_scan = pCodec->m_pDecodeBuf;
     src_buf = pCodec->m_pDecodeBuf;
     int32_t src_Bpp = pDIBitmap->GetBPP() >> 3;
     int32_t des_Bpp = (pCodec->m_SrcFormat & 0xff) >> 3;
     int32_t src_left = pCodec->m_startX;
     int32_t des_left = pCodec->m_clipBox.left;
     src_scan += src_left * src_Bpp;
     des_scan += des_left * des_Bpp;
     for (int32_t src_col = 0; src_col < pCodec->m_sizeX; src_col++) {
       PixelWeight* pPixelWeights =
           pCodec->m_WeightHorzOO.GetPixelWeight(src_col);
       if (pPixelWeights->m_SrcStart != pPixelWeights->m_SrcEnd) {
         continue;
       }
       switch (pDIBitmap->GetFormat()) {
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
-          ASSERT(FALSE);
-          return FALSE;
+          ASSERT(false);
+          return false;
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb: {
           if (pDIBitmap->GetPalette()) {
-            return FALSE;
+            return false;
           }
           uint32_t des_g = 0;
           des_g += pPixelWeights->m_Weights[0] * src_scan[src_col];
           des_scan[pPixelWeights->m_SrcStart] = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
           uint32_t des_b = 0, des_g = 0, des_r = 0;
           const uint8_t* p = src_scan + src_col * src_Bpp;
           des_b += pPixelWeights->m_Weights[0] * (*p++);
@@ skipping 10 matching lines @@
           des_b += pPixelWeights->m_Weights[0] * (*p++);
           des_g += pPixelWeights->m_Weights[0] * (*p++);
           des_r += pPixelWeights->m_Weights[0] * (*p++);
           uint8_t* pDes = &des_scan[pPixelWeights->m_SrcStart * des_Bpp];
           *pDes++ = (uint8_t)((des_b) >> 16);
           *pDes++ = (uint8_t)((des_g) >> 16);
           *pDes++ = (uint8_t)((des_r) >> 16);
           *pDes = *p;
         } break;
         default:
-          return FALSE;
+          return false;
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
 void CCodec_ProgressiveDecoder::PngOneOneMapResampleHorz(
     CFX_DIBitmap* pDeviceBitmap,
     int32_t des_line,
     uint8_t* src_scan,
     FXCodec_Format src_format) {
   uint8_t* des_scan = (uint8_t*)pDeviceBitmap->GetScanline(des_line);
   int32_t src_Bpp = (m_SrcFormat & 0xff) >> 3;
   int32_t des_Bpp = pDeviceBitmap->GetBPP() >> 3;
   int32_t src_left = m_clipBox.left;
   int32_t des_left = m_startX;
   src_scan += src_left * src_Bpp;
   des_scan += des_left * des_Bpp;
   for (int32_t des_col = 0; des_col < m_sizeX; des_col++) {
     PixelWeight* pPixelWeights = m_WeightHorzOO.GetPixelWeight(des_col);
     switch (pDeviceBitmap->GetFormat()) {
       case FXDIB_1bppMask:
       case FXDIB_1bppRgb:
-        ASSERT(FALSE);
+        ASSERT(false);
         return;
       case FXDIB_8bppMask:
       case FXDIB_8bppRgb: {
         if (pDeviceBitmap->GetPalette()) {
           return;
         }
         uint32_t des_g = 0;
         des_g +=
             pPixelWeights->m_Weights[0] * src_scan[pPixelWeights->m_SrcStart];
         des_g +=
@@ skipping 64 matching lines @@
     if (pCodec->m_SrcPassNumber == 1 && scale_y > 1.0) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
       return;
     }
     if (pass == 6 && scale_y > 1.0) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
     }
   }
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
-                                                   FXCODEC_STATUS& err_status) {
+bool CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
+                                                FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
-    return FALSE;
+    return false;
   }
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pGifModule->GetAvailInput(m_pGifContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
-      return FALSE;
+      return false;
     }
   } else {
     uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
-    return FALSE;
+    return false;
   }
   m_offSet += dwSize;
   pGifModule->Input(m_pGifContext, m_pSrcBuf, dwSize + dwAvail);
-  return TRUE;
+  return true;
 }
 
 void CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback(
     void* pModule,
     uint32_t& cur_pos) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   uint32_t remain_size =
       pCodec->m_pCodecMgr->GetGifModule()->GetAvailInput(pCodec->m_pGifContext);
   cur_pos = pCodec->m_offSet - remain_size;
 }
 
 uint8_t* CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback(
     void* pModule,
     int32_t frame_num,
     int32_t pal_size) {
   return FX_Alloc(uint8_t, pal_size);
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback(
+bool CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback(
     void* pModule,
     uint32_t rcd_pos,
     const FX_RECT& img_rc,
     int32_t pal_num,
     void* pal_ptr,
     int32_t delay_time,
-    FX_BOOL user_input,
+    bool user_input,
     int32_t trans_index,
     int32_t disposal_method,
-    FX_BOOL interlace) {
+    bool interlace) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   pCodec->m_offSet = rcd_pos;
   FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
   if (!pCodec->GifReadMoreData(pCodec->m_pCodecMgr->GetGifModule(),
                                error_status)) {
-    return FALSE;
+    return false;
   }
   uint8_t* pPalette = nullptr;
   if (pal_num != 0 && pal_ptr) {
     pPalette = (uint8_t*)pal_ptr;
   } else {
     pal_num = pCodec->m_GifPltNumber;
     pPalette = pCodec->m_pGifPalette;
   }
   if (!pCodec->m_pSrcPalette) {
     pCodec->m_pSrcPalette = FX_Alloc(FX_ARGB, pal_num);
   } else if (pal_num > pCodec->m_SrcPaletteNumber) {
     pCodec->m_pSrcPalette = FX_Realloc(FX_ARGB, pCodec->m_pSrcPalette, pal_num);
   }
   if (!pCodec->m_pSrcPalette)
-    return FALSE;
+    return false;
 
   pCodec->m_SrcPaletteNumber = pal_num;
   for (int i = 0; i < pal_num; i++) {
     uint32_t j = i * 3;
     pCodec->m_pSrcPalette[i] =
         ArgbEncode(0xff, pPalette[j], pPalette[j + 1], pPalette[j + 2]);
   }
   pCodec->m_GifTransIndex = trans_index;
   pCodec->m_GifFrameRect = img_rc;
   pCodec->m_SrcPassNumber = interlace ? 4 : 1;
@@ skipping 35 matching lines @@
       }
       case 12: {
         for (int col = 0; col < sizeX; col++) {
           FXARGB_SETDIB(pScanline, argb);
           pScanline += 4;
         }
         break;
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
 void CCodec_ProgressiveDecoder::GifReadScanlineCallback(void* pModule,
                                                         int32_t row_num,
                                                         uint8_t* row_buf) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
   ASSERT(pDIBitmap);
   int32_t img_width = pCodec->m_GifFrameRect.Width();
   if (!pDIBitmap->HasAlpha()) {
@@ skipping 129 matching lines @@
       }
     }
   }
   int des_bottom = des_top + m_sizeY - 1;
   if (des_row + (int)(2 * scale_y) >= des_bottom &&
       des_row + (int)scale_y < des_bottom) {
     GifDoubleLineResampleVert(pDeviceBitmap, scale_y, des_row + (int)scale_y);
   }
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
-                                                   FXCODEC_STATUS& err_status) {
+bool CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
+                                                FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet)
-    return FALSE;
+    return false;
 
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
-      return FALSE;
+      return false;
     }
   } else {
     uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
-    return FALSE;
+    return false;
   }
   m_offSet += dwSize;
   pBmpModule->Input(m_pBmpContext, m_pSrcBuf, dwSize + dwAvail);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::BmpInputImagePositionBufCallback(
+bool CCodec_ProgressiveDecoder::BmpInputImagePositionBufCallback(
     void* pModule,
     uint32_t rcd_pos) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   pCodec->m_offSet = rcd_pos;
   FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
   return pCodec->BmpReadMoreData(pCodec->m_pCodecMgr->GetBmpModule(),
                                  error_status);
 }
 
 void CCodec_ProgressiveDecoder::BmpReadScanlineCallback(void* pModule,
@@ skipping 106 matching lines @@
           *scan_des++ = (uint8_t)((des_r) >> 16);
           *scan_des++ = (uint8_t)((des_a) >> 16);
         } break;
         default:
           return;
       }
     }
   }
 }
 
-FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
-    FXCODEC_IMAGE_TYPE imageType,
-    CFX_DIBAttribute* pAttribute) {
+bool CCodec_ProgressiveDecoder::DetectImageType(FXCODEC_IMAGE_TYPE imageType,
+                                                CFX_DIBAttribute* pAttribute) {
   m_offSet = 0;
   uint32_t size = (uint32_t)m_pFile->GetSize();
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
   FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (!pBmpModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
       pBmpModule->InputImagePositionBufCallback =
           BmpInputImagePositionBufCallback;
       pBmpModule->ReadScanlineCallback = BmpReadScanlineCallback;
       m_pBmpContext = pBmpModule->Start((void*)this);
       if (!m_pBmpContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
-      FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
+      bool bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
-        return FALSE;
+        return false;
       }
       m_offSet += size;
       pBmpModule->Input(m_pBmpContext, m_pSrcBuf, size);
       uint32_t* pPalette = nullptr;
       int32_t readResult = pBmpModule->ReadHeader(
           m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
           &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       while (readResult == 2) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
         if (!BmpReadMoreData(pBmpModule, error_status)) {
           m_status = error_status;
-          return FALSE;
+          return false;
         }
         readResult = pBmpModule->ReadHeader(
             m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
             &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       }
       if (readResult == 1) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
         FX_Free(m_pSrcPalette);
         if (m_SrcPaletteNumber) {
           m_pSrcPalette = FX_Alloc(FX_ARGB, m_SrcPaletteNumber);
           FXSYS_memcpy(m_pSrcPalette, pPalette,
                        m_SrcPaletteNumber * sizeof(uint32_t));
         } else {
           m_pSrcPalette = nullptr;
         }
-        return TRUE;
+        return true;
       }
       if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
         m_pBmpContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
-      return FALSE;
+      return false;
     }
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       if (!pJpegModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
       m_pJpegContext = pJpegModule->Start();
       if (!m_pJpegContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
-      FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
+      bool bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
-        return FALSE;
+        return false;
       }
       m_offSet += size;
       pJpegModule->Input(m_pJpegContext, m_pSrcBuf, size);
       int32_t readResult =
           pJpegModule->ReadHeader(m_pJpegContext, &m_SrcWidth, &m_SrcHeight,
                                   &m_SrcComponents, pAttribute);
       while (readResult == 2) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
         if (!JpegReadMoreData(pJpegModule, error_status)) {
           m_status = error_status;
-          return FALSE;
+          return false;
         }
         readResult =
             pJpegModule->ReadHeader(m_pJpegContext, &m_SrcWidth, &m_SrcHeight,
                                     &m_SrcComponents, pAttribute);
       }
       if (!readResult) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
-        return TRUE;
+        return true;
       }
       if (m_pJpegContext) {
         pJpegModule->Finish(m_pJpegContext);
         m_pJpegContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
-      return FALSE;
+      return false;
     }
     case FXCODEC_IMAGE_PNG: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       if (!pPngModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
       pPngModule->ReadHeaderCallback =
           CCodec_ProgressiveDecoder::PngReadHeaderFunc;
       pPngModule->AskScanlineBufCallback =
           CCodec_ProgressiveDecoder::PngAskScanlineBufFunc;
       pPngModule->FillScanlineBufCompletedCallback =
           CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc;
       m_pPngContext = pPngModule->Start((void*)this);
       if (!m_pPngContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
-      FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
+      bool bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
-        return FALSE;
+        return false;
       }
       m_offSet += size;
       bResult = pPngModule->Input(m_pPngContext, m_pSrcBuf, size, pAttribute);
       while (bResult) {
         uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
         uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = nullptr;
           m_status = FXCODEC_STATUS_ERR_FORMAT;
-          return FALSE;
+          return false;
         }
         if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
           FXSYS_memset(m_pSrcBuf, 0, input_size);
           m_SrcSize = input_size;
         }
         bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size);
         if (!bResult) {
           m_status = FXCODEC_STATUS_ERR_READ;
-          return FALSE;
+          return false;
         }
         m_offSet += input_size;
         bResult =
             pPngModule->Input(m_pPngContext, m_pSrcBuf, input_size, pAttribute);
       }
       ASSERT(!bResult);
       if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = nullptr;
       }
       if (m_SrcPassNumber == 0) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
-        return FALSE;
+        return false;
       }
-      return TRUE;
+      return true;
     }
     case FXCODEC_IMAGE_GIF: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       if (!pGifModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
       pGifModule->RecordCurrentPositionCallback =
           CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback;
       pGifModule->AskLocalPaletteBufCallback =
           CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback;
       pGifModule->InputRecordPositionBufCallback =
           CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback;
       pGifModule->ReadScanlineCallback =
           CCodec_ProgressiveDecoder::GifReadScanlineCallback;
       m_pGifContext = pGifModule->Start((void*)this);
       if (!m_pGifContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
-        return FALSE;
+        return false;
       }
-      FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
+      bool bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
-        return FALSE;
+        return false;
       }
       m_offSet += size;
       pGifModule->Input(m_pGifContext, m_pSrcBuf, size);
       m_SrcComponents = 1;
       int32_t readResult = pGifModule->ReadHeader(
           m_pGifContext, &m_SrcWidth, &m_SrcHeight, &m_GifPltNumber,
           (void**)&m_pGifPalette, &m_GifBgIndex, nullptr);
       while (readResult == 2) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
         if (!GifReadMoreData(pGifModule, error_status)) {
           m_status = error_status;
-          return FALSE;
+          return false;
         }
         readResult = pGifModule->ReadHeader(
             m_pGifContext, &m_SrcWidth, &m_SrcHeight, &m_GifPltNumber,
             (void**)&m_pGifPalette, &m_GifBgIndex, nullptr);
       }
       if (readResult == 1) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
-        return TRUE;
+        return true;
       }
       if (m_pGifContext) {
         pGifModule->Finish(m_pGifContext);
         m_pGifContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
-      return FALSE;
+      return false;
     }
     case FXCODEC_IMAGE_TIF: {
       CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
       if (!pTiffModule) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
-        return FALSE;
+        return false;
       }
       m_pTiffContext = pTiffModule->CreateDecoder(m_pFile);
       if (!m_pTiffContext) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
-        return FALSE;
+        return false;
       }
       int32_t dummy_bpc;
-      FX_BOOL ret = pTiffModule->LoadFrameInfo(m_pTiffContext, 0, &m_SrcWidth,
-                                               &m_SrcHeight, &m_SrcComponents,
-                                               &dummy_bpc, pAttribute);
+      bool ret = pTiffModule->LoadFrameInfo(m_pTiffContext, 0, &m_SrcWidth,
+                                            &m_SrcHeight, &m_SrcComponents,
+                                            &dummy_bpc, pAttribute);
       m_SrcComponents = 4;
       m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
       if (!ret) {
         pTiffModule->DestroyDecoder(m_pTiffContext);
         m_pTiffContext = nullptr;
         m_status = FXCODEC_STATUS_ERR_FORMAT;
-        return FALSE;
+        return false;
       }
-      return TRUE;
+      return true;
     }
     default:
       m_status = FXCODEC_STATUS_ERR_FORMAT;
-      return FALSE;
+      return false;
   }
 }
 
 FXCODEC_STATUS CCodec_ProgressiveDecoder::LoadImageInfo(
     IFX_SeekableReadStream* pFile,
     FXCODEC_IMAGE_TYPE imageType,
     CFX_DIBAttribute* pAttribute,
     bool bSkipImageTypeCheck) {
   switch (m_status) {
     case FXCODEC_STATUS_FRAME_READY:
@@ skipping 568 matching lines @@
       return FXCODEC_STATUS_ERROR;
   }
 }
 
 FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
                                                       int start_x,
                                                       int start_y,
                                                       int size_x,
                                                       int size_y,
                                                       int32_t frames,
-                                                      FX_BOOL bInterpol) {
+                                                      bool bInterpol) {
   if (m_status != FXCODEC_STATUS_DECODE_READY)
     return FXCODEC_STATUS_ERROR;
 
   if (!pDIBitmap || pDIBitmap->GetBPP() < 8 || frames < 0 ||
       frames >= m_FrameNumber) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   m_pDeviceBitmap = pDIBitmap;
   if (m_clipBox.IsEmpty())
     return FXCODEC_STATUS_ERR_PARAMS;
@@ skipping 34 matching lines @@
     }
   }
   if (m_clipBox.IsEmpty()) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       int down_scale = 1;
       GetDownScale(down_scale);
-      FX_BOOL bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
+      bool bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
       while (!bStart) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
         if (!JpegReadMoreData(pJpegModule, error_status)) {
           m_pDeviceBitmap = nullptr;
           m_pFile = nullptr;
           m_status = error_status;
           return m_status;
         }
         bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
       }
@@ skipping 132 matching lines @@
 }
 
 FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
   if (m_status != FXCODEC_STATUS_DECODE_TOBECONTINUE)
     return FXCODEC_STATUS_ERROR;
 
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       while (true) {
-        FX_BOOL readRes =
-            pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
+        bool readRes = pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         while (!readRes) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!JpegReadMoreData(pJpegModule, error_status)) {
             m_pDeviceBitmap = nullptr;
             m_pFile = nullptr;
             m_status = error_status;
             return m_status;
           }
           readRes = pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         }
@@ skipping 30 matching lines @@
           m_pFile = nullptr;
           m_status = FXCODEC_STATUS_DECODE_FINISH;
           return m_status;
         }
         if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
           FXSYS_memset(m_pSrcBuf, 0, input_size);
           m_SrcSize = input_size;
         }
-        FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size);
+        bool bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size);
         if (!bResult) {
           m_pDeviceBitmap = nullptr;
           m_pFile = nullptr;
           m_status = FXCODEC_STATUS_ERR_READ;
           return m_status;
         }
         m_offSet += input_size;
         bResult =
             pPngModule->Input(m_pPngContext, m_pSrcBuf, input_size, nullptr);
         if (!bResult) {
@@ skipping 64 matching lines @@
           return m_status;
         }
         m_pDeviceBitmap = nullptr;
         m_pFile = nullptr;
         m_status = FXCODEC_STATUS_ERROR;
         return m_status;
       }
     };
     case FXCODEC_IMAGE_TIF: {
       CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
-      FX_BOOL ret = FALSE;
+      bool ret = false;
       if (m_pDeviceBitmap->GetBPP() == 32 &&
           m_pDeviceBitmap->GetWidth() == m_SrcWidth && m_SrcWidth == m_sizeX &&
           m_pDeviceBitmap->GetHeight() == m_SrcHeight &&
           m_SrcHeight == m_sizeY && m_startX == 0 && m_startY == 0 &&
           m_clipBox.left == 0 && m_clipBox.top == 0 &&
           m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight) {
         ret = pTiffModule->Decode(m_pTiffContext, m_pDeviceBitmap);
         m_pDeviceBitmap = nullptr;
         m_pFile = nullptr;
         if (!ret) {
@@ skipping 130 matching lines @@
       return m_status;
     }
     default:
       return FXCODEC_STATUS_ERROR;
   }
 }
 
 CCodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }