Remove FX_DWORD from core/ and delete definition

core/fxcodec/jbig2/JBig2_GrdProc.cpp

 // Copyright 2015 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 "core/fxcodec/jbig2/JBig2_GrdProc.h"
 
 #include <memory>
 
@@ skipping 48 matching lines @@
   } else {
     if (UseTemplate23Opt3())
       return decode_Arith_Template3_opt3(pArithDecoder, gbContext);
     return decode_Arith_Template3_unopt(pArithDecoder, gbContext);
   }
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   if (!GBREG->m_pData)
     return nullptr;
 
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
-  FX_DWORD height = GBH & 0x7fffffff;
-  for (FX_DWORD h = 0; h < height; h++) {
+  uint32_t height = GBH & 0x7fffffff;
+  for (uint32_t h = 0; h < height; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       if (h > 1) {
         pLine1 = pLine - nStride2;
         pLine2 = pLine - nStride;
@@ skipping 53 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 2);
       line1 |= GBREG->getPixel(0, h - 2) << 1;
       line2 = GBREG->getPixel(2, h - 1);
       line2 |= GBREG->getPixel(1, h - 1) << 1;
       line2 |= GBREG->getPixel(0, h - 1) << 2;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
           CONTEXT |= line2 << 5;
           CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
           CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
           CONTEXT |= line1 << 12;
           CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
         line3 = ((line3 << 1) | bVal) & 0x0f;
       }
     }
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   if (!GBREG->m_pData)
     return nullptr;
 
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       if (h > 1) {
         pLine1 = pLine - nStride2;
         pLine2 = pLine - nStride;
@@ skipping 53 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(2, h - 2);
       line1 |= GBREG->getPixel(1, h - 2) << 1;
       line1 |= GBREG->getPixel(0, h - 2) << 2;
       line2 = GBREG->getPixel(2, h - 1);
       line2 |= GBREG->getPixel(1, h - 1) << 1;
       line2 |= GBREG->getPixel(0, h - 1) << 2;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
           CONTEXT |= line2 << 4;
           CONTEXT |= line1 << 9;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
         line3 = ((line3 << 1) | bVal) & 0x07;
       }
     }
   }
   return GBREG.release();
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   if (!GBREG->m_pData)
     return nullptr;
 
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       if (h > 1) {
         pLine1 = pLine - nStride2;
         pLine2 = pLine - nStride;
@@ skipping 53 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 2);
       line1 |= GBREG->getPixel(0, h - 2) << 1;
       line2 = GBREG->getPixel(1, h - 1);
       line2 |= GBREG->getPixel(0, h - 1) << 1;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
           CONTEXT |= line2 << 3;
           CONTEXT |= line1 << 7;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x0f;
         line3 = ((line3 << 1) | bVal) & 0x03;
       }
     }
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1;
+  uint32_t CONTEXT;
+  uint32_t line1;
   uint8_t *pLine, *pLine1, cVal;
   int32_t nStride, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   if (!GBREG->m_pData)
     return nullptr;
 
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       if (h > 0) {
         pLine1 = pLine - nStride;
         line1 = *pLine1++;
@@ skipping 40 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG.release();
 }
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   LTP = 0;
   std::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 1);
       line1 |= GBREG->getPixel(0, h - 1) << 1;
       line2 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line2;
           CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
           CONTEXT |= line1 << 5;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
