Remove typdefs for pointer types in fx_system.h

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 55 matching lines @@
                              SkAlpha leftAlpha, SkAlpha rightAlpha) 
         {
                 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,
+        void CFX_SkiaRenderer::CompositeSpan1bpp_0(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 ASSERT(!m_pDevice->IsCmykImage());
                 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 = ((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;
+                uint8_t* 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,
+        void CFX_SkiaRenderer::CompositeSpan1bpp_4(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 ASSERT(!m_pDevice->IsCmykImage());
                 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 = ((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;
+                uint8_t* 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,
+        void CFX_SkiaRenderer::CompositeSpanGray_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 ASSERT(!m_bRgbByteOrder);
                 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,
+        void CFX_SkiaRenderer::CompositeSpanGray_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 ASSERT(!m_bRgbByteOrder);
                 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;
@@ skipping 19 matching lines @@
                                 for (int col = col_start; col < col_end; col ++) {
                                         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,
+        void CFX_SkiaRenderer::CompositeSpanGray_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_bRgbByteOrder);
                 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,
+        void CFX_SkiaRenderer::CompositeSpanGray_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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;
@@ skipping 36 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,
+        void CFX_SkiaRenderer::CompositeSpanARGB_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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;
                 }
@@ skipping 24 matching lines @@
                         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,
+        void CFX_SkiaRenderer::CompositeSpanARGB_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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;
 
@@ skipping 25 matching lines @@
                         // alpha cover       color cover
                         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,
+        void CFX_SkiaRenderer::CompositeSpanARGB_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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 ++) {
@@ skipping 91 matching lines @@
                                         *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,
+        void CFX_SkiaRenderer::CompositeSpanARGB_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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;
@@ skipping 26 matching lines @@
                         *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::CompositeSpanRGB32_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
+        void CFX_SkiaRenderer::CompositeSpanRGB32_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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,
+        void CFX_SkiaRenderer::CompositeSpanRGB32_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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);
@@ skipping 15 matching lines @@
                         int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
                         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,
+        void CFX_SkiaRenderer::CompositeSpanRGB32_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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 ++) {
@@ skipping 54 matching lines @@
                                         dest_scan ++;
                                         *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,
+        void CFX_SkiaRenderer::CompositeSpanRGB32_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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;
@@ skipping 55 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 += 2;
                         }
                 }
 #endif
         }
         /*-----------------------------------------------------------------------------------------------------*/
-        void CFX_SkiaRenderer::CompositeSpanRGB24_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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;
@@ skipping 10 matching lines @@
                 }
                 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,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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) {
@@ skipping 17 matching lines @@
                         int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha);
                         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,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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 ++) {
@@ skipping 56 matching lines @@
                                         dest_scan ++;
                                         *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,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 ASSERT(!m_pDevice->IsCmykImage());
                 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);
@@ skipping 54 matching lines @@
                                 *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 ++;
                         }
                 }
 #endif
         }
-        void CFX_SkiaRenderer::CompositeSpanRGB24_10(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_10(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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 ++) {
@@ skipping 65 matching lines @@
                                 *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,
+        void CFX_SkiaRenderer::CompositeSpanRGB24_14(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* dest_extra_alpha_scan)
         {
                 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;
@@ skipping 81 matching lines @@
                                         *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,
+        void CFX_SkiaRenderer::CompositeSpanCMYK(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
                         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)
+                        int clip_top, int clip_left, int clip_right, uint8_t* clip_scan, 
+                        uint8_t* 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.
                 
                 if (dest_extra_alpha_scan) {
@@ skipping 118 matching lines @@
                 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) {
                                         uint8_t gray;
                                         color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-                                        pIccModule->TranslateScanline(pIccTransform, &gray, (FX_LPCBYTE)&color, 1);
+                                        pIccModule->TranslateScanline(pIccTransform, &gray, (const uint8_t*)&color, 1);
                                         m_Gray = gray;
                                 } else {
                                         if (bObjectCMYK) {
                                                 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
                                 ASSERT(!m_bRgbByteOrder);
                                 //TODO... opt for cmyk
                                 composite_span = &CFX_SkiaRenderer::CompositeSpanCMYK;
                                 if (bObjectCMYK) { 
                                         m_Color = FXCMYK_TODIB(color);
                                         if (pIccTransform)
-                                                pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&m_Color, 1);
+                                                pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&m_Color, 1);
                                 } else { // Object RGB
                                         if (!pIccTransform)
                                                 return FALSE;
                                         color = FXARGB_TODIB(color);
-                                        pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
+                                        pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1);
                                 }
-                                m_Red   = ((FX_LPBYTE)&m_Color)[0];
-                                m_Green = ((FX_LPBYTE)&m_Color)[1];
-                                m_Blue  = ((FX_LPBYTE)&m_Color)[2];
-                                m_Gray  = ((FX_LPBYTE)&m_Color)[3];
+                                m_Red   = ((uint8_t*)&m_Color)[0];
+                                m_Green = ((uint8_t*)&m_Color)[1];
+                                m_Blue  = ((uint8_t*)&m_Color)[2];
+                                m_Gray  = ((uint8_t*)&m_Color)[3];
                                 return TRUE;
                         } else { 
                                 if (pIccTransform) {
                                         color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-                                        pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
-                                        ((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];
+                                        pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1);
+                                        ((uint8_t*)&m_Color)[3] = m_Alpha;
+                                        m_Red = ((uint8_t*)&m_Color)[2];
+                                        m_Green = ((uint8_t*)&m_Color)[1];
+                                        m_Blue = ((uint8_t*)&m_Color)[0];
                                         // Need Johnson to improvement it.
                                         if (m_bRgbByteOrder) {
                                                 // swap
-                                                m_Red = ((FX_LPBYTE)&m_Color)[0];
-                                                m_Blue = ((FX_LPBYTE)&m_Color)[2];
+                                                m_Red = ((uint8_t*)&m_Color)[0];
+                                                m_Blue = ((uint8_t*)&m_Color)[2];
                                                 m_Color = FXARGB_TODIB(m_Color);
                                                 m_Color = FXARGB_TOBGRORDERDIB(m_Color);
                                         }
                                 } else {
                                         if (bObjectCMYK) {
                                                 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){
@@ skipping 90 matching lines @@
         }
 
         /*----------------------------------------------------------------------------------------------------*/
         void CFX_SkiaA8Renderer::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
         {
                 FXSYS_assert(m_pDevice);
                 int dst_y = y - m_Top;
                 if (dst_y < 0 || dst_y >=  m_pDevice->GetHeight())
                         return;
                 
-                FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
-                FX_LPBYTE dest_pos = dest_scan;
+                uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
+                uint8_t* dest_pos = dest_scan;
                 while (1)
                 {
                         if (x >= m_dstWidth) 
                                 return;
                         int width = runs[0];
                         SkASSERT(width >= 0);
                         if (width <= 0) 
                                 return;
                         unsigned aa = antialias[0];
                         if (aa) {
@@ skipping 15 matching lines @@
                 }
         }
         void CFX_SkiaA8Renderer::blitH(int x, int y, int width)
         {
                 FXSYS_assert(m_pDevice);
                 int dst_y = y - m_Top;
                 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;
+                uint8_t* 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) {
                         uint8_t* dest_pos = dest_scan + col_start;
                         if (result >= 4)
                                 FXSYS_memset32(dest_pos, 0xffffffff,result);
                         else
                                 FXSYS_memset(dest_pos,255,result);
@@ skipping 41 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