FX_BOOL considered harmful.

core/src/fxcodec/codec/fx_codec_fax.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/fxcodec/fx_codec.h"
 #include "codec_int.h"
 const uint8_t OneLeadPos[256] = {
     8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
@@ skipping 61 matching lines @@
     }
     if (byte_pos == max_byte) {
         return max_pos;
     }
     int pos = leading_pos[data_buf[byte_pos]] + byte_pos * 8;
     if (pos > max_pos) {
         pos = max_pos;
     }
     return pos;
 }
-void _FaxG4FindB1B2(const uint8_t* ref_buf, int columns, int a0, FX_BOOL a0color, int& b1, int& b2)
+void _FaxG4FindB1B2(const uint8_t* ref_buf, int columns, int a0, bool a0color, int& b1, int& b2)
 {
     if (a0color) {
         a0color = 1;
     }
     uint8_t first_bit = (a0 < 0) ? 1 : ((ref_buf[a0 / 8] & (1 << (7 - a0 % 8))) != 0);
     b1 = _FindBit(ref_buf, columns, a0 + 1, !first_bit);
     if (b1 >= columns) {
         b1 = b2 = columns;
         return;
     }
@@ skipping 300 matching lines @@
         }
         bitpos ++;
         int next_off = ins_off + ins * 3;
         for (; ins_off < next_off; ins_off += 3) {
             if (ins_array[ins_off] == code) {
                 return ins_array[ins_off + 1] + ins_array[ins_off + 2] * 256;
             }
         }
     }
 }
-FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns)
+bool _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns)
 {
     int a0 = -1, a0color = 1;
     while (1) {
         if (bitpos >= bitsize) {
-            return FALSE;
+            return false;
         }
         int a1, a2, b1, b2;
         _FaxG4FindB1B2(ref_buf, columns, a0, a0color, b1, b2);
-        FX_BOOL bit = NEXTBIT;
+        bool bit = NEXTBIT;
         int v_delta = 0;
         if (bit) {
         } else {
             if (bitpos >= bitsize) {
-                return FALSE;
+                return false;
             }
-            FX_BOOL bit1 = NEXTBIT;
+            bool bit1 = NEXTBIT;
             if (bitpos >= bitsize) {
-                return FALSE;
+                return false;
             }
-            FX_BOOL bit2 = NEXTBIT;
+            bool bit2 = NEXTBIT;
             if (bit1 && bit2) {
                 v_delta = 1;
             } else if (bit1) {
                 v_delta = -1;
             } else if (bit2) {
                 int run_len1 = 0;
                 while (1) {
                     int run = _FaxGetRun(a0color ? FaxWhiteRunIns : FaxBlackRunIns, src_buf, bitpos, bitsize);
                     run_len1 += run;
                     if (run < 64) {
@@ skipping 16 matching lines @@
                     }
                 }
                 a2 = a1 + run_len2;
                 if (a0color) {
                     _FaxFillBits(dest_buf, columns, a1, a2);
                 }
                 a0 = a2;
                 if (a0 < columns) {
                     continue;
                 }
-                return TRUE;
+                return true;
             } else {
                 if (bitpos >= bitsize) {
-                    return FALSE;
+                    return false;
                 }
                 bit = NEXTBIT;
                 if (bit) {
                     if (!a0color) {
                         _FaxFillBits(dest_buf, columns, a0, b2);
                     }
                     if (b2 >= columns) {
-                        return TRUE;
+                        return true;
                     }
                     a0 = b2;
                     continue;
                 } else {
                     if (bitpos >= bitsize) {
-                        return FALSE;
+                        return false;
                     }
-                    FX_BOOL bit1 = NEXTBIT;
+                    bool bit1 = NEXTBIT;
                     if (bitpos >= bitsize) {
-                        return FALSE;
+                        return false;
                     }
-                    FX_BOOL bit2 = NEXTBIT;
+                    bool bit2 = NEXTBIT;
                     if (bit1 && bit2) {
                         v_delta = 2;
                     } else if (bit1) {
                         v_delta = -2;
                     } else if (bit2) {
                         if (bitpos >= bitsize) {
-                            return FALSE;
+                            return false;
                         }
                         bit = NEXTBIT;
                         if (bit) {
                             v_delta = 3;
                         } else {
                             v_delta = -3;
                         }
                     } else {
                         if (bitpos >= bitsize) {
-                            return FALSE;
+                            return false;
                         }
                         bit = NEXTBIT;
                         if (bit) {
                             bitpos += 3;
                             continue;
                         } else {
                             bitpos += 5;
-                            return TRUE;
+                            return true;
                         }
                     }
                 }
             }
         }
         a1 = b1 + v_delta;
         if (!a0color) {
             _FaxFillBits(dest_buf, columns, a0, a1);
         }
         if (a1 >= columns) {
-            return TRUE;
+            return true;
         }
         a0 = a1;
         a0color = !a0color;
     }
 }
