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

core/src/fxcodec/jbig2/JBig2_Context.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 <map>
 #include <list>
 #include "JBig2_Context.h"
 
 // Implement a very small least recently used (LRU) cache. It is very
 // common for a JBIG2 dictionary to span multiple pages in a PDF file,
 // and we do not want to decode the same dictionary over and over
 // again. We key off of the memory location of the dictionary. The
 // list keeps track of the freshness of entries, with freshest ones
 // at the front. Even a tiny cache size like 2 makes a dramatic
 // difference for typical JBIG2 documents.
 const int kSymbolDictCacheMaxSize = 2;
 
 void OutputBitmap(CJBig2_Image* pImage)
 {
     if(!pImage) {
         return;
     }
 }
-CJBig2_Context *CJBig2_Context::CreateContext(CJBig2_Module *pModule, FX_BYTE *pGlobalData, FX_DWORD dwGlobalLength,
-        FX_BYTE *pData, FX_DWORD dwLength, FX_INT32 nStreamType, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause)
+CJBig2_Context *CJBig2_Context::CreateContext(CJBig2_Module *pModule, uint8_t *pGlobalData, FX_DWORD dwGlobalLength,
+        uint8_t *pData, FX_DWORD dwLength, int32_t nStreamType, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause)
 {
     return new(pModule)CJBig2_Context(pGlobalData, dwGlobalLength, pData, dwLength, nStreamType, pSymbolDictCache, pPause);
 }
 void CJBig2_Context::DestroyContext(CJBig2_Context *pContext)
 {
     if(pContext) {
         delete pContext;
     }
 }
-CJBig2_Context::CJBig2_Context(FX_BYTE *pGlobalData, FX_DWORD dwGlobalLength,
-                               FX_BYTE *pData, FX_DWORD dwLength, FX_INT32 nStreamType, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause)
+CJBig2_Context::CJBig2_Context(uint8_t *pGlobalData, FX_DWORD dwGlobalLength,
+                               uint8_t *pData, FX_DWORD dwLength, int32_t nStreamType, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause)
 {
     if(pGlobalData && (dwGlobalLength > 0)) {
         JBIG2_ALLOC(m_pGlobalContext, CJBig2_Context(NULL, 0, pGlobalData, dwGlobalLength,
                     JBIG2_EMBED_STREAM, pSymbolDictCache, pPause));
     } else {
         m_pGlobalContext = NULL;
     }
     JBIG2_ALLOC(m_pStream, CJBig2_BitStream(pData, dwLength));
     m_nStreamType = nStreamType;
     m_nState = JBIG2_OUT_OF_PAGE;
@@ skipping 40 matching lines @@
     m_pPage = NULL;
     if(m_pStream) {
         delete m_pStream;
     }
     m_pStream = NULL;
     if(m_pSegmentList) {
         delete m_pSegmentList;
     }
     m_pSegmentList = NULL;
 }
