Use stdint.h types throughout PDFium.

core/src/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 "../../../include/fxge/fx_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 const FX_DWORD g_dwWinPalette[256] = {
@@ skipping 99 matching lines @@
     }
 
     FX_DWORD*    GetColorLut()const
     {
         return m_cLut;
     }
     FX_DWORD*    GetAmountLut()const
     {
         return m_aLut;
     }
-    FX_INT32     Getlut()const
+    int32_t     Getlut()const
     {
         return m_lut;
     }
 protected:
     FX_DWORD*    m_pPalette;
     FX_DWORD*    m_cLut;
     FX_DWORD*    m_aLut;
     int          m_lut;
 };
 int _Partition(FX_DWORD* alut, FX_DWORD* clut, int l, int r)
@@ skipping 21 matching lines @@
     return l;
 }
 void _Qsort(FX_DWORD* alut, FX_DWORD* 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, FX_BYTE& r, FX_BYTE& g, FX_BYTE& b)
+void _ColorDecode(FX_DWORD pal_v, uint8_t& r, uint8_t& g, uint8_t& b)
 {
-    r = (FX_BYTE)((pal_v & 0xf00) >> 4);
-    g = (FX_BYTE)(pal_v & 0x0f0);
-    b = (FX_BYTE)((pal_v & 0x00f) << 4);
+    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, int pal_type, FX_DWORD* win_mac_pal, FX_DWORD lut)
 {
     int row, col;
     FX_DWORD lut_1 = lut - 1;
     if (pal_type == FXDIB_PALETTE_LOC) {
         for (row = 0; row < 256; row++) {
             int lut_offset = lut_1 - row;
             if (lut_offset < 0) {
                 lut_offset += 256;
             }
             FX_DWORD color = cLut[lut_offset];
-            FX_BYTE r, g, b;
+            uint8_t r, g, b;
             _ColorDecode(color, r, g, b);
             dest_pal[row] = ((FX_DWORD)r << 16) | ((FX_DWORD)g << 8) | b | 0xff000000;
             aLut[lut_offset] = row;
         }
     } else {
         for (row = 0; row < 256; row++) {
             int lut_offset = lut_1 - row;
             if (lut_offset < 0) {
                 lut_offset += 256;
             }
-            FX_BYTE r, g, b;
+            uint8_t r, g, b;
             _ColorDecode(cLut[lut_offset], r, g, b);
             int error, min_error = 1000000;
             int c_index = 0;
             for (col = 0; col < 256; col++) {
                 FX_DWORD p_color = win_mac_pal[col];
-                int d_r = r - (FX_BYTE)(p_color >> 16);
-                int d_g = g - (FX_BYTE)(p_color >> 8);
-                int d_b = b - (FX_BYTE)p_color;
+                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;
                 error = d_r * d_r + d_g * d_g + d_b * d_b;
                 if (error < min_error) {
                     min_error = error;
                     c_index = col;
                 }
             }
             dest_pal[row] =  win_mac_pal[c_index];
             aLut[lut_offset] = row;
         }
     }
@@ skipping 36 matching lines @@
     }
     if (m_aLut) {
         FX_Free(m_aLut);
         m_aLut = NULL;
     }
     m_cLut = FX_Alloc(FX_DWORD, 4096);
     m_aLut = FX_Alloc(FX_DWORD, 4096);
     int row, col;
     m_lut = 0;
     for (row = 0; row < height; row++) {
-        FX_BYTE* scan_line = (FX_BYTE*)pBitmap->GetScanline(row);
+        uint8_t* scan_line = (uint8_t*)pBitmap->GetScanline(row);
         for (col = 0; col < width; col++) {
-            FX_BYTE* src_port = scan_line + col * bpp;
+            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);
             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++;
         }
     }
     _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
     FX_DWORD* win_mac_pal = NULL;
     if (pal_type == FXDIB_PALETTE_WIN) {
         win_mac_pal = (FX_DWORD*)g_dwWinPalette;
     } else if (pal_type == FXDIB_PALETTE_MAC) {
         win_mac_pal = (FX_DWORD*)g_dwMacPalette;
     }
     _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_1bppMask2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