-FX_BOOL _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos)
+bool _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos)
 {
     int startbit = bitpos;
     while (bitpos < bitsize) {
         int bit = NEXTBIT;
         if (bit) {
             if (bitpos - startbit <= 11) {
                 bitpos = startbit;
             }
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns)
+bool _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns)
 {
-    int color = TRUE;
+    int color = true;
     int startpos = 0;
     while (1) {
         if (bitpos >= bitsize) {
-            return FALSE;
+            return false;
         }
         int run_len = 0;
         while (1) {
             int run = _FaxGetRun(color ? FaxWhiteRunIns : FaxBlackRunIns, src_buf, bitpos, bitsize);
             if (run < 0) {
                 while (bitpos < bitsize) {
                     int bit = NEXTBIT;
                     if (bit) {
-                        return TRUE;
+                        return true;
                     }
                 }
-                return FALSE;
+                return false;
             }
             run_len += run;
             if (run < 64) {
                 break;
             }
         }
         if (!color) {
             _FaxFillBits(dest_buf, columns, startpos, startpos + run_len);
         }
         startpos += run_len;
         if (startpos >= columns) {
             break;
         }
         color = !color;
     }
-    return TRUE;
+    return true;
 }
 class CCodec_FaxDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_FaxDecoder();
     virtual ~CCodec_FaxDecoder();
-    FX_BOOL                             Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-                               int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows);
+    bool                                Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
+                               int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows);
     virtual void                v_DownScale(int dest_width, int dest_height) {}
-    virtual FX_BOOL             v_Rewind();
+    virtual bool                v_Rewind();
     virtual uint8_t*    v_GetNextLine();
     virtual FX_DWORD    GetSrcOffset();
     int                 m_Encoding, m_bEndOfLine, m_bByteAlign, m_bBlack;
     int                 bitpos;
     const uint8_t*      m_pSrcBuf;
     FX_DWORD    m_SrcSize;
     uint8_t*    m_pScanlineBuf;
     uint8_t*    m_pRefBuf;
 };
 CCodec_FaxDecoder::CCodec_FaxDecoder()
 {
     m_pScanlineBuf = NULL;
     m_pRefBuf = NULL;
 }
 CCodec_FaxDecoder::~CCodec_FaxDecoder()
 {
     if (m_pScanlineBuf) {
         FX_Free(m_pScanlineBuf);
     }
     if (m_pRefBuf) {
         FX_Free(m_pRefBuf);
     }
 }
-FX_BOOL CCodec_FaxDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-                                  int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows)
+bool CCodec_FaxDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
+                                  int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows)
 {
     m_Encoding = K;
     m_bEndOfLine = EndOfLine;
     m_bByteAlign = EncodedByteAlign;
     m_bBlack = BlackIs1;
     m_OrigWidth = Columns;
     m_OrigHeight = Rows;
     if (m_OrigWidth == 0) {
         m_OrigWidth = width;
     }
     if (m_OrigHeight == 0) {
         m_OrigHeight = height;
     }
     m_Pitch = (m_OrigWidth + 31) / 32 * 4;
     m_OutputWidth = m_OrigWidth;
     m_OutputHeight = m_OrigHeight;
     m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
     m_pRefBuf = FX_Alloc(uint8_t, m_Pitch);
     m_pSrcBuf = src_buf;
     m_SrcSize = src_size;
     m_nComps = 1;
     m_bpc = 1;
-    m_bColorTransformed = FALSE;
-    return TRUE;
+    m_bColorTransformed = false;
+    return true;
 }
