Avoid some FX_BOOL/bool noise in fx_codec_fax.cpp

core/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 <algorithm>
 #include <vector>
 
 #include "core/fxcodec/codec/codec_int.h"
@@ skipping 107 matching lines @@
 
   for (int i = startpos % 8; i < 8; ++i)
     dest_buf[first_byte] -= 1 << (7 - i);
   for (int i = 0; i <= (endpos - 1) % 8; ++i)
     dest_buf[last_byte] -= 1 << (7 - i);
 
   if (last_byte > first_byte + 1)
     FXSYS_memset(dest_buf + first_byte + 1, 0, last_byte - first_byte - 1);
 }
 
-#define NEXTBIT()                                  \
-  src_buf[*bitpos / 8] & (1 << (7 - *bitpos % 8)); \
-  ++(*bitpos);
+inline bool NextBit(const uint8_t* src_buf, int* bitpos) {
+  int pos = (*bitpos)++;
+  return !!(src_buf[pos / 8] & (1 << (7 - pos % 8)));
+}
 
 const uint8_t FaxBlackRunIns[] = {
     0,          2,          0x02,       3,          0,          0x03,
     2,          0,          2,          0x02,       1,          0,
     0x03,       4,          0,          2,          0x02,       6,
     0,          0x03,       5,          0,          1,          0x03,
     7,          0,          2,          0x04,       9,          0,
     0x05,       8,          0,          3,          0x04,       10,
     0,          0x05,       11,         0,          0x07,       12,
     0,          2,          0x04,       13,         0,          0x07,
@@ skipping 141 matching lines @@
   bool a0color = true;
   while (1) {
     if (*bitpos >= bitsize)
       return FALSE;
 
     int a1;
     int a2;
     int b1;
     int b2;
     FaxG4FindB1B2(ref_buf, columns, a0, a0color, &b1, &b2);
-    FX_BOOL bit = NEXTBIT();
+
     int v_delta = 0;
-    if (!bit) {
+    if (!NextBit(src_buf, bitpos)) {
       if (*bitpos >= bitsize)
         return FALSE;
 
-      FX_BOOL bit1 = NEXTBIT();
+      FX_BOOL bit1 = NextBit(src_buf, bitpos);
       if (*bitpos >= bitsize)
         return FALSE;
 
-      FX_BOOL bit2 = NEXTBIT();
+      FX_BOOL bit2 = NextBit(src_buf, bitpos);
       if (bit1) {
         v_delta = bit2 ? 1 : -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) {
             break;
@@ skipping 21 matching lines @@
 
         a0 = a2;
         if (a0 < columns)
           continue;
 
         return TRUE;
       } else {
         if (*bitpos >= bitsize)
           return FALSE;
 
-        bit = NEXTBIT();
-        if (bit) {
+        if (NextBit(src_buf, bitpos)) {
           if (!a0color)
             FaxFillBits(dest_buf, columns, a0, b2);
 
           if (b2 >= columns)
             return TRUE;
 
           a0 = b2;
           continue;
         }
 
         if (*bitpos >= bitsize)
           return FALSE;
 
-        FX_BOOL next_bit1 = NEXTBIT();
+        FX_BOOL next_bit1 = NextBit(src_buf, bitpos);
         if (*bitpos >= bitsize)
           return FALSE;
 
-        FX_BOOL next_bit2 = NEXTBIT();
+        FX_BOOL next_bit2 = NextBit(src_buf, bitpos);
         if (next_bit1) {
           v_delta = next_bit2 ? 2 : -2;
         } else if (next_bit2) {
           if (*bitpos >= bitsize)
             return FALSE;
 
-          bit = NEXTBIT();
-          v_delta = bit ? 3 : -3;
+          v_delta = NextBit(src_buf, bitpos) ? 3 : -3;
         } else {
           if (*bitpos >= bitsize)
             return FALSE;
 
-          bit = NEXTBIT();
-          if (bit) {
+          if (NextBit(src_buf, bitpos)) {
             *bitpos += 3;
             continue;
           }
           *bitpos += 5;
           return TRUE;
         }
       }
     }
     a1 = b1 + v_delta;
     if (!a0color)
       FaxFillBits(dest_buf, columns, a0, a1);
 
     if (a1 >= columns)
       return TRUE;
 
     // The position of picture element must be monotonic increasing.
     if (a0 >= a1)
       return FALSE;
 
     a0 = a1;
     a0color = !a0color;
   }
 }
 
 FX_BOOL FaxSkipEOL(const uint8_t* src_buf, int bitsize, int* bitpos) {
   int startbit = *bitpos;
   while (*bitpos < bitsize) {
-    int bit = NEXTBIT();
-    if (!bit)
+    if (!NextBit(src_buf, bitpos))
       continue;
-
     if (*bitpos - startbit <= 11)
       *bitpos = startbit;
     return TRUE;
   }
   return FALSE;
 }
 
 FX_BOOL FaxGet1DLine(const uint8_t* src_buf,
                      int bitsize,
                      int* bitpos,
                      std::vector<uint8_t>* dest_buf,
                      int columns) {
   bool color = true;
   int startpos = 0;
   while (1) {
     if (*bitpos >= bitsize)
       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) {
+          if (NextBit(src_buf, bitpos))
             return TRUE;
-          }
         }
         return FALSE;
       }
       run_len += run;
       if (run < 64) {
         break;
       }
     }
     if (!color)
       FaxFillBits(dest_buf->data(), columns, startpos, startpos + run_len);
@@ skipping 159 matching lines @@
     return nullptr;
 
   // Reject unreasonable large input.
   if (actual_width > kMaxImageDimension || actual_height > kMaxImageDimension)
     return nullptr;
 
   uint32_t pitch = (static_cast<uint32_t>(actual_width) + 31) / 32 * 4;
   return new CCodec_FaxDecoder(src_buf, src_size, actual_width, actual_height,
                                pitch, K, EndOfLine, EncodedByteAlign, BlackIs1);
 }