-    FX_BYTE set_gray, reset_gray;
+    uint8_t set_gray, reset_gray;
     set_gray = 0xff;
     reset_gray = 0x00;
     for (int row = 0; row < height; row ++) {
         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
         FXSYS_memset8(dest_scan, reset_gray, width);
         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = src_left; col < src_left + width; col ++) {
             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                 *dest_scan = set_gray;
             }
             dest_scan ++;
         }
     }
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_8bppMask2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     for (int row = 0; row < height; row ++) {
         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         FXSYS_memcpy32(dest_scan, src_scan, width);
     }
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_1bppPlt2Gray(FX_LPBYTE 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();
-    FX_BYTE gray[2];
+    uint8_t gray[2];
     if (pIccTransform) {
         FX_DWORD plt[2];
         if (pSrcBitmap->IsCmykImage()) {
             plt[0] = FXCMYK_TODIB(src_plt[0]);
             plt[1] = FXCMYK_TODIB(src_plt[1]);
         } else {
             FX_LPBYTE bgr_ptr = (FX_LPBYTE)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]);
             bgr_ptr[5] = FXARGB_R(src_plt[1]);
         }
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, gray, (FX_LPCBYTE)plt, 2);
     } else {
-        FX_BYTE reset_r, reset_g, reset_b,
+        uint8_t reset_r, reset_g, reset_b,
                 set_r, set_g, set_b;
         if (pSrcBitmap->IsCmykImage()) {
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]), FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]),
                                reset_r, reset_g, reset_b);
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[1]), FXSYS_GetMValue(src_plt[1]), FXSYS_GetYValue(src_plt[1]), FXSYS_GetKValue(src_plt[1]),
                                set_r, set_g, set_b);
         } else {
             reset_r = FXARGB_R(src_plt[0]);
             reset_g = FXARGB_G(src_plt[0]);
             reset_b = FXARGB_B(src_plt[0]);
@@ skipping 14 matching lines @@
             }
             dest_scan ++;
         }
     }
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_8bppPlt2Gray(FX_LPBYTE 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();
-    FX_BYTE gray[256];
+    uint8_t gray[256];
     if (pIccTransform) {
         FX_DWORD plt[256];
         if (pSrcBitmap->IsCmykImage()) {
             for (int i = 0; i < 256; i ++) {
                 plt[i] = FXCMYK_TODIB(src_plt[i]);
             }
         } else {
             FX_LPBYTE bgr_ptr = (FX_LPBYTE)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]);
             }
         }
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, gray, (FX_LPCBYTE)plt, 256);
     } else {
         if (pSrcBitmap->IsCmykImage()) {
-            FX_BYTE r, g, b;
+            uint8_t r, g, b;
             for (int i = 0; i < 256; i ++) {
                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
                                    r, g, b);
                 gray[i] = FXRGB2GRAY(r, g, b);
             }
         } else
             for (int i = 0; i < 256; i ++) {
                 gray[i] = FXRGB2GRAY(FXARGB_R(src_plt[i]), FXARGB_G(src_plt[i]), FXARGB_B(src_plt[i]));
             }
     }
@@ skipping 28 matching lines @@
                     src_scan += 4;
                 }
             }
         }
     } else {
         if (pSrcBitmap->IsCmykImage()) {
             for (int row = 0; row < height; row ++) {
                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
                 for (int col = 0; col < width; col ++) {
-                    FX_BYTE r, g, b;
+                    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);
                     *dest_scan++ = FXRGB2GRAY(r, g, b);
                     src_scan += 4;
                 }
             }
         } else {
             for (int row = 0; row < height; row ++) {
                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
@@ skipping 52 matching lines @@
         }
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)plt, (FX_LPCBYTE)plt, plt_size);
         for (int i = 0; i < plt_size; i ++) {
             dst_plt[i] = FXARGB_MAKE(0xff, bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
             bgr_ptr += 3;
         }
     } else {
         if (pSrcBitmap->IsCmykImage()) {
             for (int i = 0; i < plt_size; i ++) {
-                FX_BYTE r, g, b;
+                uint8_t r, g, b;
                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
                                    r, g, b);
                 dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
             }
         } else {
             FXSYS_memcpy32(dst_plt, src_plt, plt_size * 4);
         }
     }
     return TRUE;
 }
 inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
         const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt)
 {
     int bpp = pSrcBitmap->GetBPP() / 8;
     int row, col;
     CFX_Palette palette;
     palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
     FX_DWORD* cLut = palette.GetColorLut();
     FX_DWORD* aLut = palette.GetAmountLut();
     if (cLut == NULL || aLut == NULL) {
         return FALSE;
     }
     int lut = palette.Getlut();
     FX_DWORD* 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;
-            FX_BYTE r, g, b;
+            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);
-                int d_r = r - (FX_BYTE)(p_color >> 16);
-                int d_g = g - (FX_BYTE)(p_color >> 8);
-                int d_b = b - (FX_BYTE)(p_color);
+                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;
         }
     }
