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

core/src/fxcodec/codec/fx_codec.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"
 CCodec_ModuleMgr::CCodec_ModuleMgr()
 {
@@ skipping 105 matching lines @@
         dest_height = -dest_height;
     }
     v_DownScale(dest_width, dest_height);
     if (m_pDataCache) {
         if (m_pDataCache->m_Height == m_OutputHeight && m_pDataCache->m_Width == m_OutputWidth) {
             return;
         }
         FX_Free(m_pDataCache);
         m_pDataCache = NULL;
     }
-    m_pDataCache = (CCodec_ImageDataCache*)FX_TryAlloc(FX_BYTE, sizeof(CCodec_ImageDataCache) + m_Pitch * m_OutputHeight);
+    m_pDataCache = (CCodec_ImageDataCache*)FX_TryAlloc(uint8_t, sizeof(CCodec_ImageDataCache) + m_Pitch * m_OutputHeight);
     if (m_pDataCache == NULL) {
         return;
     }
     m_pDataCache->m_Height = m_OutputHeight;
     m_pDataCache->m_Width = m_OutputWidth;
     m_pDataCache->m_nCachedLines = 0;
 }
-FX_BOOL CCodec_BasicModule::RunLengthEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf,
+FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf,
         FX_DWORD& dest_size)
 {
     return FALSE;
 }
 extern "C" double FXstrtod(const char* nptr, char** endptr)
 {
     double ret = 0.0;
     const char* ptr = nptr;
     const char* exp_ptr = NULL;
     int e_number = 0,
@@ skipping 88 matching lines @@
         while(exp_ret--) {
             ret *= 10.0;
         }
     } else {
         while(exp_ret--) {
             ret /= 10.0;
         }
     }
     return is_negative ? -ret : ret;
 }
-FX_BOOL CCodec_BasicModule::A85Encode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf,
+FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf,
                                       FX_DWORD& dest_size)
 {
     return FALSE;
 }
 CCodec_ModuleMgr* CCodec_ModuleMgr::Create()
 {
     return new CCodec_ModuleMgr;
 }
 void CCodec_ModuleMgr::Destroy()
 {
@@ skipping 107 matching lines @@
     if (pMap && data) {
         if (len > 8) {
             FX_WORD wTagNum = m_readWord(data);
             data += 2;
             FX_DWORD wTag;
             FX_LPBYTE buf;
             while (wTagNum--) {
                 wTag = m_readWord(data);
                 data += 2;
                 if (!pMap->Lookup(wTag, buf)) {
-                    buf = FX_Alloc(FX_BYTE, 10);
+                    buf = FX_Alloc(uint8_t, 10);
                     if (buf == NULL) {
                         return FALSE;
                     }
                     FXSYS_memcpy32(buf, data, 10);
                     pMap->SetAt(wTag, buf);
                 }
                 data += 10;
             }
             FX_DWORD dwIFDOffset;
             dwIFDOffset = m_readDword(data);
             while (dwIFDOffset && dwIFDOffset < len) {
                 data = m_pExifData + dwIFDOffset;
                 wTagNum = m_readWord(data);
                 data += 2;
                 while (wTagNum--) {
                     wTag = m_readWord(data);
                     data += 2;
                     if (!pMap->Lookup(wTag, buf)) {
-                        buf = FX_Alloc(FX_BYTE, 10);
+                        buf = FX_Alloc(uint8_t, 10);
                         if (buf == NULL) {
                             return FALSE;
                         }
                         FXSYS_memcpy32(buf, data, 10);
                         pMap->SetAt(wTag, buf);
                     }
                     data += 10;
                 }
                 dwIFDOffset = m_readDword(data);
             }
@@ skipping 44 matching lines @@
                     type = m_readWord(head);
                     head += 2;
                     dwModuleNum = m_readDword(head);
                     head += 4;
                     switch (type) {
                         case FX_UnsignedByte:
                         case FX_AscString:
                         case FX_SignedByte:
                         case FX_Undefined:
                             dwSize = dwModuleNum;
-                            val = FX_Alloc(FX_BYTE, dwSize);
+                            val = FX_Alloc(uint8_t, dwSize);
                             if (val == NULL) {
                                 return FALSE;
                             }
                             if (dwSize > 4) {
                                 FXSYS_memcpy32(val, old_data + m_readDword(head), dwSize);
                             } else {
                                 FXSYS_memcpy32(val, head, dwSize);
                             }
                             break;
                         case FX_UnsignedShort:
                         case FX_SignedShort:
                             dwSize = dwModuleNum << 1;
-                            val = FX_Alloc(FX_BYTE, dwSize);
+                            val = FX_Alloc(uint8_t, dwSize);
                             if (val == NULL) {
                                 return FALSE;
                             }
                             if (dwSize > 4) {
                                 FXSYS_memcpy32(val, old_data + m_readDword(head), dwSize);
                             } else {
                                 FXSYS_memcpy32(val, head, dwSize);
                             }
                             buf = val;
                             for(i = 0; i < (int)dwModuleNum; i ++) {
                                 *(FX_WORD*)buf = m_readWord(buf);
                                 buf += 2;
                             }
                             break;
                         case FX_UnsignedLong:
                         case FX_SignedLong:
                         case FX_SignedFloat:
                             dwSize = dwModuleNum << 2;
-                            val = FX_Alloc(FX_BYTE, dwSize);
+                            val = FX_Alloc(uint8_t, dwSize);
                             if (val == NULL) {
                                 return FALSE;
                             }
                             if (dwSize > 4) {
                                 FXSYS_memcpy32(val, old_data + m_readDword(head), dwSize);
                             } else {
                                 FXSYS_memcpy32(val, head, dwSize);
                             }
                             buf = val;
                             for(i = 0; i < (int)dwModuleNum; i ++) {
                                 *(FX_DWORD*)buf = m_readDword(buf);
                                 buf += 4;
                             }
                             break;
                         case FX_UnsignedRation:
                         case FX_SignedRation: {
                                 dwSize = dwModuleNum << 3;
-                                buf = FX_Alloc(FX_BYTE, dwSize);
+                                buf = FX_Alloc(uint8_t, dwSize);
                                 if (buf == NULL) {
                                     return FALSE;
                                 }
                                 if (dwSize > 4) {
                                     FXSYS_memcpy32(buf, old_data + m_readDword(head), dwSize);
                                 } else {
                                     FXSYS_memcpy32(buf, head, dwSize);
                                 }
                                 temp = buf;
-                                val = FX_Alloc(FX_BYTE, dwSize / 2);
+                                val = FX_Alloc(uint8_t, dwSize / 2);
                                 if (val == NULL) {
                                     FX_Free(buf);
                                     return FALSE;
                                 }
                                 for(i = 0; i < (int)dwModuleNum; i ++) {
                                     *(FX_DWORD*)temp = m_readDword(temp);
                                     *(FX_DWORD*)(temp + 4) = m_readDword(temp + 4);
                                     FX_DWORD* lNumerator = (FX_DWORD*)temp;
                                     FX_DWORD* lNenominator = (FX_DWORD*)(temp + 4);
                                     *(FX_FLOAT*)(val + i * 4) = (FX_FLOAT)(*lNumerator) / (FX_FLOAT)(*lNenominator);
                                     temp += 8;
                                 }
                                 FX_Free(buf);
                             }
                             break;
                         case FX_DoubleFloat:
                             dwSize = dwModuleNum << 3;
-                            val = FX_Alloc(FX_BYTE, dwSize);
+                            val = FX_Alloc(uint8_t, dwSize);
                             if (val == NULL) {
                                 return FALSE;
                             }
                             if (dwSize > 4) {
                                 FXSYS_memcpy32(val, old_data + m_readDword(head), dwSize);
                             } else {
                                 FXSYS_memcpy32(val, head, dwSize);
                             }
                             buf = val;
                             for(i = 0; i < (int)dwModuleNum; i ++) {
@@ skipping 55 matching lines @@
     virtual void                v_DownScale(int dest_width, int dest_height) {}
     virtual FX_BOOL             v_Rewind();
     virtual FX_LPBYTE   v_GetNextLine();
     virtual FX_DWORD    GetSrcOffset()
     {
         return m_SrcOffset;
     }
 protected:
     FX_BOOL                             CheckDestSize();
     void                                GetNextOperator();
-    void                                UpdateOperator(FX_BYTE used_bytes);
+    void                                UpdateOperator(uint8_t used_bytes);
 
     FX_LPBYTE                   m_pScanline;
     FX_LPCBYTE                  m_pSrcBuf;
     FX_DWORD                    m_SrcSize;
     FX_DWORD                    m_dwLineBytes;
     FX_DWORD                    m_SrcOffset;
     FX_BOOL                             m_bEOD;
-    FX_BYTE                             m_Operator;
+    uint8_t                             m_Operator;
 };
 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
     : m_pScanline(NULL)
     , m_pSrcBuf(NULL)
     , m_SrcSize(0)
     , m_dwLineBytes(0)
     , m_SrcOffset(0)
     , m_bEOD(FALSE)
     , m_Operator(0)
 {
@@ skipping 38 matching lines @@
     m_pSrcBuf = 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_DownScale = 1;
     m_Pitch = (width * nComps * bpc + 31) / 32 * 4;
     m_dwLineBytes = (width * nComps * bpc + 7) / 8;
-    m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
+    m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     return CheckDestSize();
 }
 FX_BOOL CCodec_RLScanlineDecoder::v_Rewind()
 {
     FXSYS_memset32(m_pScanline, 0, m_Pitch);
     m_SrcOffset = 0;
     m_bEOD = FALSE;
     m_Operator = 0;
     return TRUE;
 }
@@ skipping 15 matching lines @@
             if (col_pos + copy_len >= m_dwLineBytes) {
                 copy_len = m_dwLineBytes - col_pos;
                 eol = TRUE;
             }
             if (copy_len >= m_SrcSize - m_SrcOffset) {
                 copy_len = m_SrcSize - m_SrcOffset;
                 m_bEOD = TRUE;
             }
             FXSYS_memcpy32(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
             col_pos += copy_len;
-            UpdateOperator((FX_BYTE)copy_len);
+            UpdateOperator((uint8_t)copy_len);
         } else if (m_Operator > 128) {
             int fill = 0;
             if (m_SrcOffset - 1 < m_SrcSize - 1) {
                 fill = m_pSrcBuf[m_SrcOffset];
             }
             FX_DWORD duplicate_len = 257 - m_Operator;
             if (col_pos + duplicate_len >= m_dwLineBytes) {
                 duplicate_len = m_dwLineBytes - col_pos;
                 eol = TRUE;
             }
             FXSYS_memset8(m_pScanline + col_pos, fill, duplicate_len);
             col_pos += duplicate_len;
-            UpdateOperator((FX_BYTE)duplicate_len);
+            UpdateOperator((uint8_t)duplicate_len);
         } else {
             m_bEOD = TRUE;
             break;
         }
     }
     return m_pScanline;
 }
 void CCodec_RLScanlineDecoder::GetNextOperator()
 {
     if (m_SrcOffset >= m_SrcSize) {
         m_Operator = 128;
         return;
     }
     m_Operator = m_pSrcBuf[m_SrcOffset];
     m_SrcOffset ++;
 }
-void CCodec_RLScanlineDecoder::UpdateOperator(FX_BYTE used_bytes)
+void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes)
 {
     if (used_bytes == 0) {
         return;
     }
     if (m_Operator < 128) {
         FXSYS_assert((FX_DWORD)m_Operator + 1 >= used_bytes);
         if (used_bytes == m_Operator + 1) {
             m_SrcOffset += used_bytes;
             GetNextOperator();
             return;
         }
         m_Operator -= used_bytes;
         m_SrcOffset += used_bytes;
         if (m_SrcOffset >= m_SrcSize) {
             m_Operator = 128;
         }
         return;
     }
-    FX_BYTE count = 257 - m_Operator;
+    uint8_t count = 257 - m_Operator;
     FXSYS_assert((FX_DWORD)count >= used_bytes);
     if (used_bytes == count) {
         m_SrcOffset ++;
         GetNextOperator();
         return;
     }
     count -= used_bytes;
     m_Operator = 257 - count;
 }
 ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc)
 {
     CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder;
     if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps, bpc)) {
         delete pRLScanlineDecoder;
         return NULL;
     }
     return pRLScanlineDecoder;
 }