Use stdint.h types throughout PDFium.

core/src/fxge/agg/agg23/fx_agg_driver.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_ge.h"
 #include "../../dib/dib_int.h"
 #include "../../ge/text_int.h"
 #include "../../../../include/fxcodec/fx_codec.h"
@@ skipping 384 matching lines @@
         }
         if (m_bRgbByteOrder) {
             if (Bpp == 4 && bDestAlpha) {
                 for (int col = col_start; col < col_end; col ++) {
                     int src_alpha;
                     if (clip_scan) {
                         src_alpha = m_Alpha * clip_scan[col] / 255;
                     } else {
                         src_alpha = m_Alpha;
                     }
-                    FX_BYTE dest_alpha = ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255;
+                    uint8_t dest_alpha = ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255;
                     dest_scan[3] = dest_alpha;
                     int alpha_ratio = src_alpha * 255 / dest_alpha;
                     if (m_bFullCover) {
                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio);
                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio);
                         dest_scan++;
                         ori_scan++;
                     } else {
                         int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
@@ skipping 53 matching lines @@
                     continue;
                 } else {
                     if (dest_scan[3] == 0) {
                         dest_scan[3] = src_alpha_covered;
                         *dest_scan ++ = m_Blue;
                         *dest_scan ++ = m_Green;
                         *dest_scan = m_Red;
                         dest_scan += 2;
                         continue;
                     }
-                    FX_BYTE cover = cover_scan[col];
+                    uint8_t cover = cover_scan[col];
                     dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover);
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover);
                     dest_scan += 2;
                 }
             }
             return;
@@ skipping 38 matching lines @@
                     *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
                 } else {
                     int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]);
                     dest_scan++;
                 }
             }
         } else {
             int index = 0;
             if (m_pDevice->GetPalette() == NULL) {
-                index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
+                index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
             } else {
                 for (int i = 0; i < 2; i ++)
                     if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
                         index = i;
                     }
             }
             FX_LPBYTE dest_scan1 = dest_scan;
             for (int col = col_start; col < col_end; col ++) {
                 int src_alpha;
                 if (clip_scan) {
@@ skipping 17 matching lines @@
                            int clip_left, int clip_right, FX_LPBYTE clip_scan,
                            FX_LPBYTE dest_extra_alpha_scan)
     {
         ASSERT(!m_bRgbByteOrder);
         ASSERT(!m_pDevice->IsCmykImage());
         int col_start = span_left < clip_left ? clip_left - span_left : 0;
         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
         dest_scan += col_start / 8;
         int index = 0;
         if (m_pDevice->GetPalette() == NULL) {
-            index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
+            index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
         } else {
             for (int i = 0; i < 2; i ++)
                 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
                     index = i;
                 }
         }
         FX_LPBYTE dest_scan1 = dest_scan;
         for (int col = col_start; col < col_end; col ++) {
             int src_alpha;
             if (clip_scan) {
@@ skipping 34 matching lines @@
                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
                     } else {
                         src_alpha = m_Alpha * cover_scan[col] / 255;
                     }
                 }
                 if (src_alpha) {
                     if (src_alpha == 255) {
                         *dest_scan = m_Gray;
                         *dest_extra_alpha_scan = m_Alpha;
                     } else {
-                        FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
+                        uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
                                              (*dest_extra_alpha_scan) * src_alpha / 255;
                         *dest_extra_alpha_scan++ = dest_alpha;
                         int alpha_ratio = src_alpha * 255 / dest_alpha;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
                         dest_scan ++;
                         continue;
                     }
                 }
                 dest_extra_alpha_scan ++;
                 dest_scan ++;
@@ skipping 38 matching lines @@
                     if (clip_scan) {
                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
                     } else {
                         src_alpha = m_Alpha * cover_scan[col] / 255;
                     }
                 }
                 if (src_alpha) {
                     if (src_alpha == 255) {
                         *(FX_DWORD*)dest_scan = m_Color;
                     } else {
-                        FX_BYTE dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
+                        uint8_t dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
                         dest_scan[3] = dest_alpha;
                         int alpha_ratio = src_alpha * 255 / dest_alpha;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
                         dest_scan += 2;
                         continue;
                     }
@@ skipping 22 matching lines @@
                     *(FX_DWORD*)dest_scan = m_Color;
                 } else {
                     if (dest_scan[3] == 0) {
                         dest_scan[3] = src_alpha;
                         *dest_scan++ = m_Blue;
                         *dest_scan++ = m_Green;
                         *dest_scan = m_Red;
                         dest_scan += 2;
                         continue;
                     }
-                    FX_BYTE dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
+                    uint8_t dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
                     dest_scan[3] = dest_alpha;
                     int alpha_ratio = src_alpha * 255 / dest_alpha;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
                     dest_scan ++;
                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
                     dest_scan += 2;
                     continue;
                 }
