Remove FX_DWORD from core/ and delete definition

core/fxge/dib/fx_dib_composite.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/fxge/dib/dib_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
 
@@ skipping 2131 matching lines @@
     int back_alpha = *dest_alpha_scan;
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     *dest_alpha_scan++ = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
     dest_scan++;
   }
 }
 inline void _CompositeRow_8bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
                                               const uint8_t* src_scan,
-                                              FX_DWORD* pPalette,
+                                              uint32_t* pPalette,
                                               int pixel_count,
                                               int DestBpp,
                                               const uint8_t* clip_scan,
                                               const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     int dest_gap = DestBpp - 3;
     FX_ARGB argb = 0;
     for (int col = 0; col < pixel_count; col++) {
       argb = pPalette[*src_scan];
       int src_r = FXARGB_R(argb);
@@ skipping 47 matching lines @@
       if (DestBpp == 4) {
         dest_scan++;
       }
       src_scan++;
     }
   }
 }
 inline void _CompositeRow_1bppRgb2Rgb_NoBlend(uint8_t* dest_scan,
                                               const uint8_t* src_scan,
                                               int src_left,
-                                              FX_DWORD* pPalette,
+                                              uint32_t* pPalette,
                                               int pixel_count,
                                               int DestBpp,
                                               const uint8_t* clip_scan) {
   int reset_r, reset_g, reset_b;
   int set_r, set_g, set_b;
   reset_r = FXARGB_R(pPalette[0]);
   reset_g = FXARGB_G(pPalette[0]);
   reset_b = FXARGB_B(pPalette[0]);
   set_r = FXARGB_R(pPalette[1]);
   set_g = FXARGB_G(pPalette[1]);
@@ skipping 22 matching lines @@
       *dest_scan++ = src_r;
     }
     if (DestBpp == 4) {
       dest_scan++;
     }
   }
 }
 inline void _CompositeRow_8bppRgb2Argb_NoBlend(uint8_t* dest_scan,
                                                const uint8_t* src_scan,
                                                int width,
-                                               FX_DWORD* pPalette,
+                                               uint32_t* pPalette,
                                                const uint8_t* clip_scan,
                                                const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       src_scan++;
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
       uint8_t back_alpha = dest_scan[3];
@@ skipping 64 matching lines @@
       dest_scan++;
       dest_scan++;
       src_scan++;
     }
   }
 }
 
 void _CompositeRow_8bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
                                         const uint8_t* src_scan,
                                         int width,
-                                        FX_DWORD* pPalette,
+                                        uint32_t* pPalette,
                                         const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan,
                                         const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       src_scan++;
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
@@ skipping 67 matching lines @@
       dest_scan++;
       src_scan++;
     }
   }
 }
 
 inline void _CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan,
                                                const uint8_t* src_scan,
                                                int src_left,
                                                int width,
-                                               FX_DWORD* pPalette,
+                                               uint32_t* pPalette,
                                                const uint8_t* clip_scan) {
   int reset_r, reset_g, reset_b;
   int set_r, set_g, set_b;
   reset_r = FXARGB_R(pPalette[0]);
   reset_g = FXARGB_G(pPalette[0]);
   reset_b = FXARGB_B(pPalette[0]);
   set_r = FXARGB_R(pPalette[1]);
   set_g = FXARGB_G(pPalette[1]);
   set_b = FXARGB_B(pPalette[1]);
   for (int col = 0; col < width; col++) {
@@ skipping 29 matching lines @@
     dest_scan++;
     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
     dest_scan++;
     dest_scan++;
   }
 }
 void _CompositeRow_1bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
                                         const uint8_t* src_scan,
                                         int src_left,
                                         int width,