@@ skipping 90 matching lines @@
   if (!(*pImage)->m_pData) {
     delete (*pImage);
     (*pImage) = nullptr;
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return m_ProssiveStatus;
   }
   bitpos = (int)pStream->getBitPos();
   FaxG4Decode(pStream->getBuf(), pStream->getLength(), &bitpos,
               (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride);
   pStream->setBitPos(bitpos);
-  for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) {
+  for (i = 0; (uint32_t)i < (*pImage)->m_nStride * GBH; i++) {
     (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i];
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return m_ProssiveStatus;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) {
   if (m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE)
     return m_ProssiveStatus;
 
   if (m_DecodeType != 1) {
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return m_ProssiveStatus;
   }
 
   return decode_Arith(pPause);
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   if (!m_pLine) {
     m_pLine = pImage->m_pData;
   }
   nStride = pImage->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
-  FX_DWORD height = GBH & 0x7fffffff;
+  uint32_t height = GBH & 0x7fffffff;
   for (; m_loopIndex < height; m_loopIndex++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       pImage->copyLine(m_loopIndex, m_loopIndex - 1);
     } else {
       if (m_loopIndex > 1) {
         pLine1 = m_pLine - nStride2;
@@ skipping 62 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       pImage->copyLine(m_loopIndex, m_loopIndex - 1);
     } else {
       line1 = pImage->getPixel(1, m_loopIndex - 2);
       line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1;
       line2 = pImage->getPixel(2, m_loopIndex - 1);
       line2 |= pImage->getPixel(1, m_loopIndex - 1) << 1;
       line2 |= pImage->getPixel(0, m_loopIndex - 1) << 2;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
           CONTEXT |= line2 << 5;
           CONTEXT |= pImage->getPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;
           CONTEXT |= pImage->getPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;
           CONTEXT |= line1 << 12;
           CONTEXT |= pImage->getPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;
@@ skipping 18 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   if (!m_pLine) {
     m_pLine = pImage->m_pData;
   }
   nStride = pImage->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
@@ skipping 72 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
-  for (FX_DWORD h = 0; h < GBH; h++) {
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
+  for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       pImage->copyLine(h, h - 1);
     } else {
       line1 = pImage->getPixel(2, h - 2);
       line1 |= pImage->getPixel(1, h - 2) << 1;
       line1 |= pImage->getPixel(0, h - 2) << 2;
       line2 = pImage->getPixel(2, h - 1);
       line2 |= pImage->getPixel(1, h - 1) << 1;
       line2 |= pImage->getPixel(0, h - 1) << 2;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= pImage->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
           CONTEXT |= line2 << 4;
           CONTEXT |= line1 << 9;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
@@ skipping 13 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   if (!m_pLine) {
     m_pLine = pImage->m_pData;
   }
   nStride = pImage->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
@@ skipping 72 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2, line3;
+  uint32_t CONTEXT;
+  uint32_t line1, line2, line3;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       pImage->copyLine(m_loopIndex, m_loopIndex - 1);
     } else {
       line1 = pImage->getPixel(1, m_loopIndex - 2);
       line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1;
       line2 = pImage->getPixel(1, m_loopIndex - 1);
       line2 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
       line3 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
           bVal = 0;
         } else {
           CONTEXT = line3;
           CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;
           CONTEXT |= line2 << 3;
           CONTEXT |= line1 << 7;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
@@ skipping 15 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1;
+  uint32_t CONTEXT;
+  uint32_t line1;
   uint8_t *pLine1, cVal;
   int32_t nStride, k;
   int32_t nLineBytes, nBitsLeft, cc;
   if (!m_pLine) {
     m_pLine = pImage->m_pData;
   }
   nStride = pImage->m_nStride;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (; m_loopIndex < GBH; m_loopIndex++) {
@@ skipping 58 matching lines @@
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
-  FX_DWORD CONTEXT;
-  FX_DWORD line1, line2;
+  uint32_t CONTEXT;
+  uint32_t line1, line2;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       pImage->copyLine(m_loopIndex, m_loopIndex - 1);
     } else {
       line1 = pImage->getPixel(1, m_loopIndex - 1);
       line1 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
       line2 = 0;
-      for (FX_DWORD w = 0; w < GBW; w++) {
+      for (uint32_t w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
           bVal = 0;
         } else {
           CONTEXT = line2;
           CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
           CONTEXT |= line1 << 5;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           pImage->setPixel(w, m_loopIndex, bVal);
         }
         line1 =
             ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 1)) & 0x1f;
         line2 = ((line2 << 1) | bVal) & 0x0f;
       }
     }
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }