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

core/src/fxge/dib/fx_dib_engine.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 "dib_int.h"
 #include <limits.h>
@@ skipping 10 matching lines @@
         base = (FX_FLOAT)(src_len);
     } else {
         base = 0;
     }
     int ext_size = flags & FXDIB_BICUBIC_INTERPOL ? 3 : 1;
     m_ItemSize = sizeof(int) * 2 + (int)(sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + ext_size));
     m_DestMin = dest_min;
     if ((dest_max - dest_min) > (int)((1U << 30) - 4) / m_ItemSize) {
         return;
     }
-    m_pWeightTables = FX_TryAlloc(FX_BYTE, (dest_max - dest_min) * m_ItemSize + 4);
+    m_pWeightTables = FX_TryAlloc(uint8_t, (dest_max - dest_min) * m_ItemSize + 4);
     if (m_pWeightTables == NULL) {
         return;
     }
     if ((flags & FXDIB_NOSMOOTH) != 0 || FXSYS_fabs((FX_FLOAT)scale) < 1.0f) {
         for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel ++) {
             PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
             double src_pos = dest_pixel * scale + scale / 2 + base;
             if (flags & FXDIB_INTERPOL) {
                 pixel_weights.m_SrcStart = (int)FXSYS_floor((FX_FLOAT)src_pos - 1.0f / 2);
                 pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos + 1.0f / 2);
@@ skipping 153 matching lines @@
     FX_DWORD size = clip_rect.Width();
     if (size && m_DestBpp > (int)(INT_MAX / size)) {
         return;
     }
     size *= m_DestBpp;
     if (size > INT_MAX - 31) {
         return;
     }
     size += 31;
     size = size / 32 * 4;
-    m_pDestScanline = FX_TryAlloc(FX_BYTE, size);
+    m_pDestScanline = FX_TryAlloc(uint8_t, size);
     if (m_pDestScanline == NULL) {
         return;
     }
     if (dest_format == FXDIB_Rgb32) {
         FXSYS_memset8(m_pDestScanline, 255, size);
     }
     m_InterPitch = (m_DestClip.Width() * m_DestBpp + 31) / 32 * 4;
     m_ExtraMaskPitch = (m_DestClip.Width() * 8 + 31) / 32 * 4;
     m_pInterBuf = NULL;
     m_pSource = pSrcBitmap;
@@ skipping 150 matching lines @@
                         int dest_a = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             if (src_scan[j / 8] & (1 << (7 - j % 8))) {
                                 dest_a += pixel_weight * 255;
                             }
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
                         }
-                        *dest_scan++ = (FX_BYTE)(dest_a >> 16);
+                        *dest_scan++ = (uint8_t)(dest_a >> 16);
                     }
                     break;
                 }
             case 3: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_a = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             dest_a += pixel_weight * src_scan[j];
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
                         }
-                        *dest_scan++ = (FX_BYTE)(dest_a >> 16);
+                        *dest_scan++ = (uint8_t)(dest_a >> 16);
                     }
                     break;
                 }
             case 4: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_a = 0, dest_r = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
                             dest_r += pixel_weight * src_scan[j];
                             dest_a += pixel_weight;
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_r = dest_r < 0 ? 0 : dest_r > 16711680 ? 16711680 : dest_r;
                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
                         }
-                        *dest_scan++ = (FX_BYTE)(dest_r >> 16);
-                        *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
+                        *dest_scan++ = (uint8_t)(dest_r >> 16);
+                        *dest_scan_mask++ = (uint8_t)((dest_a * 255) >> 16);
                     }
                     break;
                 }
             case 5: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
                             if (m_DestFormat == FXDIB_Rgb) {
-                                dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
-                                dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
-                                dest_b_c += pixel_weight * (FX_BYTE)argb_cmyk;
+                                dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 16);
+                                dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 8);
+                                dest_b_c += pixel_weight * (uint8_t)argb_cmyk;
                             } else {
-                                dest_b_c += pixel_weight * (FX_BYTE)(argb_cmyk >> 24);
-                                dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
-                                dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
+                                dest_b_c += pixel_weight * (uint8_t)(argb_cmyk >> 24);
+                                dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 16);
+                                dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 8);
                             }
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
                         }