-    FX_INT32 lut_1 = lut - 1;
+    int32_t lut_1 = lut - 1;
     for (row = 0; row < height; row ++) {
-        FX_BYTE* src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left;
-        FX_BYTE* dest_scan = dest_buf + row * dest_pitch;
+        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++) {
-            FX_BYTE* src_port = src_scan + col * bpp;
+            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);
             for (int i = lut_1; i >= 0; i--)
                 if (clrindex == cLut[i]) {
-                    *(dest_scan + col) = (FX_BYTE)(aLut[i]);
+                    *(dest_scan + col) = (uint8_t)(aLut[i]);
                     break;
                 }
         }
     }
     FXSYS_memcpy32(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_Rgb2PltRgb8(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* 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);
             pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&plt_entry, (FX_LPCBYTE)&plt_entry, 1);
             *plt = FXARGB_TODIB(plt_entry);
         }
     }
     return ret;
 }
 FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
-    FX_BYTE set_gray, reset_gray;
+    uint8_t set_gray, reset_gray;
     set_gray = 0xff;
     reset_gray = 0x00;
     for (int row = 0; row < height; row ++) {
         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = src_left; col < src_left + width; col ++) {
             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
                 dest_scan[0] = set_gray;
                 dest_scan[1] = set_gray;
                 dest_scan[2] = set_gray;
             } else {
                 dest_scan[0] = reset_gray;
                 dest_scan[1] = reset_gray;
                 dest_scan[2] = reset_gray;
             }
             dest_scan += comps;
         }
     }
     return TRUE;
 }
 FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
     for (int row = 0; row < height; row ++) {
         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
-        FX_BYTE src_pixel;
+        uint8_t src_pixel;
         for (int col = 0; col < width; col ++) {
             src_pixel = *src_scan++;
             *dest_scan++ = src_pixel;
             *dest_scan++ = src_pixel;
             *dest_scan   = src_pixel;
             dest_scan += comps - 2;
         }
     }
     return TRUE;
 }
@@ skipping 355 matching lines @@
             FX_LPBYTE scanline = m_pBuffer + row * m_Pitch + 3;
             for (int col = 0; col < m_Width; col ++) {
                 *scanline = 0xff;
                 scanline += 4;
             }
         }
         return TRUE;
     }
     int dest_bpp = dest_format & 0xff;
     int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
-    FX_LPBYTE dest_buf = FX_TryAlloc(FX_BYTE, dest_pitch * m_Height + 4);
+    FX_LPBYTE dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
     if (dest_buf == NULL) {
         return FALSE;
     }
     CFX_DIBitmap* pAlphaMask = NULL;
     if (dest_format == FXDIB_Argb) {
         FXSYS_memset8(dest_buf, 0xff, dest_pitch * m_Height + 4);
         if (m_pAlphaMask) {
             for (int row = 0; row < m_Height; row ++) {
                 FX_LPBYTE pDstScanline = dest_buf + row * dest_pitch + 3;
                 FX_LPCBYTE pSrcScanline = m_pAlphaMask->GetScanline(row);
@@ skipping 44 matching lines @@
     m_pAlphaMask = pAlphaMask;
     if (m_pPalette) {
         FX_Free(m_pPalette);
     }
     m_pPalette = pal_8bpp;
     if (!m_bExtBuf) {
         FX_Free(m_pBuffer);
     }
     m_bExtBuf = FALSE;
     m_pBuffer = dest_buf;
-    m_bpp = (FX_BYTE)dest_format;
-    m_AlphaFlag = (FX_BYTE)(dest_format >> 8);
+    m_bpp = (uint8_t)dest_format;
+    m_AlphaFlag = (uint8_t)(dest_format >> 8);
     m_Pitch = dest_pitch;
     return TRUE;
 }