@@ skipping 52 matching lines @@
                     }
                 } else {
                     if (clip_scan) {
                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
                     } else {
                         src_alpha = m_Alpha * cover_scan[col] / 255;
                     }
                 }
                 if (src_alpha) {
                     if (src_alpha == 255) {
-                        *dest_scan++ = (FX_BYTE)m_Blue;
-                        *dest_scan++ = (FX_BYTE)m_Green;
-                        *dest_scan++ = (FX_BYTE)m_Red;
-                        *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
+                        *dest_scan++ = (uint8_t)m_Blue;
+                        *dest_scan++ = (uint8_t)m_Green;
+                        *dest_scan++ = (uint8_t)m_Red;
+                        *dest_extra_alpha_scan++ = (uint8_t)m_Alpha;
                         continue;
                     } else {
-                        FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
+                        uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
                                              (*dest_extra_alpha_scan) * src_alpha / 255;
                         *dest_extra_alpha_scan++ = dest_alpha;
                         int alpha_ratio = src_alpha * 255 / dest_alpha;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
                         dest_scan ++;
                         continue;
@@ skipping 63 matching lines @@
                 } else {
                     if (clip_scan) {
                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
                     } else {
                         src_alpha = m_Alpha * cover_scan[col] / 255;
                     }
                 }
                 if (src_alpha) {
                     if (src_alpha == 255) {
                         *(FX_CMYK*)dest_scan = m_Color;
-                        *dest_extra_alpha_scan = (FX_BYTE)m_Alpha;
+                        *dest_extra_alpha_scan = (uint8_t)m_Alpha;
                     } else {
-                        FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
+                        uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
                                              (*dest_extra_alpha_scan) * src_alpha / 255;
                         *dest_extra_alpha_scan++ = dest_alpha;
                         int alpha_ratio = src_alpha * 255 / dest_alpha;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
@@ skipping 113 matching lines @@
         } else {
             pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         }
         if (m_pDevice->GetBPP() == 8) {
             ASSERT(!m_bRgbByteOrder);
             composite_span = &CFX_Renderer::CompositeSpanGray;
             if (m_pDevice->IsAlphaMask()) {
                 m_Gray = 255;
             } else {
                 if (pIccTransform) {
-                    FX_BYTE gray;
+                    uint8_t gray;
                     color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
                     pIccModule->TranslateScanline(pIccTransform, &gray, (FX_LPCBYTE)&color, 1);
                     m_Gray = gray;
                 } else {
                     if (bObjectCMYK) {
-                        FX_BYTE r, g, b;
+                        uint8_t r, g, b;
                         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                            r, g, b);
                         m_Gray = FXRGB2GRAY(r, g, b);
                     } else {
                         m_Gray = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
                     }
                 }
             }
             return TRUE;
         }
@@ skipping 24 matching lines @@
                 ((FX_LPBYTE)&m_Color)[3] = m_Alpha;
                 m_Red = ((FX_LPBYTE)&m_Color)[2];
                 m_Green = ((FX_LPBYTE)&m_Color)[1];
                 m_Blue = ((FX_LPBYTE)&m_Color)[0];
                 if (m_bRgbByteOrder) {
                     m_Color = FXARGB_TODIB(m_Color);
                     m_Color = FXARGB_TOBGRORDERDIB(m_Color);
                 }
             } else {
                 if (bObjectCMYK) {
-                    FX_BYTE r, g, b;
+                    uint8_t r, g, b;
                     AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                        r, g, b);
                     m_Color = FXARGB_MAKE(m_Alpha, r, g, b);
                     if (m_bRgbByteOrder) {
                         m_Color = FXARGB_TOBGRORDERDIB(m_Color);
                     } else {
                         m_Color = FXARGB_TODIB(m_Color);
                     }
                     m_Red = r;
                     m_Green = g;
@@ skipping 91 matching lines @@
             return FALSE;
         }
     }
     return TRUE;
 }
 void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb)
 {
     if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) {
         return;
     }
-    FX_LPBYTE pos = (FX_BYTE*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() + x * pBitmap->GetBPP() / 8;
+    FX_LPBYTE pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() + x * pBitmap->GetBPP() / 8;
     if (pBitmap->GetFormat() == FXDIB_Argb) {
         FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
     } else {
         int alpha = FXARGB_A(argb);
         pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
         pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255;
         pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255;
     }
 }
 void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap, int left, int top, int width, int height, FX_ARGB argb)
 {
     int src_alpha = FXARGB_A(argb);
     if (src_alpha == 0) {
         return;
     }
     FX_RECT rect(left, top, left + width, top + height);
     rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
     width = rect.Width();
     int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb);
     int Bpp = pBitmap->GetBPP() / 8;
     FX_BOOL bAlpha = pBitmap->HasAlpha();
     int dib_argb = FXARGB_TOBGRORDERDIB(argb);
