Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec_progress.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 "core/fxcodec/codec/fx_codec_progress.h"
 
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_dib.h"
@@ skipping 278 matching lines @@
   if (m_pTiffContext) {
     m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
   }
   FX_Free(m_pSrcBuf);
   FX_Free(m_pDecodeBuf);
   FX_Free(m_pSrcPalette);
 }
 FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
     ICodec_JpegModule* pJpegModule,
     FXCODEC_STATUS& err_status) {
-  FX_DWORD dwSize = (FX_DWORD)m_pFile->GetSize();
+  uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  FX_DWORD dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, NULL);
+  uint32_t dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
     }
   } else {
-    FX_DWORD dwConsume = m_SrcSize - dwAvail;
+    uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memcpy(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
     return FALSE;
@@ skipping 82 matching lines @@
       switch (pDIBitmap->GetFormat()) {
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
           ASSERT(FALSE);
           return FALSE;
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb: {
           if (pDIBitmap->GetPalette()) {
             return FALSE;
           }
-          FX_DWORD des_g = 0;
+          uint32_t des_g = 0;
           des_g += pPixelWeights->m_Weights[0] * src_scan[src_col];
           des_scan[pPixelWeights->m_SrcStart] = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
-          FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+          uint32_t des_b = 0, des_g = 0, des_r = 0;
           const uint8_t* p = src_scan + src_col * src_Bpp;
           des_b += pPixelWeights->m_Weights[0] * (*p++);
           des_g += pPixelWeights->m_Weights[0] * (*p++);
           des_r += pPixelWeights->m_Weights[0] * (*p);
           uint8_t* pDes = &des_scan[pPixelWeights->m_SrcStart * des_Bpp];
           *pDes++ = (uint8_t)((des_b) >> 16);
           *pDes++ = (uint8_t)((des_g) >> 16);
           *pDes = (uint8_t)((des_r) >> 16);
         } break;
         case FXDIB_Argb: {
-          FX_DWORD des_r = 0, des_g = 0, des_b = 0;
+          uint32_t des_r = 0, des_g = 0, des_b = 0;
           const uint8_t* p = src_scan + src_col * src_Bpp;
           des_b += pPixelWeights->m_Weights[0] * (*p++);
           des_g += pPixelWeights->m_Weights[0] * (*p++);
           des_r += pPixelWeights->m_Weights[0] * (*p++);
           uint8_t* pDes = &des_scan[pPixelWeights->m_SrcStart * des_Bpp];
           *pDes++ = (uint8_t)((des_b) >> 16);
           *pDes++ = (uint8_t)((des_g) >> 16);
           *pDes++ = (uint8_t)((des_r) >> 16);
           *pDes = *p;
         } break;
@@ skipping 21 matching lines @@
     switch (pDeviceBitmap->GetFormat()) {
       case FXDIB_1bppMask:
       case FXDIB_1bppRgb:
         ASSERT(FALSE);
         return;
       case FXDIB_8bppMask:
       case FXDIB_8bppRgb: {
         if (pDeviceBitmap->GetPalette()) {
           return;
         }
-        FX_DWORD des_g = 0;
+        uint32_t des_g = 0;
         des_g +=
             pPixelWeights->m_Weights[0] * src_scan[pPixelWeights->m_SrcStart];
         des_g +=
             pPixelWeights->m_Weights[1] * src_scan[pPixelWeights->m_SrcEnd];
         *des_scan++ = (uint8_t)(des_g >> 16);
       } break;
       case FXDIB_Rgb:
       case FXDIB_Rgb32: {
-        FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_b = 0, des_g = 0, des_r = 0;
         const uint8_t* p = src_scan;
         p = src_scan + pPixelWeights->m_SrcStart * src_Bpp;
         des_b += pPixelWeights->m_Weights[0] * (*p++);
         des_g += pPixelWeights->m_Weights[0] * (*p++);
         des_r += pPixelWeights->m_Weights[0] * (*p);
         p = src_scan + pPixelWeights->m_SrcEnd * src_Bpp;
         des_b += pPixelWeights->m_Weights[1] * (*p++);
         des_g += pPixelWeights->m_Weights[1] * (*p++);
         des_r += pPixelWeights->m_Weights[1] * (*p);
         *des_scan++ = (uint8_t)((des_b) >> 16);
         *des_scan++ = (uint8_t)((des_g) >> 16);
         *des_scan++ = (uint8_t)((des_r) >> 16);
         des_scan += des_Bpp - 3;
       } break;
       case FXDIB_Argb: {
-        FX_DWORD des_a = 0, des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_a = 0, des_b = 0, des_g = 0, des_r = 0;
         const uint8_t* p = src_scan;
         p = src_scan + pPixelWeights->m_SrcStart * src_Bpp;
         des_b += pPixelWeights->m_Weights[0] * (*p++);
         des_g += pPixelWeights->m_Weights[0] * (*p++);
         des_r += pPixelWeights->m_Weights[0] * (*p++);
         des_a += pPixelWeights->m_Weights[0] * (*p);
         p = src_scan + pPixelWeights->m_SrcEnd * src_Bpp;
         des_b += pPixelWeights->m_Weights[1] * (*p++);
         des_g += pPixelWeights->m_Weights[1] * (*p++);
         des_r += pPixelWeights->m_Weights[1] * (*p++);
@@ skipping 32 matching lines @@
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
       return;
     }
     if (pass == 6 && scale_y > 1.0) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
     }
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(ICodec_GifModule* pGifModule,
                                                    FXCODEC_STATUS& err_status) {
-  FX_DWORD dwSize = (FX_DWORD)m_pFile->GetSize();
+  uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  FX_DWORD dwAvail = pGifModule->GetAvailInput(m_pGifContext, NULL);
+  uint32_t dwAvail = pGifModule->GetAvailInput(m_pGifContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
     }
   } else {
-    FX_DWORD dwConsume = m_SrcSize - dwAvail;
+    uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memcpy(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
     return FALSE;
   }
   m_offSet += dwSize;
   pGifModule->Input(m_pGifContext, m_pSrcBuf, dwSize + dwAvail);
   return TRUE;
 }
 void CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback(
     void* pModule,
-    FX_DWORD& cur_pos) {
+    uint32_t& cur_pos) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
-  FX_DWORD remain_size =
+  uint32_t remain_size =
       pCodec->m_pCodecMgr->GetGifModule()->GetAvailInput(pCodec->m_pGifContext);
   cur_pos = pCodec->m_offSet - remain_size;
 }
 uint8_t* CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback(
     void* pModule,
     int32_t frame_num,
     int32_t pal_size) {
   return FX_Alloc(uint8_t, pal_size);
 }
 FX_BOOL CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback(
     void* pModule,
-    FX_DWORD rcd_pos,
+    uint32_t rcd_pos,
     const FX_RECT& img_rc,
     int32_t pal_num,
     void* pal_ptr,
     int32_t delay_time,
     FX_BOOL user_input,
     int32_t trans_index,
     int32_t disposal_method,
     FX_BOOL interlace) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   pCodec->m_offSet = rcd_pos;
@@ skipping 12 matching lines @@
   if (pCodec->m_pSrcPalette == NULL) {
     pCodec->m_pSrcPalette = FX_Alloc(FX_ARGB, pal_num);
   } else if (pal_num > pCodec->m_SrcPaletteNumber) {
     pCodec->m_pSrcPalette = FX_Realloc(FX_ARGB, pCodec->m_pSrcPalette, pal_num);
   }
   if (pCodec->m_pSrcPalette == NULL) {
     return FALSE;
   }
   pCodec->m_SrcPaletteNumber = pal_num;
   for (int i = 0; i < pal_num; i++) {
-    FX_DWORD j = i * 3;
+    uint32_t j = i * 3;
     pCodec->m_pSrcPalette[i] =
         ArgbEncode(0xff, pPalette[j], pPalette[j + 1], pPalette[j + 2]);
   }
   pCodec->m_GifTransIndex = trans_index;
   pCodec->m_GifFrameRect = img_rc;
   pCodec->m_SrcPassNumber = interlace ? 4 : 1;
   int32_t pal_index = pCodec->m_GifBgIndex;
   CFX_DIBitmap* pDevice = pCodec->m_pDeviceBitmap;
   if (trans_index >= pal_num) {
     trans_index = -1;
@@ skipping 80 matching lines @@
     pCodec->ReSampleScanline(pDIBitmap, des_row, pCodec->m_pDecodeBuf,
                              pCodec->m_SrcFormat);
     if (scale_y > 1.0 &&
         (!pCodec->m_bInterpol || pCodec->m_SrcPassNumber == 1)) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
       return;
     }
     if (scale_y > 1.0) {
       int des_bottom = des_top + pCodec->m_sizeY;
       int des_Bpp = pDIBitmap->GetBPP() >> 3;
-      FX_DWORD des_ScanOffet = pCodec->m_startX * des_Bpp;
+      uint32_t des_ScanOffet = pCodec->m_startX * des_Bpp;
       if (des_row + (int)scale_y >= des_bottom - 1) {
         uint8_t* scan_src =
             (uint8_t*)pDIBitmap->GetScanline(des_row) + des_ScanOffet;
         int cur_row = des_row;
         while (++cur_row < des_bottom) {
           uint8_t* scan_des =
               (uint8_t*)pDIBitmap->GetScanline(cur_row) + des_ScanOffet;
-          FX_DWORD size = pCodec->m_sizeX * des_Bpp;
+          uint32_t size = pCodec->m_sizeX * des_Bpp;
           FXSYS_memcpy(scan_des, scan_src, size);
         }
       }
       if (bLastPass) {
         pCodec->GifDoubleLineResampleVert(pDIBitmap, scale_y, des_row);
       }
     }
   }
 }
 void CCodec_ProgressiveDecoder::GifDoubleLineResampleVert(
     CFX_DIBitmap* pDeviceBitmap,
     double scale_y,
     int des_row) {
   int des_Bpp = pDeviceBitmap->GetBPP() >> 3;
-  FX_DWORD des_ScanOffet = m_startX * des_Bpp;
+  uint32_t des_ScanOffet = m_startX * des_Bpp;
   int des_top = m_startY;
   int des_row_1 = des_row - int(2 * scale_y);
   if (des_row_1 < des_top) {
     des_row_1 = des_top;
   }
   for (; des_row_1 < des_row; des_row_1++) {
     uint8_t* scan_des =
         (uint8_t*)pDeviceBitmap->GetScanline(des_row_1) + des_ScanOffet;
     PixelWeight* pWeight = m_WeightVert.GetPixelWeight(des_row_1 - des_top);
     const uint8_t* scan_src1 =
@@ skipping 12 matching lines @@
           if (pDeviceBitmap->GetPalette()) {
             return;
           }
           int des_g = 0;
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
-          FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+          uint32_t des_b = 0, des_g = 0, des_r = 0;
           des_b += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_r += pWeight->m_Weights[0] * (*scan_src1++);
           scan_src1 += des_Bpp - 3;
           des_b += pWeight->m_Weights[1] * (*scan_src2++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           des_r += pWeight->m_Weights[1] * (*scan_src2++);
           scan_src2 += des_Bpp - 3;
           *scan_des++ = (uint8_t)((des_b) >> 16);
           *scan_des++ = (uint8_t)((des_g) >> 16);
           *scan_des++ = (uint8_t)((des_r) >> 16);
           scan_des += des_Bpp - 3;
         } break;
         case FXDIB_Argb: {
-          FX_DWORD des_a = 0, des_b = 0, des_g = 0, des_r = 0;
+          uint32_t des_a = 0, des_b = 0, des_g = 0, des_r = 0;
           des_b += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_r += pWeight->m_Weights[0] * (*scan_src1++);
           des_a += pWeight->m_Weights[0] * (*scan_src1++);
           des_b += pWeight->m_Weights[1] * (*scan_src2++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           des_r += pWeight->m_Weights[1] * (*scan_src2++);
           des_a += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)((des_b) >> 16);
           *scan_des++ = (uint8_t)((des_g) >> 16);
           *scan_des++ = (uint8_t)((des_r) >> 16);
           *scan_des++ = (uint8_t)((des_a) >> 16);
         } break;
         default:
           return;
       }
     }
   }
   int des_bottom = des_top + m_sizeY - 1;
   if (des_row + (int)(2 * scale_y) >= des_bottom &&
       des_row + (int)scale_y < des_bottom) {
     GifDoubleLineResampleVert(pDeviceBitmap, scale_y, des_row + (int)scale_y);
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(ICodec_BmpModule* pBmpModule,
                                                    FXCODEC_STATUS& err_status) {
-  FX_DWORD dwSize = (FX_DWORD)m_pFile->GetSize();
+  uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  FX_DWORD dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, NULL);
+  uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
     }
   } else {
-    FX_DWORD dwConsume = m_SrcSize - dwAvail;
+    uint32_t dwConsume = m_SrcSize - dwAvail;
     if (dwAvail) {
       FXSYS_memcpy(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail);
     }
     if (dwSize > dwConsume) {
       dwSize = dwConsume;
     }
   }
   if (!m_pFile->ReadBlock(m_pSrcBuf + dwAvail, m_offSet, dwSize)) {
     err_status = FXCODEC_STATUS_ERR_READ;
     return FALSE;
   }
   m_offSet += dwSize;
   pBmpModule->Input(m_pBmpContext, m_pSrcBuf, dwSize + dwAvail);
   return TRUE;
 }
 FX_BOOL CCodec_ProgressiveDecoder::BmpInputImagePositionBufCallback(
     void* pModule,
-    FX_DWORD rcd_pos) {
+    uint32_t rcd_pos) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   pCodec->m_offSet = rcd_pos;
   FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
   if (!pCodec->BmpReadMoreData(pCodec->m_pCodecMgr->GetBmpModule(),
                                error_status)) {
     return FALSE;
   }
   return TRUE;
 }
 void CCodec_ProgressiveDecoder::BmpReadScanlineCallback(void* pModule,
@@ skipping 24 matching lines @@
       } else {
         pCodec->ResampleVertBT(pDIBitmap, scale_y, des_row);
       }
     }
   }
 }
 void CCodec_ProgressiveDecoder::ResampleVertBT(CFX_DIBitmap* pDeviceBitmap,
                                                double scale_y,
                                                int des_row) {
   int des_Bpp = pDeviceBitmap->GetBPP() >> 3;
-  FX_DWORD des_ScanOffet = m_startX * des_Bpp;
+  uint32_t des_ScanOffet = m_startX * des_Bpp;
   int des_top = m_startY;
   int des_bottom = m_startY + m_sizeY;
   int des_row_1 = des_row + int(scale_y);
   if (des_row_1 >= des_bottom - 1) {
     uint8_t* scan_src =
         (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
     while (++des_row < des_bottom) {
       uint8_t* scan_des =
           (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
-      FX_DWORD size = m_sizeX * des_Bpp;
+      uint32_t size = m_sizeX * des_Bpp;
       FXSYS_memcpy(scan_des, scan_src, size);
     }
     return;
   }
   for (; des_row_1 > des_row; des_row_1--) {
     uint8_t* scan_des =
         (uint8_t*)pDeviceBitmap->GetScanline(des_row_1) + des_ScanOffet;
     PixelWeight* pWeight = m_WeightVert.GetPixelWeight(des_row_1 - des_top);
     const uint8_t* scan_src1 =
         pDeviceBitmap->GetScanline(pWeight->m_SrcStart + des_top) +
@@ skipping 11 matching lines @@
           if (pDeviceBitmap->GetPalette()) {
             return;
           }
           int des_g = 0;
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
-          FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+          uint32_t des_b = 0, des_g = 0, des_r = 0;
           des_b += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_r += pWeight->m_Weights[0] * (*scan_src1++);
           scan_src1 += des_Bpp - 3;
           des_b += pWeight->m_Weights[1] * (*scan_src2++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           des_r += pWeight->m_Weights[1] * (*scan_src2++);
           scan_src2 += des_Bpp - 3;
           *scan_des++ = (uint8_t)((des_b) >> 16);
           *scan_des++ = (uint8_t)((des_g) >> 16);
           *scan_des++ = (uint8_t)((des_r) >> 16);
           scan_des += des_Bpp - 3;
         } break;
         case FXDIB_Argb: {
-          FX_DWORD des_a = 0, des_b = 0, des_g = 0, des_r = 0;
+          uint32_t des_a = 0, des_b = 0, des_g = 0, des_r = 0;
           des_b += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_r += pWeight->m_Weights[0] * (*scan_src1++);
           des_a += pWeight->m_Weights[0] * (*scan_src1++);
           des_b += pWeight->m_Weights[1] * (*scan_src2++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           des_r += pWeight->m_Weights[1] * (*scan_src2++);
           des_a += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)((des_b) >> 16);
           *scan_des++ = (uint8_t)((des_g) >> 16);
           *scan_des++ = (uint8_t)((des_r) >> 16);
           *scan_des++ = (uint8_t)((des_a) >> 16);
         } break;
         default:
           return;
       }
     }
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
     FXCODEC_IMAGE_TYPE imageType,
     CFX_DIBAttribute* pAttribute) {
   m_offSet = 0;
-  FX_DWORD size = (FX_DWORD)m_pFile->GetSize();
+  uint32_t size = (uint32_t)m_pFile->GetSize();
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
   FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
       ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (pBmpModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pBmpModule->InputImagePositionBufCallback =
           BmpInputImagePositionBufCallback;
       pBmpModule->ReadScanlineCallback = BmpReadScanlineCallback;
       m_pBmpContext = pBmpModule->Start((void*)this);
       if (m_pBmpContext == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pBmpModule->Input(m_pBmpContext, m_pSrcBuf, size);
-      FX_DWORD* pPalette = NULL;
+      uint32_t* pPalette = NULL;
       int32_t readResult = pBmpModule->ReadHeader(
           m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
           &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       while (readResult == 2) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
         if (!BmpReadMoreData(pBmpModule, error_status)) {
           m_status = error_status;
           return FALSE;
         }
         readResult = pBmpModule->ReadHeader(
             m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
             &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       }
       if (readResult == 1) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
         FX_Free(m_pSrcPalette);
         if (m_SrcPaletteNumber) {
           m_pSrcPalette = FX_Alloc(FX_ARGB, m_SrcPaletteNumber);
           FXSYS_memcpy(m_pSrcPalette, pPalette,
-                       m_SrcPaletteNumber * sizeof(FX_DWORD));
+                       m_SrcPaletteNumber * sizeof(uint32_t));
         } else {
           m_pSrcPalette = nullptr;
         }
         return TRUE;
       }
       if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
         m_pBmpContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
@@ skipping 60 matching lines @@
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       bResult = pPngModule->Input(m_pPngContext, m_pSrcBuf, size, pAttribute);
       while (bResult) {
-        FX_DWORD remain_size = (FX_DWORD)m_pFile->GetSize() - m_offSet;
-        FX_DWORD input_size =
+        uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
+        uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = NULL;
           m_status = FXCODEC_STATUS_ERR_FORMAT;
           return FALSE;
         }
         if (m_pSrcBuf && input_size > m_SrcSize) {
@@ skipping 79 matching lines @@
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       m_pTiffContext = pTiffModule->CreateDecoder(m_pFile);
       if (m_pTiffContext == NULL) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       int32_t frames = 0;
       pTiffModule->GetFrames(m_pTiffContext, frames);
-      FX_DWORD bpc;
+      uint32_t bpc;
       FX_BOOL ret = pTiffModule->LoadFrameInfo(
-          m_pTiffContext, 0, (FX_DWORD&)m_SrcWidth, (FX_DWORD&)m_SrcHeight,
-          (FX_DWORD&)m_SrcComponents, bpc, pAttribute);
+          m_pTiffContext, 0, (uint32_t&)m_SrcWidth, (uint32_t&)m_SrcHeight,
+          (uint32_t&)m_SrcComponents, bpc, pAttribute);
       m_SrcComponents = 4;
       m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
       if (!ret) {
         pTiffModule->DestroyDecoder(m_pTiffContext);
         (m_pTiffContext = NULL);
         (m_status = FXCODEC_STATUS_ERR_FORMAT);
         return FALSE;
       }
     } break;
     default:
@@ skipping 220 matching lines @@
   for (int des_col = 0; des_col < m_sizeX; des_col++) {
     PixelWeight* pPixelWeights = m_WeightHorz.GetPixelWeight(des_col);
     switch (m_TransMethod) {
       case -1:
         return;
       case 0:
         return;
       case 1:
         return;
       case 2: {
-        FX_DWORD des_g = 0;
+        uint32_t des_g = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           des_g += pixel_weight * src_scan[j];
         }
         *des_scan++ = (uint8_t)(des_g >> 16);
       } break;
       case 3: {
         int des_r = 0, des_g = 0, des_b = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           unsigned long argb = m_pSrcPalette[src_scan[j]];
           des_r += pixel_weight * (uint8_t)(argb >> 16);
           des_g += pixel_weight * (uint8_t)(argb >> 8);
           des_b += pixel_weight * (uint8_t)argb;
         }
         *des_scan++ =
             (uint8_t)FXRGB2GRAY((des_r >> 16), (des_g >> 16), (des_b >> 16));
       } break;
       case 4: {
-        FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_b = 0, des_g = 0, des_r = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           const uint8_t* src_pixel = src_scan + j * src_Bpp;
           des_b += pixel_weight * (*src_pixel++);
           des_g += pixel_weight * (*src_pixel++);
           des_r += pixel_weight * (*src_pixel);
         }
         *des_scan++ =
             (uint8_t)FXRGB2GRAY((des_r >> 16), (des_g >> 16), (des_b >> 16));
       } break;
       case 5: {
-        FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_b = 0, des_g = 0, des_r = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           const uint8_t* src_pixel = src_scan + j * src_Bpp;
           uint8_t src_b = 0, src_g = 0, src_r = 0;
           AdobeCMYK_to_sRGB1(255 - src_pixel[0], 255 - src_pixel[1],
                              255 - src_pixel[2], 255 - src_pixel[3], src_r,
                              src_g, src_b);
           des_b += pixel_weight * src_b;
           des_g += pixel_weight * src_g;
           des_r += pixel_weight * src_r;
         }
         *des_scan++ =
             (uint8_t)FXRGB2GRAY((des_r >> 16), (des_g >> 16), (des_b >> 16));
       } break;
       case 6:
         return;
       case 7: {
-        FX_DWORD des_g = 0;
+        uint32_t des_g = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           des_g += pixel_weight * src_scan[j];
         }
         FXSYS_memset(des_scan, (uint8_t)(des_g >> 16), 3);
         des_scan += des_Bpp;
       } break;
       case 8: {
@@ skipping 40 matching lines @@
             des_g += pixel_weight * (uint8_t)(argb >> 8);
             des_b += pixel_weight * (uint8_t)argb;
           }
           *des_scan++ = (uint8_t)((des_b) >> 16);
           *des_scan++ = (uint8_t)((des_g) >> 16);
           *des_scan++ = (uint8_t)((des_r) >> 16);
           *des_scan++ = (uint8_t)((des_a) >> 16);
         }
       } break;
       case 9: {
-        FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_b = 0, des_g = 0, des_r = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           const uint8_t* src_pixel = src_scan + j * src_Bpp;
           des_b += pixel_weight * (*src_pixel++);
           des_g += pixel_weight * (*src_pixel++);
           des_r += pixel_weight * (*src_pixel);
         }
         *des_scan++ = (uint8_t)((des_b) >> 16);
         *des_scan++ = (uint8_t)((des_g) >> 16);
         *des_scan++ = (uint8_t)((des_r) >> 16);
         des_scan += des_Bpp - 3;
       } break;
       case 10: {
-        FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+        uint32_t des_b = 0, des_g = 0, des_r = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           const uint8_t* src_pixel = src_scan + j * src_Bpp;
           uint8_t src_b = 0, src_g = 0, src_r = 0;
           AdobeCMYK_to_sRGB1(255 - src_pixel[0], 255 - src_pixel[1],
                              255 - src_pixel[2], 255 - src_pixel[3], src_r,
                              src_g, src_b);
           des_b += pixel_weight * src_b;
           des_g += pixel_weight * src_g;
           des_r += pixel_weight * src_r;
         }
         *des_scan++ = (uint8_t)((des_b) >> 16);
         *des_scan++ = (uint8_t)((des_g) >> 16);
         *des_scan++ = (uint8_t)((des_r) >> 16);
         des_scan += des_Bpp - 3;
       } break;
       case 11: {
-        FX_DWORD des_alpha = 0, des_r = 0, des_g = 0, des_b = 0;
+        uint32_t des_alpha = 0, des_r = 0, des_g = 0, des_b = 0;
         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
              j++) {
           int pixel_weight =
               pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
           const uint8_t* src_pixel = src_scan + j * src_Bpp;
           pixel_weight = pixel_weight * src_pixel[3] / 255;
           des_b += pixel_weight * (*src_pixel++);
           des_g += pixel_weight * (*src_pixel++);
           des_r += pixel_weight * (*src_pixel);
           des_alpha += pixel_weight;
         }
         *des_scan++ = (uint8_t)((des_b) >> 16);
         *des_scan++ = (uint8_t)((des_g) >> 16);
         *des_scan++ = (uint8_t)((des_r) >> 16);
         *des_scan++ = (uint8_t)((des_alpha * 255) >> 16);
       } break;
       default:
         return;
     }
   }
 }
 void CCodec_ProgressiveDecoder::ResampleVert(CFX_DIBitmap* pDeviceBitmap,
                                              double scale_y,
                                              int des_row) {
   int des_Bpp = pDeviceBitmap->GetBPP() >> 3;
-  FX_DWORD des_ScanOffet = m_startX * des_Bpp;
+  uint32_t des_ScanOffet = m_startX * des_Bpp;
   if (m_bInterpol) {
     int des_top = m_startY;
     int des_row_1 = des_row - int(scale_y);
     if (des_row_1 < des_top) {
       int des_bottom = des_top + m_sizeY;
       if (des_row + (int)scale_y >= des_bottom - 1) {
         uint8_t* scan_src =
             (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
         while (++des_row < des_bottom) {
           uint8_t* scan_des =
               (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
-          FX_DWORD size = m_sizeX * des_Bpp;
+          uint32_t size = m_sizeX * des_Bpp;
           FXSYS_memcpy(scan_des, scan_src, size);
         }
       }
       return;
     }
     for (; des_row_1 < des_row; des_row_1++) {
       uint8_t* scan_des =
           (uint8_t*)pDeviceBitmap->GetScanline(des_row_1) + des_ScanOffet;
       PixelWeight* pWeight = m_WeightVert.GetPixelWeight(des_row_1 - des_top);
       const uint8_t* scan_src1 =
@@ skipping 13 matching lines @@
             if (pDeviceBitmap->GetPalette()) {
               return;
             }
             int des_g = 0;
             des_g += pWeight->m_Weights[0] * (*scan_src1++);
             des_g += pWeight->m_Weights[1] * (*scan_src2++);
             *scan_des++ = (uint8_t)(des_g >> 16);
           } break;
           case FXDIB_Rgb:
           case FXDIB_Rgb32: {
-            FX_DWORD des_b = 0, des_g = 0, des_r = 0;
+            uint32_t des_b = 0, des_g = 0, des_r = 0;
             des_b += pWeight->m_Weights[0] * (*scan_src1++);
             des_g += pWeight->m_Weights[0] * (*scan_src1++);
             des_r += pWeight->m_Weights[0] * (*scan_src1++);
             scan_src1 += des_Bpp - 3;
             des_b += pWeight->m_Weights[1] * (*scan_src2++);
             des_g += pWeight->m_Weights[1] * (*scan_src2++);
             des_r += pWeight->m_Weights[1] * (*scan_src2++);
             scan_src2 += des_Bpp - 3;
             *scan_des++ = (uint8_t)((des_b) >> 16);
             *scan_des++ = (uint8_t)((des_g) >> 16);
             *scan_des++ = (uint8_t)((des_r) >> 16);
             scan_des += des_Bpp - 3;
           } break;
           case FXDIB_Argb: {
-            FX_DWORD des_a = 0, des_b = 0, des_g = 0, des_r = 0;
+            uint32_t des_a = 0, des_b = 0, des_g = 0, des_r = 0;
             des_b += pWeight->m_Weights[0] * (*scan_src1++);
             des_g += pWeight->m_Weights[0] * (*scan_src1++);
             des_r += pWeight->m_Weights[0] * (*scan_src1++);
             des_a += pWeight->m_Weights[0] * (*scan_src1++);
             des_b += pWeight->m_Weights[1] * (*scan_src2++);
             des_g += pWeight->m_Weights[1] * (*scan_src2++);
             des_r += pWeight->m_Weights[1] * (*scan_src2++);
             des_a += pWeight->m_Weights[1] * (*scan_src2++);
             *scan_des++ = (uint8_t)((des_b) >> 16);
             *scan_des++ = (uint8_t)((des_g) >> 16);
             *scan_des++ = (uint8_t)((des_r) >> 16);
             *scan_des++ = (uint8_t)((des_a) >> 16);
           } break;
           default:
             return;
         }
       }
     }
     int des_bottom = des_top + m_sizeY;
     if (des_row + (int)scale_y >= des_bottom - 1) {
       uint8_t* scan_src =
           (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
       while (++des_row < des_bottom) {
         uint8_t* scan_des =
             (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
-        FX_DWORD size = m_sizeX * des_Bpp;
+        uint32_t size = m_sizeX * des_Bpp;
         FXSYS_memcpy(scan_des, scan_src, size);
       }
     }
     return;
   }
   int multiple = (int)FXSYS_ceil((FX_FLOAT)scale_y - 1);
   if (multiple > 0) {
     uint8_t* scan_src =
         (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
     for (int i = 1; i <= multiple; i++) {
       if (des_row + i >= m_startY + m_sizeY) {
         return;
       }
       uint8_t* scan_des =
           (uint8_t*)pDeviceBitmap->GetScanline(des_row + i) + des_ScanOffet;
-      FX_DWORD size = m_sizeX * des_Bpp;
+      uint32_t size = m_sizeX * des_Bpp;
       FXSYS_memcpy(scan_des, scan_src, size);
     }
   }
 }
 void CCodec_ProgressiveDecoder::Resample(CFX_DIBitmap* pDeviceBitmap,
                                          int32_t src_line,
                                          uint8_t* src_scan,
                                          FXCodec_Format src_format) {
   int src_top = m_clipBox.top;
   int des_top = m_startY;
@@ skipping 283 matching lines @@
         Resample(m_pDeviceBitmap, m_SrcRow, m_pDecodeBuf, m_SrcFormat);
         m_SrcRow++;
         if (pPause && pPause->NeedToPauseNow()) {
           return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         }
       }
     } break;
     case FXCODEC_IMAGE_PNG: {
       ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       while (TRUE) {
-        FX_DWORD remain_size = (FX_DWORD)m_pFile->GetSize() - m_offSet;
-        FX_DWORD input_size =
+        uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
+        uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = NULL;
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
@@ skipping 214 matching lines @@
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 ICodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }