Merge to XFA: Use stdint.h types throughout PDFium.

core/src/fxge/skia/fx_skia_blitter_new.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.
 
 #include "../../../include/fxge/fx_ge.h"
 //#define _SKIA_SUPPORT_
 #if defined(_SKIA_SUPPORT_)
 #include "../../../include/fxcodec/fx_codec.h"
 #include "SkBlitter.h"
 #include "fx_skia_blitter_new.h"
@@ skipping 56 matching lines @@
         {
                 blitV(x++, y, height, leftAlpha);
                 if (width > 0) {
                         blitRect(x, y, width, height);
                         x += width;
                 }
                 blitV(x, y, height, rightAlpha);
         }
         /*---------------------------------------------------------------------------------------------------*/
         void CFX_SkiaRenderer::CompositeSpan1bpp_0(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left/8;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left/8;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 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;
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         if (src_alpha) {
                                 if (!index)
                                         *dest_scan1 &= ~(1 << (7 - (col+span_left)%8));
                                 else
                                         *dest_scan1|= 1 << (7 - (col+span_left)%8);
                         } 
                         dest_scan1 = dest_scan+(span_left%8+col-col_start+1)/8;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpan1bpp_4(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left/8;
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left/8;
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 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;
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha * clip_scan[col] / 255;
                         if (src_alpha1) {
                                 if (!index)
                                         *dest_scan1 &= ~(1 << (7 - (col+span_left)%8));
                                 else
                                         *dest_scan1|= 1 << (7 - (col+span_left)%8);
                         } 
                         dest_scan1 = dest_scan+(span_left%8+col-col_start+1)/8;
                 }
         }
         /*-----------------------------------------------------------------------------------------------------*/
         void CFX_SkiaRenderer::CompositeSpanGray_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 ASSERT(!m_bRgbByteOrder);
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start;
                 if (cover_scan == 255 && m_Alpha == 255) {
                         FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
                         return;
                 }
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
                         dest_scan++;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanGray_3(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 ASSERT(!m_bRgbByteOrder);
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start;
                 ori_scan += col_start;
                 if (m_Alpha == 255 && cover_scan == 255) {
                         FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
                 } else {
                         int src_alpha = m_Alpha;
 #if 1
@@ skipping 15 matching lines @@
                                         int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
                                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
                                         dest_scan++;
                                 }
                         }
 #endif
                 }
         }
 
         void CFX_SkiaRenderer::CompositeSpanGray_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start;
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha * clip_scan[col] / 255;
                         if (!src_alpha1) {
                                 dest_scan ++;
                                 continue;
                         }
                         if (src_alpha1 == 255)
                                 *dest_scan++ = m_Gray;
                         else {
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha1);
                                 dest_scan ++;
                         }
                 }       
         }
 
         void CFX_SkiaRenderer::CompositeSpanGray_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left;
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start;
                 ori_scan += col_start;
 #if 1
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha = m_Alpha * clip_scan[col] / 255;
                         if (src_alpha == 255 && cover_scan == 255) {
                                 *dest_scan++ = m_Gray;
@@ skipping 32 matching lines @@
                                 int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
                                 dest_scan++;
                         }
                 }
 #endif
         }
         /*--------------------------------------------------------------------------------------------------*/
 
         void CFX_SkiaRenderer::CompositeSpanARGB_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start<<2;
                 if (m_Alpha == 255 && cover_scan == 255) {
                         FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
                         return;
                 }
                 int src_alpha;
 #if 0
@@ skipping 10 matching lines @@
                         // Dest format: Argb
                         // calculate destination alpha (it's union of source and dest alpha)
                         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;
                 }
         }
 
         void CFX_SkiaRenderer::CompositeSpanARGB_3(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                //ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                //ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
                 //ori_scan += col_start << 2;
 
                 if (m_Alpha == 255 && cover_scan == 255){
                         FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
                         return;
                 }               
@@ skipping 22 matching lines @@
                         dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], m_Alpha, cover_scan);
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
                         dest_scan += 2;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanARGB_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
 #if 1
                 int src_alpha = m_Alpha * cover_scan / 255; 
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha* clip_scan[col] / 255;
                         if (!src_alpha1) {
                                 dest_scan += 4;
                                 continue;
                         }
                         if (src_alpha1 == 255) {
                                 *(FX_DWORD*)dest_scan = m_Color;
                                 dest_scan += 4;
                         } else {
                                 // Dest format: Argb
                                 // calculate destination alpha (it's union of source and dest alpha)
                                 if (dest_scan[3] == 0) {
                                         dest_scan[3] = src_alpha1;
                                         *dest_scan++ = m_Blue;
                                         *dest_scan++ = m_Green;
                                         *dest_scan = m_Red;
                                         dest_scan += 2; 
                                         continue;
                                 }
-                                FX_BYTE dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
+                                uint8_t dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
                                 dest_scan[3] = dest_alpha;
                                 int alpha_ratio = src_alpha1*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;
                         }
                 }
@@ skipping 13 matching lines @@
                                         // Dest format: Argb
                                         // calculate destination alpha (it's union of source and dest alpha)
                                         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;
                                 }
                         }
@@ skipping 12 matching lines @@
                                         // Dest format: Argb
                                         // calculate destination alpha (it's union of source and dest alpha)
                                         if (dest_scan[3] == 0) {
                                                 dest_scan[3] = src_alpha1;
                                                 *dest_scan++ = m_Blue;
                                                 *dest_scan++ = m_Green;
                                                 *dest_scan = m_Red;
                                                 dest_scan += 2; 
                                                 continue;
                                         }
-                                        FX_BYTE dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
+                                        uint8_t dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
                                         dest_scan[3] = dest_alpha;
                                         int alpha_ratio = src_alpha1*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;
                                 }
                         }
                 }
 #endif
         }
 
         void CFX_SkiaRenderer::CompositeSpanARGB_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                //ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                //ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
                 //ori_scan += col_start << 2;
                 // Do not need origin bitmap, because of merge in pure transparent background
                 for (int col = col_start; col < col_end; col ++) 
                 {
                         int src_alpha = m_Alpha * clip_scan[col] / 255;
                         int src_alpha_covered = src_alpha * cover_scan / 255;
@@ skipping 22 matching lines @@
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
                         dest_scan += 2;
                 }
         }
         
         /*-----------------------------------------------------------------------------------------------------------*/
         void CFX_SkiaRenderer::CompositeSpanRGB32_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += (col_start << 2);
                 if (m_Alpha == 255 && cover_scan == 255) {
                         FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
                         return;
                 }
                 int src_alpha;
 #if 0
                 if (m_bFullCover)
                         src_alpha = m_Alpha;
                 else 
 #endif
                         src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         // Dest format:  Rgb32
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
                         dest_scan += 2;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanRGB32_3(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
                 ori_scan += col_start << 2;
                 if (m_Alpha == 255 && cover_scan == 255) {
                         FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
                         return;
                 }
                 int src_alpha = m_Alpha;
@@ skipping 13 matching lines @@
                         ori_scan += 2;
                         *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
                         dest_scan += 2;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanRGB32_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
 #if 1
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha * clip_scan[col] / 255;
                         if (!src_alpha1) {
                                 dest_scan += 4;
@@ skipping 52 matching lines @@
                                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
                                         dest_scan ++;
                                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
                                         dest_scan += 2;
                                 }                               
                         }
                 }                       
 #endif
         }
         void CFX_SkiaRenderer::CompositeSpanRGB32_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start << 2;
                 ori_scan += col_start << 2;
 #if 1
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha = m_Alpha * clip_scan[col] / 255;
                         if (src_alpha == 255 && cover_scan == 255) {
                                 *(FX_DWORD*)dest_scan = m_Color;
@@ skipping 51 matching lines @@
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
                                 dest_scan ++;
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
                                 dest_scan += 2;
                         }
                 }
 #endif
         }
         /*-----------------------------------------------------------------------------------------------------*/
         void CFX_SkiaRenderer::CompositeSpanRGB24_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += (col_start<<1)+col_start;
                 int src_alpha;
 #if 0
                 if (m_bFullCover)
                         src_alpha = m_Alpha;
                 else 
 #endif
                         src_alpha = m_Alpha * cover_scan / 255;
                 if (src_alpha == 255) {
                         for (int col = col_start; col < col_end; col ++) {
                                 *dest_scan++ = m_Blue;
                                 *dest_scan++ = m_Green;
                                 *dest_scan++ = m_Red;
                         }
                         return;
                 }
                 for (int col = col_start; col < col_end; col ++) {
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
                         dest_scan ++;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanRGB24_3(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left + (span_left<<1);
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left + (span_left<<1);
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += (col_start<<1) + col_start;
                 ori_scan += (col_start<<1) + col_start;
                 if (m_Alpha == 255&&cover_scan == 255) {
                         for (int col = col_start; col < col_end; col ++) {
                                 *dest_scan ++ = m_Blue;
                                 *dest_scan ++ = m_Green;
                                 *dest_scan ++ = m_Red;
@@ skipping 14 matching lines @@
                         int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha);
                         *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
                         dest_scan ++;
                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
                         dest_scan ++;
                 }
         }
         void CFX_SkiaRenderer::CompositeSpanRGB24_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start + (col_start << 1);
 #if 1
                 int src_alpha = m_Alpha * cover_scan /255;
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha * clip_scan[col] / 255;      
                         if (!src_alpha1) {
                                 dest_scan += 3;
@@ skipping 54 matching lines @@
                                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
                                         dest_scan ++;
                                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
                                         dest_scan ++;
                                 }
                         }
                 }
 #endif
         }
         void CFX_SkiaRenderer::CompositeSpanRGB24_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
