Merge to XFA: Use stdint.h types throughout PDFium.

core/src/fxcodec/codec/fx_codec_flate.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 "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../fx_zlib.h"
 #include "codec_int.h"
 
 extern "C"
 {
     static void* my_alloc_func (void* opaque, unsigned int items, unsigned int size)
     {
-        return FX_Alloc2D(FX_BYTE, items, size);
+        return FX_Alloc2D(uint8_t, items, size);
     }
     static void   my_free_func  (void* opaque, void* address)
     {
         FX_Free(address);
     }
     void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int),
                             void (*free_func)(void*, void*))
     {
         z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream));
         if (p == NULL) {
@@ skipping 45 matching lines @@
         ((z_stream*)context)->zfree(0, context);
     }
     void FPDFAPI_FlateCompress(unsigned char* dest_buf, unsigned long* dest_size, const unsigned char* src_buf, unsigned long src_size)
     {
         compress(dest_buf, dest_size, src_buf, src_size);
     }
 }
 class CLZWDecoder 
 {
 public:
-    FX_BOOL Decode(FX_LPBYTE output, FX_DWORD& outlen, const FX_BYTE* input, FX_DWORD& size, FX_BOOL bEarlyChange);
+    FX_BOOL Decode(FX_LPBYTE output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, FX_BOOL bEarlyChange);
 private:
     FX_DWORD    m_InPos;
     FX_DWORD    m_OutPos;
     FX_LPBYTE   m_pOutput;
-    const FX_BYTE*      m_pInput;
+    const uint8_t*      m_pInput;
     FX_BOOL             m_Early;
-    void                AddCode(FX_DWORD prefix_code, FX_BYTE append_char);
+    void                AddCode(FX_DWORD prefix_code, uint8_t append_char);
     FX_DWORD    m_CodeArray[5021];
     FX_DWORD    m_nCodes;
-    FX_BYTE             m_DecodeStack[4000];
+    uint8_t             m_DecodeStack[4000];
     FX_DWORD    m_StackLen;
     void                DecodeString(FX_DWORD code);
     int                 m_CodeLen;
 };
-void CLZWDecoder::AddCode(FX_DWORD prefix_code, FX_BYTE append_char)
+void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char)
 {
     if (m_nCodes + m_Early == 4094) {
         return;
     }
     m_CodeArray[m_nCodes ++] = (prefix_code << 16) | append_char;
     if (m_nCodes + m_Early == 512 - 258) {
         m_CodeLen = 10;
     } else if (m_nCodes + m_Early == 1024 - 258) {
         m_CodeLen = 11;
     } else if (m_nCodes + m_Early == 2048 - 258) {
         m_CodeLen = 12;
     }
 }
 void CLZWDecoder::DecodeString(FX_DWORD code)
 {
     while (1) {
         int index = code - 258;
         if (index < 0 || index >= (int)m_nCodes) {
             break;
         }
         FX_DWORD data = m_CodeArray[index];
         if (m_StackLen >= sizeof(m_DecodeStack)) {
             return;
         }
-        m_DecodeStack[m_StackLen++] = (FX_BYTE)data;
+        m_DecodeStack[m_StackLen++] = (uint8_t)data;
         code = data >> 16;
     }
     if (m_StackLen >= sizeof(m_DecodeStack)) {
         return;
     }
-    m_DecodeStack[m_StackLen++] = (FX_BYTE)code;
+    m_DecodeStack[m_StackLen++] = (uint8_t)code;
 }