-FX_INT32 CJBig2_Context::decodeFile(IFX_Pause* pPause)
+int32_t CJBig2_Context::decodeFile(IFX_Pause* pPause)
 {
-    FX_BYTE cFlags;
+    uint8_t cFlags;
     FX_DWORD dwTemp;
-    const FX_BYTE fileID[] = {0x97, 0x4A, 0x42, 0x32, 0x0D, 0x0A, 0x1A, 0x0A};
-    FX_INT32 nRet;
+    const uint8_t fileID[] = {0x97, 0x4A, 0x42, 0x32, 0x0D, 0x0A, 0x1A, 0x0A};
+    int32_t nRet;
     if(m_pStream->getByteLeft() < 8) {
         m_pModule->JBig2_Error("file header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
         goto failed;
     }
     if(JBIG2_memcmp(m_pStream->getPointer(), fileID, 8) != 0) {
         m_pModule->JBig2_Error("not jbig2 file");
         nRet = JBIG2_ERROR_FILE_FORMAT;
         goto failed;
     }
@@ skipping 17 matching lines @@
     if(cFlags & 0x01) {
         m_nStreamType = JBIG2_SQUENTIAL_STREAM;
         return decode_SquentialOrgnazation(pPause);
     } else {
         m_nStreamType = JBIG2_RANDOM_STREAM;
         return decode_RandomOrgnazation_FirstPage(pPause);
     }
 failed:
     return nRet;
 }
-FX_INT32 CJBig2_Context::decode_SquentialOrgnazation(IFX_Pause* pPause)
+int32_t CJBig2_Context::decode_SquentialOrgnazation(IFX_Pause* pPause)
 {
-    FX_INT32 nRet;
+    int32_t nRet;
     if(m_pStream->getByteLeft() > 0) {
         while(m_pStream->getByteLeft() >= JBIG2_MIN_SEGMENT_SIZE) {
             if(m_pSegment == NULL) {
                 JBIG2_ALLOC(m_pSegment, CJBig2_Segment());
                 nRet = parseSegmentHeader(m_pSegment);
                 if(nRet != JBIG2_SUCCESS) {
                     delete m_pSegment;
                     m_pSegment = NULL;
                     return nRet;
                 }
@@ skipping 27 matching lines @@
                 m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
                 m_PauseStep = 2;
                 return JBIG2_SUCCESS;
             }
         }
     } else {
         return JBIG2_END_OF_FILE;
     }
     return JBIG2_SUCCESS;
 }
-FX_INT32 CJBig2_Context::decode_EmbedOrgnazation(IFX_Pause* pPause)
+int32_t CJBig2_Context::decode_EmbedOrgnazation(IFX_Pause* pPause)
 {
     return decode_SquentialOrgnazation(pPause);
 }
-FX_INT32 CJBig2_Context::decode_RandomOrgnazation_FirstPage(IFX_Pause* pPause)
+int32_t CJBig2_Context::decode_RandomOrgnazation_FirstPage(IFX_Pause* pPause)
 {
     CJBig2_Segment *pSegment;
-    FX_INT32 nRet;
+    int32_t nRet;
     while(m_pStream->getByteLeft() > JBIG2_MIN_SEGMENT_SIZE) {
         JBIG2_ALLOC(pSegment, CJBig2_Segment());
         nRet = parseSegmentHeader(pSegment);
         if(nRet != JBIG2_SUCCESS) {
             delete pSegment;
             return nRet;
         } else if(pSegment->m_cFlags.s.type == 51) {
             delete pSegment;
             break;
         }
         m_pSegmentList->addItem(pSegment);
         if(pPause && m_pPause && pPause->NeedToPauseNow()) {
             m_PauseStep = 3;
             m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
             return JBIG2_SUCCESS;
         }
     }
     m_nSegmentDecoded = 0;
     return decode_RandomOrgnazation(pPause);
 }
-FX_INT32 CJBig2_Context::decode_RandomOrgnazation(IFX_Pause* pPause)
+int32_t CJBig2_Context::decode_RandomOrgnazation(IFX_Pause* pPause)
 {
-    FX_INT32 nRet;
+    int32_t nRet;
     for(; m_nSegmentDecoded < m_pSegmentList->getLength(); m_nSegmentDecoded++) {
         nRet = parseSegmentData(m_pSegmentList->getAt(m_nSegmentDecoded), pPause);
         if((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE)) {
             break;
         } else if(nRet != JBIG2_SUCCESS) {
             return nRet;
         }
         if(m_pPage && pPause && pPause->NeedToPauseNow()) {
             m_PauseStep = 4;
             m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
             return JBIG2_SUCCESS;
         }
     }
     return JBIG2_SUCCESS;
 }
-FX_INT32 CJBig2_Context::getFirstPage(FX_BYTE *pBuf, FX_INT32 width, FX_INT32 height, FX_INT32 stride, IFX_Pause* pPause)
+int32_t CJBig2_Context::getFirstPage(uint8_t *pBuf, int32_t width, int32_t height, int32_t stride, IFX_Pause* pPause)
 {
-    FX_INT32 nRet = 0;
+    int32_t nRet = 0;
     if(m_pGlobalContext) {
         nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
         if(nRet != JBIG2_SUCCESS) {
             m_ProcessiveStatus = FXCODEC_STATUS_ERROR;
             return nRet;
         }
     }
     m_bFirstPage = TRUE;
     m_PauseStep = 0;
     if(m_pPage) {
         delete m_pPage;
     }
     JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf));
     m_bBufSpecified = TRUE;
     if(m_pPage && pPause && pPause->NeedToPauseNow()) {
         m_PauseStep = 1;
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         return nRet;
     }
     int ret = Continue(pPause);
     return ret;
 }