-                        *dest_scan++ = (FX_BYTE)(dest_b_c >> 16);
-                        *dest_scan++ = (FX_BYTE)(dest_g_m >> 16);
-                        *dest_scan++ = (FX_BYTE)(dest_r_y >> 16);
+                        *dest_scan++ = (uint8_t)(dest_b_c >> 16);
+                        *dest_scan++ = (uint8_t)(dest_g_m >> 16);
+                        *dest_scan++ = (uint8_t)(dest_r_y >> 16);
                     }
                     break;
                 }
             case 6: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
                             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
                             if (m_DestFormat == FXDIB_Rgba) {
-                                dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
-                                dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
-                                dest_b_c += pixel_weight * (FX_BYTE)argb_cmyk;
+                                dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 16);
+                                dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 8);
+                                dest_b_c += pixel_weight * (uint8_t)argb_cmyk;
                             } else {
-                                dest_b_c += pixel_weight * (FX_BYTE)(argb_cmyk >> 24);
-                                dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
-                                dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
+                                dest_b_c += pixel_weight * (uint8_t)(argb_cmyk >> 24);
+                                dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 16);
+                                dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 8);
                             }
                             dest_a += pixel_weight;
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
                         }
-                        *dest_scan++ = (FX_BYTE)(dest_b_c >> 16);
-                        *dest_scan++ = (FX_BYTE)(dest_g_m >> 16);
-                        *dest_scan++ = (FX_BYTE)(dest_r_y >> 16);
-                        *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
+                        *dest_scan++ = (uint8_t)(dest_b_c >> 16);
+                        *dest_scan++ = (uint8_t)(dest_g_m >> 16);
+                        *dest_scan++ = (uint8_t)(dest_r_y >> 16);
+                        *dest_scan_mask++ = (uint8_t)((dest_a * 255) >> 16);
                     }
                     break;
                 }
             case 7: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             FX_LPCBYTE src_pixel = src_scan + j * Bpp;
                             dest_b_c += pixel_weight * (*src_pixel++);
                             dest_g_m += pixel_weight * (*src_pixel++);
                             dest_r_y += pixel_weight * (*src_pixel);
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
                         }
-                        *dest_scan++ = (FX_BYTE)((dest_b_c) >> 16);
-                        *dest_scan++ = (FX_BYTE)((dest_g_m) >> 16);
-                        *dest_scan++ = (FX_BYTE)((dest_r_y) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_b_c) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_g_m) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_r_y) >> 16);
                         dest_scan += Bpp - 3;
                     }
                     break;
                 }
             case 8: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
                         int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             FX_LPCBYTE src_pixel = src_scan + j * Bpp;
                             if (m_DestFormat == FXDIB_Argb) {
                                 pixel_weight = pixel_weight * src_pixel[3] / 255;
                             } else {
                                 pixel_weight = pixel_weight * src_scan_mask[j] / 255;
                             }
                             dest_b_c += pixel_weight * (*src_pixel++);
                             dest_g_m += pixel_weight * (*src_pixel++);
                             dest_r_y += pixel_weight * (*src_pixel);
                             dest_a += pixel_weight;
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
                         }
-                        *dest_scan++ = (FX_BYTE)((dest_b_c) >> 16);
-                        *dest_scan++ = (FX_BYTE)((dest_g_m) >> 16);
-                        *dest_scan++ = (FX_BYTE)((dest_r_y) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_b_c) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_g_m) >> 16);
+                        *dest_scan++ = (uint8_t)((dest_r_y) >> 16);
                         if (m_DestFormat == FXDIB_Argb) {
-                            *dest_scan = (FX_BYTE)((dest_a * 255) >> 16);
+                            *dest_scan = (uint8_t)((dest_a * 255) >> 16);
                         }
                         if (dest_scan_mask) {
-                            *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
+                            *dest_scan_mask++ = (uint8_t)((dest_a * 255) >> 16);
                         }
                         dest_scan += Bpp - 3;
                     }
                     break;
                 }
         }
         rows_to_go --;
     }
     return FALSE;
 }
@@ skipping 19 matching lines @@
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
                         int dest_a = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             dest_a += pixel_weight * src_scan[(j - m_SrcClip.top) * m_InterPitch];
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
                         }
-                        *dest_scan = (FX_BYTE)(dest_a >> 16);
+                        *dest_scan = (uint8_t)(dest_a >> 16);
                         dest_scan += DestBpp;
                     }
                     break;
                 }
             case 4: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
                         unsigned char* src_scan_mask = m_pExtraAlphaBuf + (col - m_DestClip.left);
                         int dest_a = 0, dest_k = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             dest_k += pixel_weight * src_scan[(j - m_SrcClip.top) * m_InterPitch];
                             dest_a += pixel_weight * src_scan_mask[(j - m_SrcClip.top) * m_ExtraMaskPitch];
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_k = dest_k < 0 ? 0 : dest_k > 16711680 ? 16711680 : dest_k;
                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
                         }