-int CLZWDecoder::Decode(FX_LPBYTE dest_buf, FX_DWORD& dest_size, const FX_BYTE* src_buf, FX_DWORD& src_size, FX_BOOL bEarlyChange)
+int CLZWDecoder::Decode(FX_LPBYTE dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, FX_BOOL bEarlyChange)
 {
     m_CodeLen = 9;
     m_InPos = 0;
     m_OutPos = 0;
     m_pInput = src_buf;
     m_pOutput = dest_buf;
     m_Early = bEarlyChange ? 1 : 0;
     m_nCodes = 0;
     FX_DWORD old_code = (FX_DWORD) - 1;
-    FX_BYTE last_char;
+    uint8_t last_char;
     while (1) {
         if (m_InPos + m_CodeLen > src_size * 8) {
             break;
         }
         int byte_pos = m_InPos / 8;
         int bit_pos = m_InPos % 8, bit_left = m_CodeLen;
         FX_DWORD code = 0;
         if (bit_pos) {
             bit_left -= 8 - bit_pos;
             code = (m_pInput[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
         }
         if (bit_left < 8) {
             code |= m_pInput[byte_pos] >> (8 - bit_left);
         } else {
             bit_left -= 8;
             code |= m_pInput[byte_pos++] << bit_left;
             if (bit_left) {
                 code |= m_pInput[byte_pos] >> (8 - bit_left);
             }
         }
         m_InPos += m_CodeLen;
         if (code < 256) {
             if (m_OutPos == dest_size) {
                 return -5;
             }
             if (m_pOutput) {
-                m_pOutput[m_OutPos] = (FX_BYTE)code;
+                m_pOutput[m_OutPos] = (uint8_t)code;
             }
             m_OutPos ++;
-            last_char = (FX_BYTE)code;
+            last_char = (uint8_t)code;
             if (old_code != (FX_DWORD) - 1) {
                 AddCode(old_code, last_char);
             }
             old_code = code;
         } else if (code == 256) {
             m_CodeLen = 9;
             m_nCodes = 0;
             old_code = (FX_DWORD) - 1;
         } else if (code == 257) {
             break;
@@ skipping 29 matching lines @@
             } else {
                 AddCode(old_code, last_char);
             }
             old_code = code;
         }
     }
     dest_size = m_OutPos;
     src_size = (m_InPos + 7) / 8;
     return 0;
 }
-static FX_BYTE PaethPredictor(int a, int b, int c)
+static uint8_t PaethPredictor(int a, int b, int c)
 {
     int p = a + b - c;
     int pa = FXSYS_abs(p - a);
     int pb = FXSYS_abs(p - b);
     int pc = FXSYS_abs(p - c);
     if (pa <= pb && pa <= pc) {
-        return (FX_BYTE)a;
+        return (uint8_t)a;
     }
     if (pb <= pc) {
-        return (FX_BYTE)b;
+        return (uint8_t)b;
     }
-    return (FX_BYTE)c;
+    return (uint8_t)c;
 }
 static FX_BOOL PNG_PredictorEncode(FX_LPBYTE& data_buf, FX_DWORD& data_size,
                                    int predictor, int Colors,
                                    int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
         return FALSE;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
-    FX_LPBYTE dest_buf = FX_Alloc2D(FX_BYTE, row_size + 1, row_count);
+    FX_LPBYTE dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count);
     int byte_cnt = 0;
     FX_LPBYTE pSrcData = data_buf;
     FX_LPBYTE pDestData = dest_buf;
     for (int row = 0; row < row_count; row++) {
         if (predictor == 10) {
             pDestData[0] = 0;
             int move_size = row_size;
             if (move_size * (row + 1) > (int)data_size) {
                 move_size = data_size - (move_size * row);
             }
             FXSYS_memmove32(pDestData + 1, pSrcData, move_size);
             pDestData += (move_size + 1);
             pSrcData += move_size;
             byte_cnt += move_size;
             continue;
         }
         for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) {
             switch (predictor) {
                 case 11: {
                         pDestData[0] = 1;
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pSrcData[byte - BytesPerPixel];
                         }
                         pDestData[byte + 1] = pSrcData[byte] - left;
                     }
                     break;
                 case 12: {
                         pDestData[0] = 2;
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pSrcData[byte - row_size];
                         }
                         pDestData[byte + 1] = pSrcData[byte] - up;
                     }
                     break;
                 case 13: {
                         pDestData[0] = 3;
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pSrcData[byte - BytesPerPixel];
                         }
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pSrcData[byte - row_size];
                         }
                         pDestData[byte + 1] = pSrcData[byte] - (left + up) / 2;
                     }
                     break;
                 case 14: {
                         pDestData[0] = 4;
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pSrcData[byte - BytesPerPixel];
                         }
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pSrcData[byte - row_size];
                         }