-FX_INT32 CJBig2_Context::Continue(IFX_Pause* pPause)
+int32_t CJBig2_Context::Continue(IFX_Pause* pPause)
 {
     m_ProcessiveStatus = FXCODEC_STATUS_DECODE_READY;
-    FX_INT32 nRet;
+    int32_t nRet;
     if(m_PauseStep <= 1) {
         switch(m_nStreamType) {
             case JBIG2_FILE_STREAM:
                 nRet = decodeFile(pPause);
                 break;
             case JBIG2_SQUENTIAL_STREAM:
                 nRet = decode_SquentialOrgnazation(pPause);
                 break;
             case JBIG2_RANDOM_STREAM:
                 if(m_bFirstPage) {
@@ skipping 27 matching lines @@
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_FINISH;
         return JBIG2_SUCCESS;
     }
     if(nRet == JBIG2_SUCCESS) {
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_FINISH;
     } else {
         m_ProcessiveStatus = FXCODEC_STATUS_ERROR;
     }
     return nRet;
 }
-FX_INT32 CJBig2_Context::getNextPage(FX_BYTE *pBuf, FX_INT32 width, FX_INT32 height, FX_INT32 stride, IFX_Pause* pPause)
+int32_t CJBig2_Context::getNextPage(uint8_t *pBuf, int32_t width, int32_t height, int32_t stride, IFX_Pause* pPause)
 {
-    FX_INT32 nRet = JBIG2_ERROR_STREAM_TYPE;
+    int32_t nRet = JBIG2_ERROR_STREAM_TYPE;
     m_bFirstPage = FALSE;
     m_PauseStep = 0;
     if(m_pPage) {
         delete m_pPage;
     }
     JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf));
     m_bBufSpecified = TRUE;
     if(m_pPage && pPause && pPause->NeedToPauseNow()) {
         m_PauseStep = 1;
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
@@ skipping 11 matching lines @@
             nRet = decode_RandomOrgnazation(pPause);
             break;
         case JBIG2_EMBED_STREAM:
             nRet = decode_EmbedOrgnazation(pPause);
             break;
         default:
             return JBIG2_ERROR_STREAM_TYPE;
     }
     return nRet;
 }
-FX_INT32 CJBig2_Context::getFirstPage(CJBig2_Image **image, IFX_Pause* pPause)
+int32_t CJBig2_Context::getFirstPage(CJBig2_Image **image, IFX_Pause* pPause)
 {
-    FX_INT32 nRet;
+    int32_t nRet;
     m_bFirstPage = TRUE;
     m_PauseStep = 0;
     if(m_pGlobalContext) {
         nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
         if(nRet != JBIG2_SUCCESS) {
             return nRet;
         }
     }
     m_bBufSpecified = FALSE;
     return Continue(pPause);
 }
-FX_INT32 CJBig2_Context::getNextPage(CJBig2_Image **image, IFX_Pause* pPause)
+int32_t CJBig2_Context::getNextPage(CJBig2_Image **image, IFX_Pause* pPause)
 {
-    FX_INT32 nRet;
+    int32_t nRet;
     m_bBufSpecified = FALSE;
     m_bFirstPage = FALSE;
     m_PauseStep = 0;
     switch(m_nStreamType) {
         case JBIG2_FILE_STREAM:
             nRet = decodeFile(pPause);
             break;
         case JBIG2_SQUENTIAL_STREAM:
             nRet = decode_SquentialOrgnazation(pPause);
             break;
         case JBIG2_RANDOM_STREAM:
             nRet = decode_RandomOrgnazation(pPause);
             break;
         case JBIG2_EMBED_STREAM:
             nRet = decode_EmbedOrgnazation(pPause);
             break;
         default:
             return JBIG2_ERROR_STREAM_TYPE;
     }
     if(nRet == JBIG2_SUCCESS) {
         *image = m_pPage;
         m_pPage = NULL;
         return JBIG2_SUCCESS;
     }
     return nRet;
 }
 CJBig2_Segment *CJBig2_Context::findSegmentByNumber(FX_DWORD dwNumber)
 {
     CJBig2_Segment *pSeg;
-    FX_INT32 i;
+    int32_t i;
     if(m_pGlobalContext) {
         pSeg = m_pGlobalContext->findSegmentByNumber(dwNumber);
         if(pSeg) {
             return pSeg;
         }
     }
     for(i = 0; i < m_pSegmentList->getLength(); i++) {
         pSeg = m_pSegmentList->getAt(i);
         if(pSeg->m_dwNumber == dwNumber) {
             return pSeg;
         }
     }
     return NULL;
 }
 CJBig2_Segment *CJBig2_Context::findReferredSegmentByTypeAndIndex(CJBig2_Segment *pSegment,
-        FX_BYTE cType, FX_INT32 nIndex)
+        uint8_t cType, int32_t nIndex)
 {
     CJBig2_Segment *pSeg;
-    FX_INT32 i, count;
+    int32_t i, count;
     count = 0;
     for(i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
         pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
         if(pSeg && pSeg->m_cFlags.s.type == cType) {
             if(count == nIndex) {
                 return pSeg;
             } else {
                 count ++;
             }
         }
     }
     return NULL;
 }