-                ori_scan  = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left+(span_left<<1);
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
+                ori_scan  = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left+(span_left<<1);
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start + (col_start<<1);
                 ori_scan += col_start + (col_start<<1);
 #if 1
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha = m_Alpha * clip_scan[col] / 255;
                         if (src_alpha == 255 && cover_scan == 255) {
                                 *dest_scan++ = m_Blue;
@@ skipping 50 matching lines @@
                                 dest_scan ++;
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
                                 dest_scan ++;
                                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
                                 dest_scan ++;
                         }
                 }
 #endif
         }
         void CFX_SkiaRenderer::CompositeSpanRGB24_10(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
-                dest_extra_alpha_scan =  (FX_BYTE*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
+                dest_extra_alpha_scan =  (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start+(col_start<<1);
 #if 1
                 if (m_Alpha == 255 && cover_scan == 255) {
                         for (int col = col_start; col < col_end; col ++) {
-                                *dest_scan++ = (FX_BYTE)m_Blue;
-                                *dest_scan++ = (FX_BYTE)m_Green;
-                                *dest_scan++ = (FX_BYTE)m_Red;
+                                *dest_scan++ = (uint8_t)m_Blue;
+                                *dest_scan++ = (uint8_t)m_Green;
+                                *dest_scan++ = (uint8_t)m_Red;
                                 *dest_extra_alpha_scan++ = 255;
                         }
                         return;
                 }
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         // Dest format: Rgba
                         // calculate destination alpha (it's union of source and dest alpha)
-                        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 ++;                   
                 }
 #else
                 if (m_bFullCover) {
                         if (m_Alpha == 255) {
                                 for (int col = col_start; col < col_end; col ++) {
-                                        *dest_scan++ = (FX_BYTE)m_Blue;
-                                        *dest_scan++ = (FX_BYTE)m_Green;
-                                        *dest_scan++ = (FX_BYTE)m_Red;
+                                        *dest_scan++ = (uint8_t)m_Blue;
+                                        *dest_scan++ = (uint8_t)m_Green;
+                                        *dest_scan++ = (uint8_t)m_Red;
                                         *dest_extra_alpha_scan++ = 255;
                                 }
                                 return;
                         }
                         for (int col = col_start; col < col_end; col ++) {
                                 // Dest format: Rgba
                                 // calculate destination alpha (it's union of source and dest alpha)
-                                FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + m_Alpha - 
+                                uint8_t dest_alpha = (*dest_extra_alpha_scan) + m_Alpha - 
                                                                         (*dest_extra_alpha_scan) * m_Alpha / 255;
                                 *dest_extra_alpha_scan++ = dest_alpha;
                                 int alpha_ratio = m_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 ++;
                         }
                 } else {
                         if (m_Alpha == 255 && cover_scan == 255) {
                                 for (int col = col_start; col < col_end; col ++) {
-                                        *dest_scan++ = (FX_BYTE)m_Blue;
-                                        *dest_scan++ = (FX_BYTE)m_Green;
-                                        *dest_scan++ = (FX_BYTE)m_Red;
+                                        *dest_scan++ = (uint8_t)m_Blue;
+                                        *dest_scan++ = (uint8_t)m_Green;
+                                        *dest_scan++ = (uint8_t)m_Red;
                                         *dest_extra_alpha_scan++ = 255;
                                 }
                                 return;
                         }
                         int src_alpha = m_Alpha * cover_scan / 255;
                         for (int col = col_start; col < col_end; col ++) {
                                 // Dest format: Rgba
                                 // calculate destination alpha (it's union of source and dest alpha)
-                                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 ++;                   
                         }
                 }
 #endif
         }
         void CFX_SkiaRenderer::CompositeSpanRGB24_14(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
-                dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
-                dest_extra_alpha_scan =  (FX_BYTE*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
-                clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
+                dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
+                dest_extra_alpha_scan =  (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
+                clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start + (col_start << 1);
 #if 1
                 int src_alpha = m_Alpha * cover_scan / 255;
                 for (int col = col_start; col < col_end; col ++) {
                         int src_alpha1 = src_alpha * clip_scan[col] / 255;
                         if (!src_alpha1) {
                                 dest_extra_alpha_scan++;
                                 dest_scan += 3;
                                 continue;
                         }                               
                         if (src_alpha1 == 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;
                         } else {
                                 // Dest format: Rgba
                                 // calculate destination alpha (it's union of source and dest alpha)
-                                FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 - 
+                                uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 - 
                                                                         (*dest_extra_alpha_scan) * src_alpha1 / 255;
                                 *dest_extra_alpha_scan++ = dest_alpha;
                                 int alpha_ratio = src_alpha1*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 ++;
                         }
                 }
 #else
                 if (m_bFullCover) {
                         for (int col = col_start; col < col_end; col ++) {
                                 int src_alpha = m_Alpha * clip_scan[col] / 255;
                                 if (!src_alpha) {
                                         dest_extra_alpha_scan++;
                                         dest_scan += 3;
                                         continue;
                                 }
                                 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;
                                 } else {
                                         // Dest format: Rgba
                                         // calculate destination alpha (it's union of source and dest alpha)
-                                        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 ++;
                                 }
                         }
                 } else {
                         int src_alpha = m_Alpha * cover_scan / 255;
                         for (int col = col_start; col < col_end; col ++) {
                                 int src_alpha1 = m_Alpha * cover_scan * clip_scan[col] / 255;
                                 if (!src_alpha1) {
                                         dest_extra_alpha_scan++;
                                         dest_scan += 3;
                                         continue;
                                 }                               
                                 if (src_alpha1 == 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;
                                 } else {
                                         // Dest format: Rgba
                                         // calculate destination alpha (it's union of source and dest alpha)
-                                        FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 - 
+                                        uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 - 
                                                                                 (*dest_extra_alpha_scan) * src_alpha1 / 255;
                                         *dest_extra_alpha_scan++ = dest_alpha;
                                         int alpha_ratio = src_alpha1*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 ++;
                                 }
                         }
                 }
 #endif
         }
         /*-----------------------------------------------------------------------------------------------------*/
 
         // A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
         void CFX_SkiaRenderer::CompositeSpanCMYK(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
-                        int span_left, int span_len, int span_top, FX_BYTE cover_scan, 
+                        int span_left, int span_len, int span_top, uint8_t cover_scan, 
                         int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan, 
                         FX_LPBYTE dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 // Cmyk(a)
                 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);
                 if (col_end < col_start) return; // do nothing.
                 dest_scan += col_start * 4;
                 Bpp; // for avoid compile warning.
@@ skipping 10 matching lines @@
                                 } else {
                                         if (clip_scan)
                                                 src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255;
                                         else
                                                 src_alpha = m_Alpha * cover_scan / 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 {
                                                 // Dest format: Cmyka
                                                 // calculate destination alpha (it's union of source and dest alpha)
-                                                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 83 matching lines @@
                         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
                 
                 if (m_pDevice->GetBPP() == 8) { // Gray(a) device
                         ASSERT(!m_bRgbByteOrder);
                         if (m_pDevice->IsAlphaMask()) {
                                 //Alpha Mask
                                 m_Gray = 255;
                         } else {
                                 //Gray(a) device
                                 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));
                                         }
                                 }
                         }
                 } else {
                         if (bDeviceCMYK) { // Cmyk(a) Device
@@ skipping 26 matching lines @@
                                         // Need Johnson to improvement it.
                                         if (m_bRgbByteOrder) {
                                                 // swap
                                                 m_Red = ((FX_LPBYTE)&m_Color)[0];
                                                 m_Blue = ((FX_LPBYTE)&m_Color)[2];
                                                 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);
                                                         m_Red = b; m_Green = g; m_Blue = r;//
                                                 }else {
                                                         m_Color = FXARGB_TODIB(m_Color);
                                                         m_Red = r; m_Green = g; m_Blue = b;//
                                                 }
@@ skipping 127 matching lines @@
                 if (dst_y < 0 || dst_y >=  m_pDevice->GetHeight())
                         return;
                 if (x >= m_dstWidth) 
                         return;
                 FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
                 int col_start = x < m_Left ? 0 : x - m_Left;
                 int col_end = x + width;
                 col_end = col_end < m_dstWidth ? col_end - m_Left: m_pDevice->GetWidth();
                 int result = col_end - col_start;
                 if (result > 0) {
-                        FX_BYTE* dest_pos = dest_scan + col_start;
+                        uint8_t* dest_pos = dest_scan + col_start;
                         if (result >= 4)
                                 FXSYS_memset32(dest_pos, 0xffffffff,result);
                         else
                                 FXSYS_memset(dest_pos,255,result);
                 }
         }
         void CFX_SkiaA8Renderer::blitV(int x, int y, int height, SkAlpha alpha)
         {
                 FXSYS_assert(alpha);
                 if (alpha == 255) {
@@ skipping 35 matching lines @@
                 m_pDevice = pDevice;
                 m_Left = Left;
                 m_Top = Top;
                 if (pDevice){
                         m_dstWidth = m_Left + pDevice->GetWidth();
                         m_dstHeight = m_Top + pDevice->GetHeight();
                 }
                 return TRUE;
         }
 #endif