-                        FX_BYTE upper_left = 0;
+                        uint8_t upper_left = 0;
                         if (byte >= BytesPerPixel && row) {
                             upper_left = pSrcData[byte - row_size - BytesPerPixel];
                         }
                         pDestData[byte + 1] = pSrcData[byte] - PaethPredictor(left, up, upper_left);
                     }
                     break;
                 default: {
                         pDestData[byte + 1] = pSrcData[byte];
                     }
                     break;
             }
             byte_cnt++;
         }
         pDestData += (row_size + 1);
         pSrcData += row_size;
     }
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = (row_size + 1) * row_count - (last_row_size > 0 ? (row_size - last_row_size) : 0);
     return TRUE;
 }
 static void PNG_PredictLine(FX_LPBYTE pDestData, FX_LPCBYTE pSrcData, FX_LPCBYTE pLastLine,
                             int bpc, int nColors, int nPixels)
 {
     int row_size = (nPixels * bpc * nColors + 7) / 8;
     int BytesPerPixel = (bpc * nColors + 7) / 8;
-    FX_BYTE tag = pSrcData[0];
+    uint8_t tag = pSrcData[0];
     if (tag == 0) {
         FXSYS_memmove32(pDestData, pSrcData + 1, row_size);
         return;
     }
     for (int byte = 0; byte < row_size; byte ++) {
-        FX_BYTE raw_byte = pSrcData[byte + 1];
+        uint8_t raw_byte = pSrcData[byte + 1];
         switch (tag) {
             case 1:     {
-                    FX_BYTE left = 0;
+                    uint8_t left = 0;
                     if (byte >= BytesPerPixel) {
                         left = pDestData[byte - BytesPerPixel];
                     }
                     pDestData[byte] = raw_byte + left;
                     break;
                 }
             case 2: {
-                    FX_BYTE up = 0;
+                    uint8_t up = 0;
                     if (pLastLine) {
                         up = pLastLine[byte];
                     }
                     pDestData[byte] = raw_byte + up;
                     break;
                 }
             case 3: {
-                    FX_BYTE left = 0;
+                    uint8_t left = 0;
                     if (byte >= BytesPerPixel) {
                         left = pDestData[byte - BytesPerPixel];
                     }
-                    FX_BYTE up = 0;
+                    uint8_t up = 0;
                     if (pLastLine) {
                         up = pLastLine[byte];
                     }
                     pDestData[byte] = raw_byte + (up + left) / 2;
                     break;
                 }
             case 4: {
-                    FX_BYTE left = 0;
+                    uint8_t left = 0;
                     if (byte >= BytesPerPixel) {
                         left = pDestData[byte - BytesPerPixel];
                     }
-                    FX_BYTE up = 0;
+                    uint8_t up = 0;
                     if (pLastLine) {
                         up = pLastLine[byte];
                     }
-                    FX_BYTE upper_left = 0;
+                    uint8_t upper_left = 0;
                     if (byte >= BytesPerPixel && pLastLine) {
                         upper_left = pLastLine[byte - BytesPerPixel];
                     }
                     pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
                     break;
                 }
             default:
                 pDestData[byte] = raw_byte;
                 break;
         }
     }
 }
 static FX_BOOL PNG_Predictor(FX_LPBYTE& data_buf, FX_DWORD& data_size,
                              int Colors, int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
         return FALSE;
     const int row_count = (data_size + row_size) / (row_size + 1);
     const int last_row_size = data_size % (row_size + 1);
-    FX_LPBYTE dest_buf = FX_Alloc2D(FX_BYTE, row_size, row_count);
+    FX_LPBYTE dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
     int byte_cnt = 0;
     FX_LPBYTE pSrcData = data_buf;
     FX_LPBYTE pDestData = dest_buf;
     for (int row = 0; row < row_count; row ++) {
-        FX_BYTE tag = pSrcData[0];
+        uint8_t tag = pSrcData[0];
         byte_cnt++;
         if (tag == 0) {
             int move_size = row_size;
             if ((row + 1) * (move_size + 1) > (int)data_size) {
                 move_size = last_row_size - 1;
             }
             FXSYS_memmove32(pDestData, pSrcData + 1, move_size);
             pSrcData += move_size + 1;
             pDestData += move_size;
             byte_cnt += move_size;
             continue;
         }
         for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte ++) {
-            FX_BYTE raw_byte = pSrcData[byte + 1];
+            uint8_t raw_byte = pSrcData[byte + 1];
             switch (tag) {
                 case 1: {
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pDestData[byte - BytesPerPixel];
                         }
                         pDestData[byte] = raw_byte + left;
                         break;
                     }
                 case 2: {
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pDestData[byte - row_size];
                         }
                         pDestData[byte] = raw_byte + up;
                         break;
                     }
                 case 3: {
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pDestData[byte - BytesPerPixel];
                         }
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pDestData[byte - row_size];
                         }
                         pDestData[byte] = raw_byte + (up + left) / 2;
                         break;
                     }
                 case 4: {
-                        FX_BYTE left = 0;
+                        uint8_t left = 0;
                         if (byte >= BytesPerPixel) {
                             left = pDestData[byte - BytesPerPixel];
                         }
-                        FX_BYTE up = 0;
+                        uint8_t up = 0;
                         if (row) {
                             up = pDestData[byte - row_size];
                         }
-                        FX_BYTE upper_left = 0;
+                        uint8_t upper_left = 0;
                         if (byte >= BytesPerPixel && row) {
                             upper_left = pDestData[byte - row_size - BytesPerPixel];
                         }
                         pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
                         break;
                     }
                 default:
                     pDestData[byte] = raw_byte;
                     break;
             }
             byte_cnt++;
         }
         pSrcData += row_size + 1;
         pDestData += row_size;
     }
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = row_size * row_count - (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0);
     return TRUE;
 }
 static void TIFF_PredictorEncodeLine(FX_LPBYTE dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns)
 {
     int BytesPerPixel = BitsPerComponent * Colors / 8;
     if (BitsPerComponent < 8) {
-        FX_BYTE mask = 0x01;
+        uint8_t mask = 0x01;
         if (BitsPerComponent == 2) {
             mask = 0x03;
         } else if (BitsPerComponent == 4) {
             mask = 0x0F;
         }
         int row_bits = Colors * BitsPerComponent * Columns;
         for (int i = row_bits - BitsPerComponent; i >= BitsPerComponent; i -= BitsPerComponent) {
             int col = i % 8;
             int index = i / 8;
             int col_pre = (col == 0) ? (8 - BitsPerComponent) : (col - BitsPerComponent);
             int index_pre = (col == 0) ? (index - 1) : index;
-            FX_BYTE cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask;
-            FX_BYTE left = (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask;
+            uint8_t cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask;
+            uint8_t left = (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask;
             cur -= left;
             cur &= mask;
             cur <<= (8 - col - BitsPerComponent);
             dest_buf[index] &= ~(mask << ((8 - col - BitsPerComponent)));
             dest_buf[index] |= cur;
         }
     } else if (BitsPerComponent == 8) {
         for (int i = row_size - 1; i >= BytesPerPixel; i--) {
             dest_buf[i] -= dest_buf[i - BytesPerPixel];
         }
     } else {
         for (int i = row_size - BytesPerPixel; i >= BytesPerPixel; i -= BytesPerPixel) {
             FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1];
             pixel -= (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
             dest_buf[i] = pixel >> 8;
-            dest_buf[i + 1] = (FX_BYTE)pixel;
+            dest_buf[i + 1] = (uint8_t)pixel;
         }
     }
 }
 static FX_BOOL TIFF_PredictorEncode(FX_LPBYTE& data_buf, FX_DWORD& data_size,
                                     int Colors, int BitsPerComponent, int Columns)
 {
     int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size == 0)
         return FALSE;
     const int row_count = (data_size + row_size - 1) / row_size;
@@ skipping 25 matching lines @@
             col_pre = col;
         }
         return;
     }
     int BytesPerPixel = BitsPerComponent * Colors / 8;
     if (BitsPerComponent == 16) {
         for (int i = BytesPerPixel; i < row_size; i += 2) {
             FX_WORD pixel = (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
             pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
             dest_buf[i] = pixel >> 8;
-            dest_buf[i + 1] = (FX_BYTE)pixel;
+            dest_buf[i + 1] = (uint8_t)pixel;
         }
     } else {
         for (int i = BytesPerPixel; i < row_size; i ++) {
             dest_buf[i] += dest_buf[i - BytesPerPixel];
         }
     }
 }
 static FX_BOOL TIFF_Predictor(FX_LPBYTE& data_buf, FX_DWORD& data_size,
                               int Colors, int BitsPerComponent, int Columns)
 {
@@ skipping 67 matching lines @@
         int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns)
 {
     m_SrcBuf = src_buf;
     m_SrcSize = src_size;
     m_OutputWidth = m_OrigWidth = width;
     m_OutputHeight = m_OrigHeight = height;
     m_nComps = nComps;
     m_bpc = bpc;
     m_bColorTransformed = FALSE;
     m_Pitch = (width * nComps * bpc + 7) / 8;
-    m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
+    m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     m_Predictor = 0;
     if (predictor) {
         if (predictor >= 10) {
             m_Predictor = 2;
         } else if (predictor == 2) {
             m_Predictor = 1;
         }
         if (m_Predictor) {
             if (BitsPerComponent * Colors * Columns == 0) {
                 BitsPerComponent = m_bpc;
                 Colors = m_nComps;
                 Columns = m_OrigWidth;
             }
             m_Colors = Colors;
             m_BitsPerComponent = BitsPerComponent;
             m_Columns = Columns;
             m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8;
-            m_pLastLine = FX_Alloc(FX_BYTE, m_PredictPitch);
-            m_pPredictRaw = FX_Alloc(FX_BYTE, m_PredictPitch + 1);
-            m_pPredictBuffer = FX_Alloc(FX_BYTE, m_PredictPitch);
+            m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
+            m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
+            m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
         }
     }
 }
 FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind()
 {
     if (m_pFlate) {
         FPDFAPI_FlateEnd(m_pFlate);
     }
     m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (m_pFlate == NULL) {
@@ skipping 55 matching lines @@
     FX_DWORD alloc_step = orig_size ? 10240 : (src_size < 10240 ? 10240 : src_size);
     static const FX_DWORD kMaxInitialAllocSize = 10000000;
     if (guess_size > kMaxInitialAllocSize) {
         guess_size = kMaxInitialAllocSize;
         alloc_step = kMaxInitialAllocSize;
     }
     FX_DWORD buf_size = guess_size;
     FX_DWORD last_buf_size = buf_size;
     void* context = nullptr;
 
-    FX_LPBYTE guess_buf = FX_Alloc(FX_BYTE, guess_size + 1);
+    FX_LPBYTE guess_buf = FX_Alloc(uint8_t, guess_size + 1);
     FX_LPBYTE cur_buf = guess_buf;
     guess_buf[guess_size] = '\0';
     context = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (!context)
         goto fail;
     FPDFAPI_FlateInput(context, src_buf, src_size);
     if (useOldImpl) {
         while (1) {
-            FX_INT32 ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
+            int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
             if (ret != Z_OK)
                 break;
-            FX_INT32 avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
+            int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
             if (avail_buf_size != 0)
                 break;
 
             // |avail_buf_size| == 0 case.
             FX_DWORD old_size = guess_size;
             guess_size += alloc_step;
             if (guess_size < old_size || guess_size + 1 < guess_size)
                 goto fail;
-            guess_buf = FX_Realloc(FX_BYTE, guess_buf, guess_size + 1);
+            guess_buf = FX_Realloc(uint8_t, guess_buf, guess_size + 1);
             if (!guess_buf)
                 goto fail;
             guess_buf[guess_size] = '\0';
             cur_buf = guess_buf + old_size;
             buf_size = guess_size - old_size;
         }
         dest_size = FPDFAPI_FlateGetTotalOut(context);
         offset = FPDFAPI_FlateGetTotalIn(context);
         if (guess_size / 2 > dest_size) {
-            guess_buf = FX_Realloc(FX_BYTE, guess_buf, dest_size + 1);
+            guess_buf = FX_Realloc(uint8_t, guess_buf, dest_size + 1);
             if (!guess_buf)
                 goto fail;
             guess_size = dest_size;
             guess_buf[guess_size] = '\0';
         }
         dest_buf = guess_buf;
     } else {
         CFX_ArrayTemplate<FX_LPBYTE> result_tmp_bufs;
         while (1) {
-            FX_INT32 ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
-            FX_INT32 avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
+            int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
+            int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
             if (ret != Z_OK) {
                 last_buf_size = buf_size - avail_buf_size;
                 result_tmp_bufs.Add(cur_buf);
                 break;
             }
             if (avail_buf_size != 0) {
                 last_buf_size = buf_size - avail_buf_size;
                 result_tmp_bufs.Add(cur_buf);
                 break;
             }
 
             // |avail_buf_size| == 0 case.
             result_tmp_bufs.Add(cur_buf);
-            cur_buf = FX_Alloc(FX_BYTE, buf_size + 1);
+            cur_buf = FX_Alloc(uint8_t, buf_size + 1);
             cur_buf[buf_size] = '\0';
         }
         dest_size = FPDFAPI_FlateGetTotalOut(context);
         offset = FPDFAPI_FlateGetTotalIn(context);
         if (result_tmp_bufs.GetSize() == 1) {
             dest_buf = result_tmp_bufs[0];
         } else {
-            FX_LPBYTE result_buf = FX_Alloc(FX_BYTE, dest_size);
+            FX_LPBYTE result_buf = FX_Alloc(uint8_t, dest_size);
             FX_DWORD result_pos = 0;
-            for (FX_INT32 i = 0; i < result_tmp_bufs.GetSize(); i++) {
+            for (int32_t i = 0; i < result_tmp_bufs.GetSize(); i++) {
                 FX_LPBYTE tmp_buf = result_tmp_bufs[i];
                 FX_DWORD tmp_buf_size = buf_size;
                 if (i == result_tmp_bufs.GetSize() - 1) {
                     tmp_buf_size = last_buf_size;
                 }
                 FXSYS_memcpy32(result_buf + result_pos, tmp_buf, tmp_buf_size);
                 result_pos += tmp_buf_size;
                 FX_Free(result_tmp_bufs[i]);
             }
             dest_buf = result_buf;
         }
     }
     FPDFAPI_FlateEnd(context);
     return;
 
 fail:
     FX_Free(guess_buf);
     dest_buf = nullptr;
     dest_size = 0;
     return;
 }
 ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns)
 {
     CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder;
     pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
     return pDecoder;
 }
-FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const FX_BYTE* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
+FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
         int predictor, int Colors, int BitsPerComponent, int Columns,
         FX_DWORD estimated_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     dest_buf = NULL;
     FX_DWORD offset = 0;
     int predictor_type = 0;
     if (predictor) {
         if (predictor >= 10) {
             predictor_type = 2;
         } else if (predictor == 2) {
             predictor_type = 1;
         }
     }
     if (bLZW) {
         {
             nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
             dest_size = (FX_DWORD) - 1;
             offset = src_size;
             int err = decoder->Decode(NULL, dest_size, src_buf, offset,
                                       bEarlyChange);
             if (err || dest_size == 0 || dest_size + 1 < dest_size) {
                 return -1;
             }
         }
         {
             nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
-            dest_buf = FX_Alloc( FX_BYTE, dest_size + 1);
+            dest_buf = FX_Alloc( uint8_t, dest_size + 1);
             dest_buf[dest_size] = '\0';
             decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
         }
     } else {
         FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size, offset);
     }
     if (predictor_type == 0) {
         return offset;
     }
     FX_BOOL ret = TRUE;
     if (predictor_type == 2) {
         ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                             Columns);
     } else if (predictor_type == 1) {
         ret = TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                              Columns);
     }
     return ret ? offset : -1;
 }