-    FX_BYTE* pBuffer = pBitmap->GetBuffer();
+    uint8_t* pBuffer = pBitmap->GetBuffer();
     if (src_alpha == 255) {
         for (int row = rect.top; row < rect.bottom; row ++) {
             FX_LPBYTE dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
             if (Bpp == 4) {
                 FX_DWORD* scan = (FX_DWORD*)dest_scan;
                 for (int col = 0; col < width; col ++) {
                     *scan ++ = dib_argb;
                 }
             } else {
                 for (int col = 0; col < width; col ++) {
                     *dest_scan ++ = src_r;
                     *dest_scan ++ = src_g;
                     *dest_scan ++ = src_b;
                 }
             }
         }
         return;
     }
     src_r = FX_GAMMA(src_r);
     src_g = FX_GAMMA(src_g);
     src_b = FX_GAMMA(src_b);
     for (int row = rect.top; row < rect.bottom; row ++) {
         FX_LPBYTE dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
         if (bAlpha) {
             for (int col = 0; col < width; col ++) {
-                FX_BYTE back_alpha = dest_scan[3];
+                uint8_t back_alpha = dest_scan[3];
                 if (back_alpha == 0) {
                     FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
                     dest_scan += 4;
                     continue;
                 }
-                FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
+                uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
                 dest_scan[3] = dest_alpha;
                 int alpha_ratio = src_alpha * 255 / dest_alpha;
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
                 dest_scan++;
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
                 dest_scan++;
                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
                 dest_scan += 2;
             }
         } else {
@@ skipping 18 matching lines @@
         return;
     }
     pBitmap->GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
     if (width == 0 || height == 0) {
         return;
     }
     int Bpp = pBitmap->GetBPP() / 8;
     FXDIB_Format dest_format = pBitmap->GetFormat();
     FXDIB_Format src_format = pSrcBitmap->GetFormat();
     int pitch = pBitmap->GetPitch();
-    FX_BYTE* buffer = pBitmap->GetBuffer();
+    uint8_t* buffer = pBitmap->GetBuffer();
     if (dest_format == src_format) {
         for (int row = 0; row < height; row ++) {
             FX_LPBYTE dest_scan = buffer + (dest_top + row) * pitch + dest_left * Bpp;
             FX_LPBYTE src_scan = (FX_LPBYTE)pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
             if (Bpp == 4) {
                 for (int col = 0; col < width; col ++) {
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_scan[3], src_scan[0], src_scan[1], src_scan[2]));
                     dest_scan += 4;
                     src_scan += 4;
                 }
             } else {
                 for (int col = 0; col < width; col ++) {
                     *dest_scan++ = src_scan[2];
                     *dest_scan++ = src_scan[1];
                     *dest_scan++ = src_scan[0];
                     src_scan += 3;
                 }
             }
         }
         return;
     }
     FX_LPBYTE dest_buf = buffer + dest_top * pitch + dest_left * Bpp;
     if (dest_format == FXDIB_Rgb) {
         if (src_format == FXDIB_Rgb32) {
             for (int row = 0; row < height; row ++) {
                 FX_LPBYTE dest_scan = dest_buf + row * pitch;
-                FX_LPBYTE src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
+                FX_LPBYTE src_scan = (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
                 for (int col = 0; col < width; col ++) {
                     *dest_scan++ = src_scan[2];
                     *dest_scan++ = src_scan[1];
                     *dest_scan++ = src_scan[0];
                     src_scan += 4;
                 }
             }
         } else {
             ASSERT(FALSE);
         }
     } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
         if (src_format == FXDIB_Rgb) {
             for (int row = 0; row < height; row ++) {
-                FX_BYTE* dest_scan = (FX_BYTE*)(dest_buf + row * pitch);
-                FX_LPBYTE src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
+                uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
+                FX_LPBYTE src_scan = (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
                 if (src_format == FXDIB_Argb) {
                     for (int col = 0; col < width; col ++) {
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]), FX_GAMMA(src_scan[1]), FX_GAMMA(src_scan[2])));
                         dest_scan += 4;
                         src_scan += 3;
                     }
                 } else {
                     for (int col = 0; col < width; col ++) {
                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2]));
                         dest_scan += 4;
@@ skipping 10 matching lines @@
                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2]));
                     src_scan  += 4;
                     dest_scan += 4;
                 }
             }
         }
     } else {
         ASSERT(FALSE);
     }
 }
-FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, FX_BYTE alpha)
+FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha)
 {
-    FX_BYTE r, g, b;
+    uint8_t r, g, b;
     AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk),
                        r, g, b);
     return ArgbEncode(alpha, r, g, b);
 }
 FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
     int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ skipping 226 matching lines @@
     IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
     SetDeviceDriver(pDriver);
     return TRUE;
 }
 CFX_FxgeDevice::~CFX_FxgeDevice()
 {
     if (m_bOwnedBitmap && GetBitmap()) {
         delete GetBitmap();
     }
 }