Remove FX_DWORD from core/ and delete definition

core/fxge/dib/fx_dib_convert.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/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_dib.h"
 #include "core/include/fxge/fx_ge.h"
 
 class CFX_Palette {
  public:
   CFX_Palette();
   ~CFX_Palette();
 
   FX_BOOL BuildPalette(const CFX_DIBSource* pBitmap);
-  FX_DWORD* GetPalette() const { return m_pPalette; }
-  FX_DWORD* GetColorLut() const { return m_cLut; }
-  FX_DWORD* GetAmountLut() const { return m_aLut; }
+  uint32_t* GetPalette() const { return m_pPalette; }
+  uint32_t* GetColorLut() const { return m_cLut; }
+  uint32_t* GetAmountLut() const { return m_aLut; }
   int32_t Getlut() const { return m_lut; }
 
  protected:
-  FX_DWORD* m_pPalette;
-  FX_DWORD* m_cLut;
-  FX_DWORD* m_aLut;
+  uint32_t* m_pPalette;
+  uint32_t* m_cLut;
+  uint32_t* m_aLut;
   int m_lut;
 };
-int _Partition(FX_DWORD* alut, FX_DWORD* clut, int l, int r) {
-  FX_DWORD p_a = alut[l];
-  FX_DWORD p_c = clut[l];
+int _Partition(uint32_t* alut, uint32_t* clut, int l, int r) {
+  uint32_t p_a = alut[l];
+  uint32_t p_c = clut[l];
   while (l < r) {
     while (l < r && alut[r] >= p_a) {
       r--;
     }
     if (l < r) {
       alut[l] = alut[r];
       clut[l++] = clut[r];
     }
     while (l < r && alut[l] <= p_a) {
       l++;
     }
     if (l < r) {
       alut[r] = alut[l];
       clut[r--] = clut[l];
     }
   }
   alut[l] = p_a;
   clut[l] = p_c;
   return l;
 }
-void _Qsort(FX_DWORD* alut, FX_DWORD* clut, int l, int r) {
+void _Qsort(uint32_t* alut, uint32_t* clut, int l, int r) {
   if (l < r) {
     int pI = _Partition(alut, clut, l, r);
     _Qsort(alut, clut, l, pI - 1);
     _Qsort(alut, clut, pI + 1, r);
   }
 }
-void _ColorDecode(FX_DWORD pal_v, uint8_t& r, uint8_t& g, uint8_t& b) {
+void _ColorDecode(uint32_t pal_v, uint8_t& r, uint8_t& g, uint8_t& b) {
   r = (uint8_t)((pal_v & 0xf00) >> 4);
   g = (uint8_t)(pal_v & 0x0f0);
   b = (uint8_t)((pal_v & 0x00f) << 4);
 }
-void _Obtain_Pal(FX_DWORD* aLut,
-                 FX_DWORD* cLut,
-                 FX_DWORD* dest_pal,
-                 FX_DWORD lut) {
-  FX_DWORD lut_1 = lut - 1;
+void _Obtain_Pal(uint32_t* aLut,
+                 uint32_t* cLut,
+                 uint32_t* dest_pal,
+                 uint32_t lut) {
+  uint32_t lut_1 = lut - 1;
   for (int row = 0; row < 256; row++) {
     int lut_offset = lut_1 - row;
     if (lut_offset < 0) {
       lut_offset += 256;
     }
-    FX_DWORD color = cLut[lut_offset];
+    uint32_t color = cLut[lut_offset];
     uint8_t r;
     uint8_t g;
     uint8_t b;
     _ColorDecode(color, r, g, b);
-    dest_pal[row] = ((FX_DWORD)r << 16) | ((FX_DWORD)g << 8) | b | 0xff000000;
+    dest_pal[row] = ((uint32_t)r << 16) | ((uint32_t)g << 8) | b | 0xff000000;
     aLut[lut_offset] = row;
   }
 }
 
 CFX_Palette::CFX_Palette() {
   m_pPalette = NULL;
   m_cLut = NULL;
   m_aLut = NULL;
   m_lut = 0;
 }
 CFX_Palette::~CFX_Palette() {
   FX_Free(m_pPalette);
   FX_Free(m_cLut);
   FX_Free(m_aLut);
   m_lut = 0;
 }
 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap) {
   if (!pBitmap) {
     return FALSE;
   }
   FX_Free(m_pPalette);
-  m_pPalette = FX_Alloc(FX_DWORD, 256);
+  m_pPalette = FX_Alloc(uint32_t, 256);
   int bpp = pBitmap->GetBPP() / 8;
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   FX_Free(m_cLut);
   m_cLut = NULL;
   FX_Free(m_aLut);
   m_aLut = NULL;
-  m_cLut = FX_Alloc(FX_DWORD, 4096);
-  m_aLut = FX_Alloc(FX_DWORD, 4096);
+  m_cLut = FX_Alloc(uint32_t, 4096);
+  m_aLut = FX_Alloc(uint32_t, 4096);
   int row, col;
   m_lut = 0;
   for (row = 0; row < height; row++) {
     uint8_t* scan_line = (uint8_t*)pBitmap->GetScanline(row);
     for (col = 0; col < width; col++) {
       uint8_t* src_port = scan_line + col * bpp;
-      FX_DWORD b = src_port[0] & 0xf0;
-      FX_DWORD g = src_port[1] & 0xf0;
-      FX_DWORD r = src_port[2] & 0xf0;
-      FX_DWORD index = (r << 4) + g + (b >> 4);
+      uint32_t b = src_port[0] & 0xf0;
+      uint32_t g = src_port[1] & 0xf0;
+      uint32_t r = src_port[2] & 0xf0;
+      uint32_t index = (r << 4) + g + (b >> 4);
       m_aLut[index]++;
     }
   }
   for (row = 0; row < 4096; row++) {
     if (m_aLut[row] != 0) {
       m_aLut[m_lut] = m_aLut[row];
       m_cLut[m_lut] = row;
       m_lut++;
     }
   }
@@ skipping 39 matching lines @@
   return TRUE;
 }
 FX_BOOL ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
                                    int dest_pitch,
                                    int width,
                                    int height,
                                    const CFX_DIBSource* pSrcBitmap,
                                    int src_left,
                                    int src_top,
                                    void* pIccTransform) {
-  FX_DWORD* src_plt = pSrcBitmap->GetPalette();
+  uint32_t* src_plt = pSrcBitmap->GetPalette();
   uint8_t gray[2];
   if (pIccTransform) {
-    FX_DWORD plt[2];
+    uint32_t plt[2];
     if (pSrcBitmap->IsCmykImage()) {
       plt[0] = FXCMYK_TODIB(src_plt[0]);
       plt[1] = FXCMYK_TODIB(src_plt[1]);
     } else {
       uint8_t* bgr_ptr = (uint8_t*)plt;
       bgr_ptr[0] = FXARGB_B(src_plt[0]);
       bgr_ptr[1] = FXARGB_G(src_plt[0]);
       bgr_ptr[2] = FXARGB_R(src_plt[0]);
       bgr_ptr[3] = FXARGB_B(src_plt[1]);
       bgr_ptr[4] = FXARGB_G(src_plt[1]);
@@ skipping 38 matching lines @@
   return TRUE;
 }
 FX_BOOL ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
                                    int dest_pitch,
                                    int width,
                                    int height,
                                    const CFX_DIBSource* pSrcBitmap,
                                    int src_left,
                                    int src_top,
                                    void* pIccTransform) {
-  FX_DWORD* src_plt = pSrcBitmap->GetPalette();
+  uint32_t* src_plt = pSrcBitmap->GetPalette();
   uint8_t gray[256];
   if (pIccTransform) {
-    FX_DWORD plt[256];
+    uint32_t plt[256];
     if (pSrcBitmap->IsCmykImage()) {
       for (int i = 0; i < 256; i++) {
         plt[i] = FXCMYK_TODIB(src_plt[i]);
       }
     } else {
       uint8_t* bgr_ptr = (uint8_t*)plt;
       for (int i = 0; i < 256; i++) {
         *bgr_ptr++ = FXARGB_B(src_plt[i]);
         *bgr_ptr++ = FXARGB_G(src_plt[i]);
         *bgr_ptr++ = FXARGB_R(src_plt[i]);
@@ skipping 61 matching lines @@
       }
     }
   } else {
     if (pSrcBitmap->IsCmykImage()) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan =
             pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
         for (int col = 0; col < width; col++) {
           uint8_t r, g, b;
-          AdobeCMYK_to_sRGB1(FXSYS_GetCValue((FX_DWORD)src_scan[0]),
-                             FXSYS_GetMValue((FX_DWORD)src_scan[1]),
-                             FXSYS_GetYValue((FX_DWORD)src_scan[2]),
-                             FXSYS_GetKValue((FX_DWORD)src_scan[3]), r, g, b);
+          AdobeCMYK_to_sRGB1(FXSYS_GetCValue((uint32_t)src_scan[0]),
+                             FXSYS_GetMValue((uint32_t)src_scan[1]),
+                             FXSYS_GetYValue((uint32_t)src_scan[2]),
+                             FXSYS_GetKValue((uint32_t)src_scan[3]), r, g, b);
           *dest_scan++ = FXRGB2GRAY(r, g, b);
           src_scan += 4;
         }
       }
     } else {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan =
             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
         for (int col = 0; col < width; col++) {
@@ skipping 33 matching lines @@
     }
   }
 }
 FX_BOOL ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
                                   int dest_pitch,
                                   int width,
                                   int height,
                                   const CFX_DIBSource* pSrcBitmap,
                                   int src_left,
                                   int src_top,
-                                  FX_DWORD* dst_plt,
+                                  uint32_t* dst_plt,
                                   void* pIccTransform) {
   ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
                           src_left, src_top);
-  FX_DWORD* src_plt = pSrcBitmap->GetPalette();
+  uint32_t* src_plt = pSrcBitmap->GetPalette();
   int plt_size = pSrcBitmap->GetPaletteSize();
   if (pIccTransform) {
-    FX_DWORD plt[256];
+    uint32_t plt[256];
     uint8_t* bgr_ptr = (uint8_t*)plt;
     if (pSrcBitmap->IsCmykImage()) {
       for (int i = 0; i < plt_size; i++) {
         plt[i] = FXCMYK_TODIB(src_plt[i]);
       }
     } else {
       for (int i = 0; i < plt_size; i++) {
         *bgr_ptr++ = FXARGB_B(src_plt[i]);
         *bgr_ptr++ = FXARGB_G(src_plt[i]);
         *bgr_ptr++ = FXARGB_R(src_plt[i]);
@@ skipping 23 matching lines @@
   }
   return TRUE;
 }
 FX_BOOL ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf,
                                               int dest_pitch,
                                               int width,
                                               int height,
                                               const CFX_DIBSource* pSrcBitmap,
                                               int src_left,
                                               int src_top,
-                                              FX_DWORD* dst_plt) {
+                                              uint32_t* dst_plt) {
   int bpp = pSrcBitmap->GetBPP() / 8;
   int row, col;
   CFX_Palette palette;
   palette.BuildPalette(pSrcBitmap);
-  FX_DWORD* cLut = palette.GetColorLut();
-  FX_DWORD* aLut = palette.GetAmountLut();
+  uint32_t* cLut = palette.GetColorLut();
+  uint32_t* aLut = palette.GetAmountLut();
   if (!cLut || !aLut) {
     return FALSE;
   }
   int lut = palette.Getlut();
-  FX_DWORD* pPalette = palette.GetPalette();
+  uint32_t* pPalette = palette.GetPalette();
   if (lut > 256) {
     int err, min_err;
     int lut_256 = lut - 256;
     for (row = 0; row < lut_256; row++) {
       min_err = 1000000;
       uint8_t r, g, b;
       _ColorDecode(cLut[row], r, g, b);
       int clrindex = 0;
       for (int col = 0; col < 256; col++) {
-        FX_DWORD p_color = *(pPalette + col);
+        uint32_t p_color = *(pPalette + col);
         int d_r = r - (uint8_t)(p_color >> 16);
         int d_g = g - (uint8_t)(p_color >> 8);
         int d_b = b - (uint8_t)(p_color);
         err = d_r * d_r + d_g * d_g + d_b * d_b;
         if (err < min_err) {
           min_err = err;
           clrindex = col;
         }
       }
       aLut[row] = clrindex;
     }
   }
   int32_t lut_1 = lut - 1;
   for (row = 0; row < height; row++) {
     uint8_t* src_scan =
         (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left;
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     for (col = 0; col < width; col++) {
       uint8_t* src_port = src_scan + col * bpp;
       int r = src_port[2] & 0xf0;
       int g = src_port[1] & 0xf0;
       int b = src_port[0] & 0xf0;
-      FX_DWORD clrindex = (r << 4) + g + (b >> 4);
+      uint32_t clrindex = (r << 4) + g + (b >> 4);
       for (int i = lut_1; i >= 0; i--)
         if (clrindex == cLut[i]) {
           *(dest_scan + col) = (uint8_t)(aLut[i]);
           break;
         }
     }
   }
-  FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
+  FXSYS_memcpy(dst_plt, pPalette, sizeof(uint32_t) * 256);
   return TRUE;
 }
 FX_BOOL ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
                                   int dest_pitch,
                                   int width,
                                   int height,
                                   const CFX_DIBSource* pSrcBitmap,
                                   int src_left,
                                   int src_top,
-                                  FX_DWORD* dst_plt,
+                                  uint32_t* dst_plt,
                                   void* pIccTransform) {
   FX_BOOL ret = ConvertBuffer_Rgb2PltRgb8_NoTransform(
       dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top,
       dst_plt);
   if (ret && pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int i = 0; i < 256; i++) {
       FX_ARGB* plt = dst_plt + i;
       FX_ARGB plt_entry = FXARGB_TODIB(*plt);
@@ skipping 60 matching lines @@
 FX_BOOL ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
                                   uint8_t* dest_buf,
                                   int dest_pitch,
                                   int width,
                                   int height,
                                   const CFX_DIBSource* pSrcBitmap,
                                   int src_left,
                                   int src_top,
                                   void* pIccTransform) {
   int comps = (dst_format & 0xff) / 8;
-  FX_DWORD* src_plt = pSrcBitmap->GetPalette();
-  FX_DWORD plt[2];
+  uint32_t* src_plt = pSrcBitmap->GetPalette();
+  uint32_t plt[2];
   uint8_t* bgr_ptr = (uint8_t*)plt;
   if (pSrcBitmap->IsCmykImage()) {
     plt[0] = FXCMYK_TODIB(src_plt[0]);
     plt[1] = FXCMYK_TODIB(src_plt[1]);
   } else {
     bgr_ptr[0] = FXARGB_B(src_plt[0]);
     bgr_ptr[1] = FXARGB_G(src_plt[0]);
     bgr_ptr[2] = FXARGB_R(src_plt[0]);
     bgr_ptr[3] = FXARGB_B(src_plt[1]);
     bgr_ptr[4] = FXARGB_G(src_plt[1]);
@@ skipping 37 matching lines @@
 FX_BOOL ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
                                   uint8_t* dest_buf,
                                   int dest_pitch,
                                   int width,
                                   int height,
                                   const CFX_DIBSource* pSrcBitmap,
                                   int src_left,
                                   int src_top,
                                   void* pIccTransform) {
   int comps = (dst_format & 0xff) / 8;
-  FX_DWORD* src_plt = pSrcBitmap->GetPalette();
-  FX_DWORD plt[256];
+  uint32_t* src_plt = pSrcBitmap->GetPalette();
+  uint32_t plt[256];
   uint8_t* bgr_ptr = (uint8_t*)plt;
   if (!pSrcBitmap->IsCmykImage()) {
     for (int i = 0; i < 256; i++) {
       *bgr_ptr++ = FXARGB_B(src_plt[i]);
       *bgr_ptr++ = FXARGB_G(src_plt[i]);
       *bgr_ptr++ = FXARGB_R(src_plt[i]);
     }
     bgr_ptr = (uint8_t*)plt;
   }
   if (pIccTransform) {
@@ skipping 162 matching lines @@
   return TRUE;
 }
 FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
                       uint8_t* dest_buf,
                       int dest_pitch,
                       int width,
                       int height,
                       const CFX_DIBSource* pSrcBitmap,
                       int src_left,
                       int src_top,
-                      FX_DWORD*& d_pal,
+                      uint32_t*& d_pal,
                       void* pIccTransform) {
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     pIccTransform = NULL;
   }
   switch (dest_format) {
     case FXDIB_Invalid:
     case FXDIB_1bppCmyk:
     case FXDIB_1bppMask:
@@ skipping 26 matching lines @@
       }
       return FALSE;
     }
     case FXDIB_8bppRgb:
     case FXDIB_8bppRgba: {
       if ((src_format & 0xff) == 8 && !pSrcBitmap->GetPalette()) {
         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
                              height, pSrcBitmap, src_left, src_top, d_pal,
                              pIccTransform);
       }
-      d_pal = FX_Alloc(FX_DWORD, 256);
+      d_pal = FX_Alloc(uint32_t, 256);
       if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
           pSrcBitmap->GetPalette()) {
         return ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
                                          pSrcBitmap, src_left, src_top, d_pal,
                                          pIccTransform);
       }
       if ((src_format & 0xff) >= 24) {
         return ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
                                          pSrcBitmap, src_left, src_top, d_pal,
                                          pIccTransform);
@@ skipping 112 matching lines @@
     }
   }
   if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
     delete pSrcAlpha;
     pSrcAlpha = NULL;
   }
   if (!ret) {
     delete pClone;
     return NULL;
   }
-  FX_DWORD* pal_8bpp = NULL;
+  uint32_t* pal_8bpp = NULL;
   ret = ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
                       m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
   if (!ret) {
     FX_Free(pal_8bpp);
     delete pClone;
     return NULL;
   }
   if (pal_8bpp) {
     pClone->CopyPalette(pal_8bpp);
     FX_Free(pal_8bpp);
@@ skipping 57 matching lines @@
           return FALSE;
         }
         pAlphaMask = m_pAlphaMask;
         m_pAlphaMask = NULL;
       } else {
         pAlphaMask = m_pAlphaMask;
       }
     }
   }
   FX_BOOL ret = FALSE;
-  FX_DWORD* pal_8bpp = NULL;
+  uint32_t* pal_8bpp = NULL;
   ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
                       this, 0, 0, pal_8bpp, pIccTransform);
   if (!ret) {
     FX_Free(pal_8bpp);
     if (pAlphaMask != m_pAlphaMask) {
       delete pAlphaMask;
     }
     FX_Free(dest_buf);
     return FALSE;
   }
   if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
     delete m_pAlphaMask;
   }
   m_pAlphaMask = pAlphaMask;
   FX_Free(m_pPalette);
   m_pPalette = pal_8bpp;
   if (!m_bExtBuf) {
     FX_Free(m_pBuffer);
   }
   m_bExtBuf = FALSE;
   m_pBuffer = dest_buf;
   m_bpp = (uint8_t)dest_format;
   m_AlphaFlag = (uint8_t)(dest_format >> 8);
   m_Pitch = dest_pitch;
   return TRUE;
 }