-FX_BOOL CCodec_FlateModule::Encode(const FX_BYTE* src_buf, FX_DWORD src_size,
+FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
                                    int predictor, int Colors, int BitsPerComponent, int Columns,
                                    FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     if (predictor != 2 && predictor < 10) {
         return Encode(src_buf, src_size, dest_buf, dest_size);
     }
     FX_LPBYTE pSrcBuf = NULL;
-    pSrcBuf = FX_Alloc(FX_BYTE, src_size);
+    pSrcBuf = FX_Alloc(uint8_t, src_size);
     FXSYS_memcpy32(pSrcBuf, src_buf, src_size);
     FX_BOOL ret = TRUE;
     if (predictor == 2) {
         ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                    Columns);
     } else if (predictor >= 10) {
         ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
                                   BitsPerComponent, Columns);
     }
     if (ret)
         ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
     FX_Free(pSrcBuf);
     return ret;
 }
 FX_BOOL CCodec_FlateModule::Encode(FX_LPCBYTE src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     dest_size = src_size + src_size / 1000 + 12;
-    dest_buf = FX_Alloc( FX_BYTE, dest_size);
+    dest_buf = FX_Alloc( uint8_t, dest_size);
     unsigned long temp_size = dest_size;
     FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
     dest_size = (FX_DWORD)temp_size;
     return TRUE;
 }