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

core/src/fxge/dib/fx_dib_main.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxge/fx_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
@@ skipping 44 matching lines @@
 CFX_DIBitmap::CFX_DIBitmap()
 {
     m_bExtBuf = FALSE;
     m_pBuffer = NULL;
     m_pPalette = NULL;
 }
 #define _MAX_OOM_LIMIT_ 12000000
 FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, FX_LPBYTE pBuffer, int pitch)
 {
     m_pBuffer = NULL;
-    m_bpp = (FX_BYTE)format;
-    m_AlphaFlag = (FX_BYTE)(format >> 8);
+    m_bpp = (uint8_t)format;
+    m_AlphaFlag = (uint8_t)(format >> 8);
     m_Width = m_Height = m_Pitch = 0;
     if (width <= 0 || height <= 0 || pitch < 0) {
         return FALSE;
     }
     if ((INT_MAX - 31) / width < (format & 0xff)) {
         return FALSE;
     }
     if (!pitch) {
         pitch = (width * (format & 0xff) + 31) / 32 * 4;
     }
     if ((1 << 30) / pitch < height) {
         return FALSE;
     }
     if (pBuffer) {
         m_pBuffer = pBuffer;
         m_bExtBuf = TRUE;
     } else {
         int size = pitch * height + 4;
         int oomlimit = _MAX_OOM_LIMIT_;
         if (oomlimit >= 0 && size >= oomlimit) {
-            m_pBuffer = FX_TryAlloc(FX_BYTE, size);
+            m_pBuffer = FX_TryAlloc(uint8_t, size);
             if (m_pBuffer == NULL) {
                 return FALSE;
             }
         } else {
-            m_pBuffer = FX_Alloc(FX_BYTE, size);
+            m_pBuffer = FX_Alloc(uint8_t, size);
         }
     }
     m_Width = width;
     m_Height = height;
     m_Pitch = pitch;
     if (HasAlpha() && format != FXDIB_Argb) {
         FX_BOOL ret = TRUE;
         ret = BuildAlphaMask();
         if (!ret) {
             if (!m_bExtBuf && m_pBuffer) {
@@ skipping 163 matching lines @@
         BuildPalette();
     }
     m_pPalette[index] = color;
 }
 int CFX_DIBSource::FindPalette(FX_DWORD color) const
 {
     ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
     if (m_pPalette == NULL) {
         if (IsCmykImage()) {
             if (GetBPP() == 1) {
-                return ((FX_BYTE)color == 0xff) ? 0 : 1;
+                return ((uint8_t)color == 0xff) ? 0 : 1;
             }
-            return 0xff - (FX_BYTE)color;
+            return 0xff - (uint8_t)color;
         }
         if (GetBPP() == 1) {
-            return ((FX_BYTE)color == 0xff) ? 1 : 0;
+            return ((uint8_t)color == 0xff) ? 1 : 0;
         }
-        return (FX_BYTE)color;
+        return (uint8_t)color;
     }
     int palsize = (1 << GetBPP());
     for (int i = 0; i < palsize; i ++)
         if (m_pPalette[i] == color) {
             return i;
         }
     return -1;
 }
 void CFX_DIBitmap::Clear(FX_DWORD color)
 {
@@ skipping 162 matching lines @@
         pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
     } else {
         if (alpha_flag >> 8 && !IsCmykImage())
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
             return FALSE;
         }
     }
     if(!IsCmykImage()) {
-        color_p[3] = (FX_BYTE)alpha;
+        color_p[3] = (uint8_t)alpha;
     }
     if (GetFormat() == FXDIB_Argb) {
         for (int row = 0; row < height; row ++) {
             FX_DWORD* dest_pos = (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
             FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
             if (src_bpp == 1) {
                 for (int col = 0; col < width; col ++) {
                     int src_bitpos = src_left + col;
                     if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
                         *dest_pos = dst_color;
@@ skipping 402 matching lines @@
 FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
         return FALSE;
     }
     switch (GetFormat()) {
         case FXDIB_1bppRgb: {
                 if (m_pPalette == NULL) {
                     return FALSE;
                 }
-                FX_BYTE gray[2];
+                uint8_t gray[2];
                 for (int i = 0; i < 2; i ++) {
-                    int r = (FX_BYTE)(m_pPalette[i] >> 16);
-                    int g = (FX_BYTE)(m_pPalette[i] >> 8);
-                    int b = (FX_BYTE)m_pPalette[i];
-                    gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
+                    int r = (uint8_t)(m_pPalette[i] >> 16);
+                    int g = (uint8_t)(m_pPalette[i] >> 8);
+                    int b = (uint8_t)m_pPalette[i];
+                    gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
                 }
                 CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
                 if (!pMask) {
                     return FALSE;
                 }
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
                     return FALSE;
                 }
                 FXSYS_memset8(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
                 for (int row = 0; row < m_Height; row ++) {
                     FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
                     FX_LPBYTE dest_pos = (FX_LPBYTE)pMask->GetScanline(row);
                     for (int col = 0; col < m_Width; col ++) {
                         if (src_pos[col / 8] & (1 << (7 - col % 8))) {
                             *dest_pos = gray[1];
                         }
                         dest_pos ++;
                     }
                 }
                 TakeOver(pMask);
                 delete pMask;
                 break;
             }
         case FXDIB_8bppRgb: {
                 if (m_pPalette == NULL) {
                     return FALSE;
                 }
-                FX_BYTE gray[256];
+                uint8_t gray[256];
                 for (int i = 0; i < 256; i ++) {
-                    int r = (FX_BYTE)(m_pPalette[i] >> 16);
-                    int g = (FX_BYTE)(m_pPalette[i] >> 8);
-                    int b = (FX_BYTE)m_pPalette[i];
-                    gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
+                    int r = (uint8_t)(m_pPalette[i] >> 16);
+                    int g = (uint8_t)(m_pPalette[i] >> 8);
+                    int b = (uint8_t)m_pPalette[i];
+                    gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
                 }
                 CFX_DIBitmap* pMask = FX_NEW CFX_DIBitmap;
                 if (!pMask) {
                     return FALSE;
                 }
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
                     return FALSE;
                 }
                 for (int row = 0; row < m_Height; row ++) {
@@ skipping 165 matching lines @@
                 }
             } else {
                 if (color == 0xffffffff) {
                     *pos |= 1 << (7 - x % 8);
                 } else {
                     *pos &= ~(1 << (7 - x % 8));
                 }
             }
             break;
         case FXDIB_8bppMask:
-            *pos = (FX_BYTE)(color >> 24);
+            *pos = (uint8_t)(color >> 24);
             break;
         case FXDIB_8bppRgb: {
                 if (m_pPalette) {
                     for (int i = 0; i < 256; i ++) {
                         if (m_pPalette[i] == color) {
-                            *pos = (FX_BYTE)i;
+                            *pos = (uint8_t)i;
                             return;
                         }
                     }
                     *pos = 0;
                 } else {
                     *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
                 }
                 break;
             }
         case FXDIB_Rgb:
@@ skipping 108 matching lines @@
             }
         } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
             return TRUE;
         }
         if (m_pPalette == NULL) {
             BuildPalette();
         }
         int size = 1 << m_bpp;
         if (isCmykImage) {
             for (int i = 0; i < size; i ++) {
-                FX_BYTE b, g, r;
+                uint8_t b, g, r;
                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]), FXSYS_GetMValue(m_pPalette[i]), FXSYS_GetYValue(m_pPalette[i]), FXSYS_GetKValue(m_pPalette[i]),
                                    r, g, b);
                 int gray = 255 - FXRGB2GRAY(r, g, b);
                 m_pPalette[i] = CmykEncode(bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
                                            by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
             }
         } else
             for (int i = 0; i < size; i ++) {
                 int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]), FXARGB_G(m_pPalette[i]), FXARGB_B(m_pPalette[i]));
                 m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255, bg + (fg - bg) * gray / 255,
                                             bb + (fb - bb) * gray / 255);
             }
         return TRUE;
     }
     if (isCmykImage) {
         if (forecolor == 0xff && backcolor == 0x00) {
             for (int row = 0; row < m_Height; row ++) {
                 FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
                 for (int col = 0; col < m_Width; col ++) {
-                    FX_BYTE b, g, r;
+                    uint8_t b, g, r;
                     AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                                        r, g, b);
                     *scanline ++ = 0;
                     *scanline ++ = 0;
                     *scanline ++ = 0;
                     *scanline ++ = 255 - FXRGB2GRAY(r, g, b);
                 }
             }
             return TRUE;
         }
     } else if (forecolor == 0 && backcolor == 0xffffff) {
         for (int row = 0; row < m_Height; row ++) {
             FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
             int gap = m_bpp / 8 - 2;
             for (int col = 0; col < m_Width; col ++) {
                 int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
                 *scanline ++ = gray;
                 *scanline ++ = gray;
                 *scanline    = gray;
                 scanline += gap;
             }
         }
         return TRUE;
     }
     if (isCmykImage) {
         for (int row = 0; row < m_Height; row ++) {
             FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
             for (int col = 0; col < m_Width; col ++) {
-                FX_BYTE b, g, r;
+                uint8_t b, g, r;
                 AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                                    r, g, b);
                 int gray = 255 - FXRGB2GRAY(r, g, b);
                 *scanline ++ = bc + (fc - bc) * gray / 255;
                 *scanline ++ = bm + (fm - bm) * gray / 255;
                 *scanline ++ = by + (fy - by) * gray / 255;
                 *scanline ++ = bk + (fk - bk) * gray / 255;
             }
         }
     } else {
@@ skipping 19 matching lines @@
     if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
         return FALSE;
     }
     if (m_Width < 4 && m_Height < 4) {
         return FALSE;
     }
     FX_RECT rect(0, 0, m_Width, m_Height);
     if (pRect) {
         rect.Intersect(*pRect);
     }