-FX_BOOL CCodec_FaxDecoder::v_Rewind()
+bool CCodec_FaxDecoder::v_Rewind()
 {
     FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
     bitpos = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_FaxDecoder::v_GetNextLine()
 {
     int bitsize = m_SrcSize * 8;
     _FaxSkipEOL(m_pSrcBuf, bitsize, bitpos);
     if (bitpos >= bitsize) {
         return NULL;
     }
     FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
     if (m_Encoding < 0) {
         _FaxG4GetRow(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_OrigWidth);
         FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
     } else if (m_Encoding == 0) {
         _FaxGet1DLine(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_OrigWidth);
     } else {
-        FX_BOOL bNext1D = m_pSrcBuf[bitpos / 8] & (1 << (7 - bitpos % 8));
+        bool bNext1D = m_pSrcBuf[bitpos / 8] & (1 << (7 - bitpos % 8));
         bitpos ++;
         if (bNext1D) {
             _FaxGet1DLine(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_OrigWidth);
         } else {
             _FaxG4GetRow(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_OrigWidth);
         }
         FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
     }
     if (m_bEndOfLine) {
         _FaxSkipEOL(m_pSrcBuf, bitsize, bitpos);
     }
     if (m_bByteAlign && bitpos < bitsize) {
         int bitpos0 = bitpos;
         int bitpos1 = (bitpos + 7) / 8 * 8;
         while (m_bByteAlign && bitpos0 < bitpos1) {
             int bit = m_pSrcBuf[bitpos0 / 8] & (1 << (7 - bitpos0 % 8));
             if (bit != 0) {
-                m_bByteAlign = FALSE;
+                m_bByteAlign = false;
             } else {
                 bitpos0 ++;
             }
         }
         if (m_bByteAlign) {
             bitpos = bitpos1;
         }
     }
     if (m_bBlack) {
         for (int i = 0; i < m_Pitch; i ++) {
@@ skipping 156 matching lines @@
 };
 static void _AddBitStream(uint8_t* dest_buf, int& dest_bitpos, int data, int bitlen)
 {
     for (int i = bitlen - 1; i >= 0; i --) {
         if (data & (1 << i)) {
             dest_buf[dest_bitpos / 8] |= 1 << (7 - dest_bitpos % 8);
         }
         dest_bitpos ++;
     }
 }
-static void _FaxEncodeRun(uint8_t* dest_buf, int& dest_bitpos, int run, FX_BOOL bWhite)
+static void _FaxEncodeRun(uint8_t* dest_buf, int& dest_bitpos, int run, bool bWhite)
 {
     while (run >= 2560) {
         _AddBitStream(dest_buf, dest_bitpos, 0x1f, 12);
         run -= 2560;
     }
     if (run >= 64) {
         int markup = run - run % 64;
         const uint8_t* p = bWhite ? WhiteRunMarkup : BlackRunMarkup;
         p += (markup / 64 - 1) * 2;
         _AddBitStream(dest_buf, dest_bitpos, *p, p[1]);
@@ skipping 105 matching lines @@
         dest_bitpos %= 8;
         FXSYS_memcpy(m_pRefLine, scan_line, m_Pitch);
     }
     if (dest_bitpos) {
         m_DestBuf.AppendByte(last_byte);
     }
     dest_buf = m_DestBuf.GetBuffer();
     dest_size = m_DestBuf.GetSize();
     m_DestBuf.DetachBuffer();
 }
-FX_BOOL CCodec_FaxModule::Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size)
+bool    CCodec_FaxModule::Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     CCodec_FaxEncoder encoder(src_buf, width, height, pitch);
     encoder.Encode(dest_buf, dest_size);
-    return TRUE;
+    return true;
 }
 ICodec_ScanlineDecoder* CCodec_FaxModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-        int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows)
+        int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows)
 {
     CCodec_FaxDecoder* pDecoder = new CCodec_FaxDecoder;
     pDecoder->Create(src_buf, src_size, width, height, K, EndOfLine, EncodedByteAlign, BlackIs1, Columns, Rows);
     return pDecoder;
 }