-                                        FX_DWORD* pPalette,
+                                        uint32_t* pPalette,
                                         const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan) {
   int reset_r, reset_g, reset_b;
   int set_r, set_g, set_b;
   reset_r = FXARGB_R(pPalette[0]);
   reset_g = FXARGB_G(pPalette[0]);
   reset_b = FXARGB_B(pPalette[0]);
   set_r = FXARGB_R(pPalette[1]);
   set_g = FXARGB_G(pPalette[1]);
   set_b = FXARGB_B(pPalette[1]);
@@ skipping 1455 matching lines @@
       dest_scan[1] = FX_GAMMA_INVERSE(
           FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), src_g, src_alpha));
       dest_scan[0] = FX_GAMMA_INVERSE(
           FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), src_r, src_alpha));
     }
     dest_scan += Bpp;
   }
 }
 inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
                                                   int alpha_flag,
-                                                  FX_DWORD mask_color,
+                                                  uint32_t mask_color,
                                                   int& mask_alpha,
                                                   int& mask_red,
                                                   int& mask_green,
                                                   int& mask_blue,
                                                   int& mask_black,
                                                   void* icc_module,
                                                   void* pIccTransform) {
   ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
   if (alpha_flag >> 8) {
     mask_alpha = alpha_flag & 0xff;
@@ skipping 46 matching lines @@
                          mask_color_p[0]);
       mask_red = mask_color_p[2];
       mask_green = mask_color_p[1];
       mask_blue = mask_color_p[0];
     }
   }
   return TRUE;
 }
 inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
                                                   FXDIB_Format dest_format,