-FX_INT32 CJBig2_Context::parseSegmentHeader(CJBig2_Segment *pSegment)
+int32_t CJBig2_Context::parseSegmentHeader(CJBig2_Segment *pSegment)
 {
-    FX_BYTE  cSSize, cPSize;
-    FX_BYTE cTemp;
+    uint8_t  cSSize, cPSize;
+    uint8_t cTemp;
     FX_WORD wTemp;
     FX_DWORD dwTemp;
     if((m_pStream->readInteger(&pSegment->m_dwNumber) != 0)
             || (m_pStream->read1Byte(&pSegment->m_cFlags.c) != 0)) {
         goto failed;
     }
     cTemp = m_pStream->getCurByte();
     if((cTemp >> 5) == 7) {
         if(m_pStream->readInteger((FX_DWORD*)&pSegment->m_nReferred_to_segment_count) != 0) {
             goto failed;
         }
         pSegment->m_nReferred_to_segment_count &= 0x1fffffff;
         if (pSegment->m_nReferred_to_segment_count > JBIG2_MAX_REFERRED_SEGMENT_COUNT) {
             m_pModule->JBig2_Error("Too many referred segments.");
             return JBIG2_ERROR_LIMIT;
         }
         dwTemp = 5 + 4 + (pSegment->m_nReferred_to_segment_count + 1) / 8;
     } else {
         if(m_pStream->read1Byte(&cTemp) != 0) {
             goto failed;
         }
         pSegment->m_nReferred_to_segment_count = cTemp >> 5;
         dwTemp = 5 + 1;
     }
     cSSize = pSegment->m_dwNumber > 65536 ? 4 : pSegment->m_dwNumber > 256 ? 2 : 1;
     cPSize = pSegment->m_cFlags.s.page_association_size ? 4 : 1;
     if(pSegment->m_nReferred_to_segment_count) {
         pSegment->m_pReferred_to_segment_numbers = (FX_DWORD*)m_pModule->JBig2_Malloc2(
                     sizeof(FX_DWORD), pSegment->m_nReferred_to_segment_count);
-        for(FX_INT32 i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
+        for(int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
             switch(cSSize) {
                 case 1:
                     if(m_pStream->read1Byte(&cTemp) != 0) {
                         goto failed;
                     }
                     pSegment->m_pReferred_to_segment_numbers[i] = cTemp;
                     break;
                 case 2:
                     if(m_pStream->readShortInteger(&wTemp) != 0) {
                         goto failed;
@@ skipping 26 matching lines @@
     if(m_pStream->readInteger(&pSegment->m_dwData_length) != 0) {
         goto failed;
     }
     pSegment->m_pData = m_pStream->getPointer();
     pSegment->m_State = JBIG2_SEGMENT_DATA_UNPARSED;
     return JBIG2_SUCCESS;
 failed:
     m_pModule->JBig2_Error("header too short.");
     return JBIG2_ERROR_TOO_SHORT;
 }
-FX_INT32 CJBig2_Context::parseSegmentData(CJBig2_Segment *pSegment, IFX_Pause* pPause)
+int32_t CJBig2_Context::parseSegmentData(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
-    FX_INT32 ret = ProcessiveParseSegmentData(pSegment, pPause);
+    int32_t ret = ProcessiveParseSegmentData(pSegment, pPause);
     while(m_ProcessiveStatus  == FXCODEC_STATUS_DECODE_TOBECONTINUE && m_pStream->getByteLeft() > 0) {
         ret = ProcessiveParseSegmentData(pSegment, pPause);
     }
     return ret;
 }
-FX_INT32 CJBig2_Context::ProcessiveParseSegmentData(CJBig2_Segment *pSegment, IFX_Pause* pPause)
+int32_t CJBig2_Context::ProcessiveParseSegmentData(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
     switch(pSegment->m_cFlags.s.type) {
         case 0:
             return parseSymbolDict(pSegment, pPause);
         case 4:
         case 6:
         case 7:
             if(m_nState == JBIG2_OUT_OF_PAGE) {
                 goto failed2;
             } else {
@@ skipping 80 matching lines @@
             break;
     }
     return JBIG2_SUCCESS;
 failed1:
     m_pModule->JBig2_Error("segment data too short.");
     return JBIG2_ERROR_TOO_SHORT;
 failed2:
     m_pModule->JBig2_Error("segment syntax error.");
     return JBIG2_ERROR_FETAL;
 }
-FX_INT32 CJBig2_Context::parseSymbolDict(CJBig2_Segment *pSegment, IFX_Pause* pPause)
+int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
     FX_DWORD dwTemp;
     FX_WORD wFlags;
-    FX_BYTE cSDHUFFDH, cSDHUFFDW, cSDHUFFBMSIZE, cSDHUFFAGGINST;
+    uint8_t cSDHUFFDH, cSDHUFFDW, cSDHUFFBMSIZE, cSDHUFFAGGINST;
     CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B2 = NULL, *Table_B3 = NULL, *Table_B4 = NULL, *Table_B5 = NULL;
-    FX_INT32 i, nIndex, nRet;
+    int32_t i, nIndex, nRet;
     CJBig2_Segment *pSeg = NULL, *pLRSeg = NULL;
     FX_BOOL bUsed;
     CJBig2_Image ** SDINSYMS = NULL;
     CJBig2_SDDProc *pSymbolDictDecoder;
     JBig2ArithCtx *gbContext = NULL, *grContext = NULL;
     CJBig2_ArithDecoder *pArithDecoder;
     JBIG2_ALLOC(pSymbolDictDecoder, CJBig2_SDDProc());
-    FX_BYTE *key = pSegment->m_pData;
+    uint8_t *key = pSegment->m_pData;
     FX_BOOL cache_hit = false;
     if(m_pStream->readShortInteger(&wFlags) != 0) {
         m_pModule->JBig2_Error("symbol dictionary segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
         goto failed;
     }
     pSymbolDictDecoder->SDHUFF = wFlags & 0x0001;
     pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001;
     pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003;
     pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003;
     cSDHUFFDH = (wFlags >> 2) & 0x0003;
     cSDHUFFDW = (wFlags >> 4) & 0x0003;
     cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001;
     cSDHUFFAGGINST = (wFlags >> 7) & 0x0001;
     if(pSymbolDictDecoder->SDHUFF == 0) {
         if(pSymbolDictDecoder->SDTEMPLATE == 0) {
             dwTemp = 8;
         } else {
             dwTemp = 2;
         }
-        for(i = 0; i < (FX_INT32)dwTemp; i++) {
-            if(m_pStream->read1Byte((FX_BYTE*)&pSymbolDictDecoder->SDAT[i]) != 0) {
+        for(i = 0; i < (int32_t)dwTemp; i++) {
+            if(m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDAT[i]) != 0) {
                 m_pModule->JBig2_Error("symbol dictionary segment : data header too short.");
                 nRet = JBIG2_ERROR_TOO_SHORT;
                 goto failed;
             }
         }
     }
     if((pSymbolDictDecoder->SDREFAGG == 1) && (pSymbolDictDecoder->SDRTEMPLATE == 0)) {
         for(i = 0; i < 4; i++) {
-            if(m_pStream->read1Byte((FX_BYTE*)&pSymbolDictDecoder->SDRAT[i]) != 0) {
+            if(m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDRAT[i]) != 0) {
                 m_pModule->JBig2_Error("symbol dictionary segment : data header too short.");
                 nRet = JBIG2_ERROR_TOO_SHORT;
                 goto failed;
             }
         }
     }
     if((m_pStream->readInteger(&pSymbolDictDecoder->SDNUMEXSYMS) != 0)
             || (m_pStream->readInteger(&pSymbolDictDecoder->SDNUMNEWSYMS) != 0)) {
         m_pModule->JBig2_Error("symbol dictionary segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
@@ skipping 238 matching lines @@
     if(grContext) {
         m_pModule->JBig2_Free(grContext);
     }
     return nRet;
 }
 
 FX_BOOL CJBig2_Context::parseTextRegion(CJBig2_Segment *pSegment)
 {
     FX_DWORD dwTemp;
     FX_WORD wFlags;
-    FX_INT32 i, nIndex, nRet;
+    int32_t i, nIndex, nRet;
     JBig2RegionInfo ri;
     CJBig2_Segment *pSeg;
     CJBig2_Image **SBSYMS = NULL;
     JBig2HuffmanCode *SBSYMCODES = NULL;
-    FX_BYTE cSBHUFFFS, cSBHUFFDS, cSBHUFFDT, cSBHUFFRDW, cSBHUFFRDH, cSBHUFFRDX, cSBHUFFRDY, cSBHUFFRSIZE;
+    uint8_t cSBHUFFFS, cSBHUFFDS, cSBHUFFDT, cSBHUFFRDW, cSBHUFFRDH, cSBHUFFRDX, cSBHUFFRDY, cSBHUFFRSIZE;
     CJBig2_HuffmanTable *Table_B1 = NULL,
                          *Table_B6 = NULL,
                           *Table_B7 = NULL,
                            *Table_B8 = NULL,
                             *Table_B9 = NULL,
                              *Table_B10 = NULL,
                               *Table_B11 = NULL,
                                *Table_B12 = NULL,
                                 *Table_B13 = NULL,
                                  *Table_B14 = NULL,
@@ skipping 33 matching lines @@
         cSBHUFFDS = (wFlags >> 2) & 0x0003;
         cSBHUFFDT = (wFlags >> 4) & 0x0003;
         cSBHUFFRDW = (wFlags >> 6) & 0x0003;
         cSBHUFFRDH = (wFlags >> 8) & 0x0003;
         cSBHUFFRDX = (wFlags >> 10) & 0x0003;
         cSBHUFFRDY = (wFlags >> 12) & 0x0003;
         cSBHUFFRSIZE = (wFlags >> 14) & 0x0001;
     }
     if((pTRD->SBREFINE == 1) && (pTRD->SBRTEMPLATE == 0)) {
         for(i = 0; i < 4; i++) {
-            if(m_pStream->read1Byte((FX_BYTE*)&pTRD->SBRAT[i]) != 0) {
+            if(m_pStream->read1Byte((uint8_t*)&pTRD->SBRAT[i]) != 0) {
                 m_pModule->JBig2_Error("text region segment : data header too short.");
                 nRet = JBIG2_ERROR_TOO_SHORT;
                 goto failed;
             }
         }
     }
     if(m_pStream->readInteger(&pTRD->SBNUMINSTANCES) != 0) {
         m_pModule->JBig2_Error("text region segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
         goto failed;
@@ skipping 35 matching lines @@
             nRet = JBIG2_ERROR_FETAL;
             goto failed;
         }
         m_pStream->alignByte();
         pTRD->SBSYMCODES = SBSYMCODES;
     } else {
         dwTemp = 0;
         while((FX_DWORD)(1 << dwTemp) < pTRD->SBNUMSYMS) {
             dwTemp ++;
         }
-        pTRD->SBSYMCODELEN = (FX_BYTE)dwTemp;
+        pTRD->SBSYMCODELEN = (uint8_t)dwTemp;
     }
     if(pTRD->SBHUFF == 1) {
         if((cSBHUFFFS == 2) || (cSBHUFFRDW == 2) || (cSBHUFFRDH == 2)
                 || (cSBHUFFRDX == 2) || (cSBHUFFRDY == 2)) {
             m_pModule->JBig2_Error("text region segment : SBHUFFFS=2 or SBHUFFRDW=2 or "
                                    "SBHUFFRDH=2 or SBHUFFRDX=2 or SBHUFFRDY=2 is not permitted");
             nRet = JBIG2_ERROR_FETAL;
             goto failed;
         }
         nIndex = 0;
@@ skipping 273 matching lines @@
     }
     if(Table_B15) {
         delete Table_B15;
     }
     return nRet;
 }
 
 FX_BOOL CJBig2_Context::parsePatternDict(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
     FX_DWORD dwTemp;
-    FX_BYTE cFlags;
+    uint8_t cFlags;
     JBig2ArithCtx *gbContext;
     CJBig2_ArithDecoder *pArithDecoder;
     CJBig2_PDDProc *pPDD;
-    FX_INT32 nRet;
+    int32_t nRet;
     JBIG2_ALLOC(pPDD, CJBig2_PDDProc());
     if((m_pStream->read1Byte(&cFlags) != 0)
             || (m_pStream->read1Byte(&pPDD->HDPW) != 0)
             || (m_pStream->read1Byte(&pPDD->HDPH) != 0)
             || (m_pStream->readInteger(&pPDD->GRAYMAX) != 0)) {
         m_pModule->JBig2_Error("pattern dictionary segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
         goto failed;
     }
     if (pPDD->GRAYMAX > JBIG2_MAX_PATTERN_INDEX) {
@@ skipping 29 matching lines @@
     }
     delete pPDD;
     return JBIG2_SUCCESS;
 failed:
     delete pPDD;
     return nRet;
 }
 FX_BOOL CJBig2_Context::parseHalftoneRegion(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
     FX_DWORD dwTemp;
-    FX_BYTE cFlags;
+    uint8_t cFlags;
     JBig2RegionInfo ri;
     CJBig2_Segment *pSeg;
     CJBig2_PatternDict *pPatternDict;
     JBig2ArithCtx *gbContext;
     CJBig2_ArithDecoder *pArithDecoder;
     CJBig2_HTRDProc *pHRD;
-    FX_INT32 nRet;
+    int32_t nRet;
     JBIG2_ALLOC(pHRD, CJBig2_HTRDProc());
     if((parseRegionInfo(&ri) != JBIG2_SUCCESS)
             || (m_pStream->read1Byte(&cFlags) != 0)
             || (m_pStream->readInteger(&pHRD->HGW) != 0)
             || (m_pStream->readInteger(&pHRD->HGH) != 0)
             || (m_pStream->readInteger((FX_DWORD*)&pHRD->HGX) != 0)
             || (m_pStream->readInteger((FX_DWORD*)&pHRD->HGY) != 0)
             || (m_pStream->readShortInteger(&pHRD->HRX) != 0)
             || (m_pStream->readShortInteger(&pHRD->HRY) != 0)) {
         m_pModule->JBig2_Error("halftone region segment : data header too short.");
@@ skipping 66 matching lines @@
     delete pHRD;
     return JBIG2_SUCCESS;
 failed:
     delete pHRD;
     return nRet;
 }
 
 FX_BOOL CJBig2_Context::parseGenericRegion(CJBig2_Segment *pSegment, IFX_Pause* pPause)
 {
     FX_DWORD dwTemp;
-    FX_BYTE cFlags;
-    FX_INT32 i, nRet;
+    uint8_t cFlags;
+    int32_t i, nRet;
     if(m_pGRD == NULL) {
         JBIG2_ALLOC(m_pGRD, CJBig2_GRDProc());
         if((parseRegionInfo(&m_ri) != JBIG2_SUCCESS)
                 || (m_pStream->read1Byte(&cFlags) != 0)) {
             m_pModule->JBig2_Error("generic region segment : data header too short.");
             nRet = JBIG2_ERROR_TOO_SHORT;
             goto failed;
         }
         if (m_ri.height < 0 || m_ri.width < 0) {
             m_pModule->JBig2_Error("generic region segment : wrong data.");
             nRet = JBIG2_FAILED;
             goto failed;
         }
         m_pGRD->GBW = m_ri.width;
         m_pGRD->GBH = m_ri.height;
         m_pGRD->MMR = cFlags & 0x01;
         m_pGRD->GBTEMPLATE = (cFlags >> 1) & 0x03;
         m_pGRD->TPGDON = (cFlags >> 3) & 0x01;
         if(m_pGRD->MMR == 0) {
             if(m_pGRD->GBTEMPLATE == 0) {
                 for(i = 0; i < 8; i++) {
-                    if(m_pStream->read1Byte((FX_BYTE*)&m_pGRD->GBAT[i]) != 0) {
+                    if(m_pStream->read1Byte((uint8_t*)&m_pGRD->GBAT[i]) != 0) {
                         m_pModule->JBig2_Error("generic region segment : data header too short.");
                         nRet = JBIG2_ERROR_TOO_SHORT;
                         goto failed;
                     }
                 }
             } else {
                 for(i = 0; i < 2; i++) {
-                    if(m_pStream->read1Byte((FX_BYTE*)&m_pGRD->GBAT[i]) != 0) {
+                    if(m_pStream->read1Byte((uint8_t*)&m_pGRD->GBAT[i]) != 0) {
                         m_pModule->JBig2_Error("generic region segment : data header too short.");
                         nRet = JBIG2_ERROR_TOO_SHORT;
                         goto failed;
                     }
                 }
             }
         }
         m_pGRD->USESKIP = 0;
     }
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
@@ skipping 67 matching lines @@
     delete m_pGRD;
     m_pGRD = NULL;
     return nRet;
 }
 
 FX_BOOL CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment *pSegment)
 {
     FX_DWORD dwTemp;
     JBig2RegionInfo ri;
     CJBig2_Segment *pSeg;
-    FX_INT32 i, nRet;
-    FX_BYTE cFlags;
+    int32_t i, nRet;
+    uint8_t cFlags;
     JBig2ArithCtx *grContext;
     CJBig2_GRRDProc *pGRRD;
     CJBig2_ArithDecoder *pArithDecoder;
     JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
     if((parseRegionInfo(&ri) != JBIG2_SUCCESS)
             || (m_pStream->read1Byte(&cFlags) != 0)) {
         m_pModule->JBig2_Error("generic refinement region segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
         goto failed;
     }
     pGRRD->GRW = ri.width;
     pGRRD->GRH = ri.height;
     pGRRD->GRTEMPLATE = cFlags & 0x01;
     pGRRD->TPGRON = (cFlags >> 1) & 0x01;
     if(pGRRD->GRTEMPLATE == 0) {
         for(i = 0; i < 4; i++) {
-            if(m_pStream->read1Byte((FX_BYTE*)&pGRRD->GRAT[i]) != 0) {
+            if(m_pStream->read1Byte((uint8_t*)&pGRRD->GRAT[i]) != 0) {
                 m_pModule->JBig2_Error("generic refinement region segment : data header too short.");
                 nRet = JBIG2_ERROR_TOO_SHORT;
                 goto failed;
             }
         }
     }
     pSeg = NULL;
     if(pSegment->m_nReferred_to_segment_count > 0) {
         for(i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
             pSeg = this->findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]);
@@ skipping 55 matching lines @@
     pSegment->m_nResultType = JBIG2_HUFFMAN_TABLE_POINTER;
     JBIG2_ALLOC(pSegment->m_Result.ht, CJBig2_HuffmanTable(m_pStream));
     if(!pSegment->m_Result.ht->isOK()) {
         delete pSegment->m_Result.ht;
         pSegment->m_Result.ht = NULL;
         return JBIG2_ERROR_FETAL;
     }
     m_pStream->alignByte();
     return JBIG2_SUCCESS;
 }
-FX_INT32 CJBig2_Context::parseRegionInfo(JBig2RegionInfo *pRI)
+int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo *pRI)
 {
     if((m_pStream->readInteger((FX_DWORD*)&pRI->width) != 0)
             || (m_pStream->readInteger((FX_DWORD*)&pRI->height) != 0)
             || (m_pStream->readInteger((FX_DWORD*)&pRI->x) != 0)
             || (m_pStream->readInteger((FX_DWORD*)&pRI->y) != 0)
             || (m_pStream->read1Byte(&pRI->flags) != 0)) {
         return JBIG2_ERROR_TOO_SHORT;
     }
     return JBIG2_SUCCESS;
 }
 JBig2HuffmanCode *CJBig2_Context::decodeSymbolIDHuffmanTable(CJBig2_BitStream *pStream,
         FX_DWORD SBNUMSYMS)
 {
     JBig2HuffmanCode *SBSYMCODES;
-    FX_INT32 runcodes[35], runcodes_len[35], runcode;
-    FX_INT32 i, j, nTemp, nVal, nBits;
-    FX_INT32 run;
+    int32_t runcodes[35], runcodes_len[35], runcode;
+    int32_t i, j, nTemp, nVal, nBits;
+    int32_t run;
     SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(sizeof(JBig2HuffmanCode), SBNUMSYMS);
     for (i = 0; i < 35; i ++) {
         if(pStream->readNBits(4, &runcodes_len[i]) != 0) {
             goto failed;
         }
     }
     huffman_assign_code(runcodes, runcodes_len, 35);
     i = 0;
     while(i < (int)SBNUMSYMS) {
         nVal = 0;
@@ skipping 120 matching lines @@
                 SBSYMCODES[CURTEMP].code = CURCODE;
                 CURCODE = CURCODE + 1;
             }
             CURTEMP = CURTEMP + 1;
         }
         CURLEN = CURLEN + 1;
     }
     m_pModule->JBig2_Free(LENCOUNT);
     m_pModule->JBig2_Free(FIRSTCODE);
 }