-                        *dest_scan = (FX_BYTE)(dest_k >> 16);
+                        *dest_scan = (uint8_t)(dest_k >> 16);
                         dest_scan += DestBpp;
-                        *dest_sacn_mask++ = (FX_BYTE)(dest_a >> 16);
+                        *dest_sacn_mask++ = (uint8_t)(dest_a >> 16);
                     }
                     break;
                 }
             case 5:
             case 7: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
                             FX_LPCBYTE src_pixel = src_scan + (j - m_SrcClip.top) * m_InterPitch;
                             dest_b_c += pixel_weight * (*src_pixel++);
                             dest_g_m += pixel_weight * (*src_pixel++);
                             dest_r_y += pixel_weight * (*src_pixel);
                         }
                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
                         }
-                        dest_scan[0] = (FX_BYTE)((dest_b_c) >> 16);
-                        dest_scan[1] = (FX_BYTE)((dest_g_m) >> 16);
-                        dest_scan[2] = (FX_BYTE)((dest_r_y) >> 16);
+                        dest_scan[0] = (uint8_t)((dest_b_c) >> 16);
+                        dest_scan[1] = (uint8_t)((dest_g_m) >> 16);
+                        dest_scan[2] = (uint8_t)((dest_r_y) >> 16);
                         dest_scan += DestBpp;
                     }
                     break;
                 }
             case 6:
             case 8: {
                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
                         unsigned char* src_scan_mask = NULL;
                         if (m_DestFormat != FXDIB_Argb) {
@@ skipping 24 matching lines @@
                         }
                         if (dest_a) {
                             int r = ((FX_DWORD)dest_r_y) * 255 / dest_a;
                             int g = ((FX_DWORD)dest_g_m) * 255 / dest_a;
                             int b = ((FX_DWORD)dest_b_c) * 255 / dest_a;
                             dest_scan[0] = b > 255 ? 255 : b < 0 ? 0 : b;
                             dest_scan[1] = g > 255 ? 255 : g < 0 ? 0 : g;
                             dest_scan[2] = r > 255 ? 255 : r < 0 ? 0 : r;
                         }
                         if (m_DestFormat == FXDIB_Argb) {
-                            dest_scan[3] = (FX_BYTE)((dest_a) >> 16);
+                            dest_scan[3] = (uint8_t)((dest_a) >> 16);
                         } else {
-                            *dest_sacn_mask = (FX_BYTE)((dest_a) >> 16);
+                            *dest_sacn_mask = (uint8_t)((dest_a) >> 16);
                         }
                         dest_scan += DestBpp;
                         if (dest_sacn_mask) {
                             dest_sacn_mask++;
                         }
                     }
                     break;
                 }
         }
         m_pDestBitmap->ComposeScanline(row - m_DestClip.top, m_pDestScanline, m_pDestMaskScanline);
@@ skipping 122 matching lines @@
     if (m_DestHeight < 0) {
         m_bFlipY = TRUE;
         m_DestHeight = -m_DestHeight;
     }
     m_LineIndex = 0;
     FX_DWORD size = m_ClipRect.Width();
     if (size && m_DestBPP > (int)(INT_MAX / size)) {
         return FALSE;
     }
     size *= m_DestBPP;
-    m_pScanline = FX_Alloc(FX_BYTE, (size / 8 + 3) / 4 * 4);
+    m_pScanline = FX_Alloc(uint8_t, (size / 8 + 3) / 4 * 4);
     if (m_pSource->m_pAlphaMask) {
-        m_pMaskScanline = FX_Alloc(FX_BYTE, (m_ClipRect.Width() + 3) / 4 * 4);
+        m_pMaskScanline = FX_Alloc(uint8_t, (m_ClipRect.Width() + 3) / 4 * 4);
     }
     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
         ContinueQuickStretch(NULL);
         return FALSE;
     }
     return TRUE;
 }
 FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
 {
     if (m_pScanline == NULL) {
@@ skipping 20 matching lines @@
             return TRUE;
         }
         m_pSource->DownSampleScanline(src_y, m_pScanline, m_DestBPP, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
         if (m_pMaskScanline) {
             m_pSource->m_pAlphaMask->DownSampleScanline(src_y, m_pMaskScanline, 1, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
         }
         m_pDest->ComposeScanline(dest_y, m_pScanline, m_pMaskScanline);
     }
     return FALSE;
 }