-                                                  FX_DWORD*& pDestPalette,
-                                                  FX_DWORD* pSrcPalette,
+                                                  uint32_t*& pDestPalette,
+                                                  uint32_t* pSrcPalette,
                                                   void* icc_module,
                                                   void* pIccTransform) {
   ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
   FX_BOOL isSrcCmyk = !!(src_format & 0x0400);
   FX_BOOL isDstCmyk = !!(dest_format & 0x0400);
   pDestPalette = NULL;
   if (pIccTransform) {
     if (pSrcPalette) {
       if ((dest_format & 0xff) == 8) {
         int pal_count = 1 << (src_format & 0xff);
         uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-        pDestPalette = (FX_DWORD*)gray_pal;
+        pDestPalette = (uint32_t*)gray_pal;
         for (int i = 0; i < pal_count; i++) {
-          FX_DWORD color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
+          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
                                      : FXARGB_TODIB(pSrcPalette[i]);
           pIccModule->TranslateScanline(pIccTransform, gray_pal,
                                         (const uint8_t*)&color, 1);
           gray_pal++;
         }
       } else {
         int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(FX_DWORD, palsize);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
         for (int i = 0; i < palsize; i++) {
-          FX_DWORD color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
+          uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i])
                                      : FXARGB_TODIB(pSrcPalette[i]);
           pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color,
                                         (const uint8_t*)&color, 1);
           pDestPalette[i] =
               isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
         }
       }
     } else {
       int pal_count = 1 << (src_format & 0xff);
       uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
       if (pal_count == 2) {
         gray_pal[0] = 0;
         gray_pal[1] = 255;
       } else {
         for (int i = 0; i < pal_count; i++) {
           gray_pal[i] = i;
         }
       }
       if ((dest_format & 0xff) == 8) {
         pIccModule->TranslateScanline(pIccTransform, gray_pal, gray_pal,
                                       pal_count);
-        pDestPalette = (FX_DWORD*)gray_pal;
+        pDestPalette = (uint32_t*)gray_pal;
       } else {
-        pDestPalette = FX_Alloc(FX_DWORD, pal_count);
+        pDestPalette = FX_Alloc(uint32_t, pal_count);
         for (int i = 0; i < pal_count; i++) {
           pIccModule->TranslateScanline(
               pIccTransform, (uint8_t*)&pDestPalette[i], &gray_pal[i], 1);
           pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(pDestPalette[i])
                                       : FXARGB_TODIB(pDestPalette[i]);
         }
         FX_Free(gray_pal);
       }
     }
   } else {
     if (pSrcPalette) {
       if ((dest_format & 0xff) == 8) {
         int pal_count = 1 << (src_format & 0xff);
         uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
-        pDestPalette = (FX_DWORD*)gray_pal;
+        pDestPalette = (uint32_t*)gray_pal;
         if (isSrcCmyk) {
           for (int i = 0; i < pal_count; i++) {
             FX_CMYK cmyk = pSrcPalette[i];
             uint8_t r, g, b;
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                                FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
                                g, b);
             *gray_pal++ = FXRGB2GRAY(r, g, b);
           }
         } else {
           for (int i = 0; i < pal_count; i++) {
             FX_ARGB argb = pSrcPalette[i];
             *gray_pal++ =
                 FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
           }
         }
       } else {
         int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(FX_DWORD, palsize);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
         if (isDstCmyk == isSrcCmyk) {
-          FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(FX_DWORD));
+          FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t));
         } else {
           for (int i = 0; i < palsize; i++) {
             FX_CMYK cmyk = pSrcPalette[i];
             uint8_t r, g, b;
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                                FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
                                g, b);
             pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b);
           }
         }
       }
     } else {
       if ((dest_format & 0xff) == 8) {
         int pal_count = 1 << (src_format & 0xff);
         uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
         if (pal_count == 2) {
           gray_pal[0] = 0;
           gray_pal[1] = 255;
         } else {
           for (int i = 0; i < pal_count; i++) {
             gray_pal[i] = i;
           }
         }
-        pDestPalette = (FX_DWORD*)gray_pal;
+        pDestPalette = (uint32_t*)gray_pal;
       } else {
         int palsize = 1 << (src_format & 0xff);
-        pDestPalette = FX_Alloc(FX_DWORD, palsize);
+        pDestPalette = FX_Alloc(uint32_t, palsize);
         if (palsize == 2) {
           pDestPalette[0] = isSrcCmyk ? 255 : 0xff000000;
           pDestPalette[1] = isSrcCmyk ? 0 : 0xffffffff;
         } else {
           for (int i = 0; i < palsize; i++) {
             pDestPalette[i] = isSrcCmyk ? FX_CCOLOR(i) : (i * 0x10101);
           }
         }
         if (isSrcCmyk != isDstCmyk) {
           for (int i = 0; i < palsize; i++) {
@@ skipping 16 matching lines @@
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ScanlineCompositor::~CFX_ScanlineCompositor() {
   FX_Free(m_pSrcPalette);
   FX_Free(m_pCacheScanline);
 }
 FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format,
                                      FXDIB_Format src_format,
                                      int32_t width,
-                                     FX_DWORD* pSrcPalette,
-                                     FX_DWORD mask_color,
+                                     uint32_t* pSrcPalette,
+                                     uint32_t mask_color,
                                      int blend_type,
                                      FX_BOOL bClip,
                                      FX_BOOL bRgbByteOrder,
                                      int alpha_flag,
                                      void* pIccTransform) {
   m_SrcFormat = src_format;
   m_DestFormat = dest_format;
   m_BlendType = blend_type;
   m_bRgbByteOrder = bRgbByteOrder;
   ICodec_IccModule* pIccModule = NULL;
@@ skipping 509 matching lines @@
                                         dst_scan_extra_alpha);
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left,
                                     int dest_top,
                                     int width,
                                     int height,
                                     const CFX_DIBSource* pMask,
-                                    FX_DWORD color,
+                                    uint32_t color,
                                     int src_left,
                                     int src_top,
                                     int blend_type,
                                     const CFX_ClipRgn* pClipRgn,
                                     FX_BOOL bRgbByteOrder,
                                     int alpha_flag,
                                     void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
@@ skipping 48 matching lines @@
       compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width,
                                        clip_scan, dst_scan_extra_alpha);
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::CompositeRect(int left,
                                     int top,
                                     int width,
                                     int height,
-                                    FX_DWORD color,
+                                    uint32_t color,
                                     int alpha_flag,
                                     void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
   int src_alpha = (alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
   if (src_alpha == 0) {
     return TRUE;
   }
   FX_RECT rect(left, top, left + width, top + height);
   rect.Intersect(0, 0, m_Width, m_Height);
   if (rect.IsEmpty()) {
     return TRUE;
   }
   width = rect.Width();
-  FX_DWORD dst_color;
+  uint32_t dst_color;
   if (alpha_flag >> 8) {
     dst_color = FXCMYK_TODIB(color);
   } else {
     dst_color = FXARGB_TODIB(color);
   }
   uint8_t* color_p = (uint8_t*)&dst_color;
   if (m_bpp == 8) {
     uint8_t gray = 255;
     if (!IsAlphaMask()) {
       if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
@@ skipping 93 matching lines @@
   if (src_alpha == 255) {
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
       uint8_t* dest_scan_alpha =
           m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left
                        : NULL;
       if (dest_scan_alpha) {
         FXSYS_memset(dest_scan_alpha, 0xff, width);
       }
       if (Bpp == 4) {
-        FX_DWORD* scan = (FX_DWORD*)dest_scan;
+        uint32_t* scan = (uint32_t*)dest_scan;
         for (int col = 0; col < width; col++) {
           *scan++ = dst_color;
         }
       } else {
         for (int col = 0; col < width; col++) {
           *dest_scan++ = color_p[0];
           *dest_scan++ = color_p[1];
           *dest_scan++ = color_p[2];
         }
       }
@@ skipping 70 matching lines @@
 }
 CFX_BitmapComposer::~CFX_BitmapComposer() {
   FX_Free(m_pScanlineV);
   FX_Free(m_pScanlineAlphaV);
   FX_Free(m_pClipScanV);
   FX_Free(m_pAddClipScan);
 }
 void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest,
                                  const CFX_ClipRgn* pClipRgn,
                                  int bitmap_alpha,
-                                 FX_DWORD mask_color,
+                                 uint32_t mask_color,
                                  FX_RECT& dest_rect,
                                  FX_BOOL bVertical,
                                  FX_BOOL bFlipX,
                                  FX_BOOL bFlipY,
                                  FX_BOOL bRgbByteOrder,
                                  int alpha_flag,
                                  void* pIccTransform,
                                  int blend_type) {
   m_pBitmap = pDest;
   m_pClipRgn = pClipRgn;
@@ skipping 11 matching lines @@
   m_bFlipX = bFlipX;
   m_bFlipY = bFlipY;
   m_AlphaFlag = alpha_flag;
   m_pIccTransform = pIccTransform;
   m_bRgbByteOrder = bRgbByteOrder;
   m_BlendType = blend_type;
 }
 FX_BOOL CFX_BitmapComposer::SetInfo(int width,
                                     int height,
                                     FXDIB_Format src_format,
-                                    FX_DWORD* pSrcPalette) {
+                                    uint32_t* pSrcPalette) {
   m_SrcFormat = src_format;
   if (!m_Compositor.Init(m_pBitmap->GetFormat(), src_format, width, pSrcPalette,
                          m_MaskColor, FXDIB_BLEND_NORMAL,
                          m_pClipMask != NULL || (m_BitmapAlpha < 255),
                          m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform)) {
     return FALSE;
   }
   if (m_bVertical) {
     m_pScanlineV = FX_Alloc(uint8_t, m_pBitmap->GetBPP() / 8 * width + 4);
     m_pClipScanV = FX_Alloc(uint8_t, m_pBitmap->GetHeight());
@@ skipping 129 matching lines @@
   }
   src_alpha_scan = m_pScanlineAlphaV;
   dest_alpha_scan = dest_alpha_buf;
   if (dest_alpha_scan) {
     for (i = 0; i < m_DestHeight; i++) {
       *dest_alpha_scan = *src_alpha_scan++;
       dest_alpha_scan += y_alpha_step;
     }
   }
 }