-    FX_BYTE translate[256];
+    uint8_t translate[256];
     for (int i = 0; i < 256; i ++) {
         int err2 = 65536;
         for (int j = 0; j < pal_size; j ++) {
-            FX_BYTE entry = (FX_BYTE)pPalette[j];
+            uint8_t entry = (uint8_t)pPalette[j];
             int err = (int)entry - i;
             if (err * err < err2) {
                 err2 = err * err;
                 translate[i] = entry;
             }
         }
     }
     for (int row = rect.top; row < rect.bottom; row ++) {
         FX_LPBYTE scan = m_pBuffer + row * m_Pitch;
         FX_LPBYTE next_scan = m_pBuffer + (row + 1) * m_Pitch;
         for (int col = rect.left; col < rect.right; col ++) {
             int src_pixel = scan[col];
             int dest_pixel = translate[src_pixel];
-            scan[col] = (FX_BYTE)dest_pixel;
+            scan[col] = (uint8_t)dest_pixel;
             int error = -dest_pixel + src_pixel;
             if (col < rect.right - 1) {
                 int src = scan[col + 1];
                 src += error * 7 / 16;
                 if (src > 255) {
                     scan[col + 1] = 255;
                 } else if (src < 0) {
                     scan[col + 1] = 0;
                 } else {
                     scan[col + 1] = src;
@@ skipping 148 matching lines @@
         FX_Free(m_pScanline);
     }
 }
 void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
 {
     m_pSrc = pSrc;
     m_bAutoDropSrc = bAutoDropSrc;
     m_Width = pSrc->GetWidth();
     m_Height = pSrc->GetHeight();
     FXDIB_Format format = GetDestFormat();
-    m_bpp = (FX_BYTE)format;
-    m_AlphaFlag = (FX_BYTE)(format >> 8);
+    m_bpp = (uint8_t)format;
+    m_AlphaFlag = (uint8_t)(format >> 8);
     m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
     m_pPalette = GetDestPalette();
-    m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
+    m_pScanline = FX_Alloc(uint8_t, m_Pitch);
 }
 FX_LPCBYTE CFX_FilteredDIB::GetScanline(int line) const
 {
     TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
     return m_pScanline;
 }
 void CFX_FilteredDIB::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
         int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
 {
     m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
@@ skipping 94 matching lines @@
         if (pBitmap == NULL) {
             return FALSE;
         }
         if (pBitmap->GetBuffer() == NULL) {
             delete pBitmap;
             return FALSE;
         }
         if (pBitmap->IsAlphaMask()) {
             if (m_BitmapAlpha != 255) {
                 if (m_AlphaFlag >> 8) {
-                    m_AlphaFlag = (((FX_BYTE)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) | ((m_AlphaFlag >> 8) << 8));
+                    m_AlphaFlag = (((uint8_t)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) | ((m_AlphaFlag >> 8) << 8));
                 } else {
                     m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
                 }
             }
             m_pDevice->CompositeMask(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
                                      pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, m_MaskColor,
                                      0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform);
         } else {
             if (m_BitmapAlpha != 255) {
                 pBitmap->MultiplyAlpha(m_BitmapAlpha);
@@ skipping 50 matching lines @@
     if (!m_pBitmap->Create(width, height, src_format)) {
         delete m_pBitmap;
         m_pBitmap = NULL;
         return FALSE;
     }
     if (pSrcPalette) {
         m_pBitmap->CopyPalette(pSrcPalette);
     }
     return TRUE;
 }