Use stdint.h types throughout PDFium.

core/src/fxcodec/codec/fx_codec_icc.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/fxcodec/fx_codec.h"
 #include "codec_int.h"
 #include "../lcms2/include/fx_lcms2.h"
 const FX_DWORD N_COMPONENT_LAB = 3;
 const FX_DWORD N_COMPONENT_GRAY = 1;
 const FX_DWORD N_COMPONENT_RGB = 3;
 const FX_DWORD N_COMPONENT_CMYK = 4;
 const FX_DWORD N_COMPONENT_DEFAULT = 3;
 
-FX_BOOL MD5ComputeID( FX_LPCVOID buf, FX_DWORD dwSize, FX_BYTE ID[16] )
+FX_BOOL MD5ComputeID( FX_LPCVOID buf, FX_DWORD dwSize, uint8_t ID[16] )
 {
     return cmsMD5computeIDExt(buf, dwSize, ID);
 }
 struct CLcmsCmm  {
     cmsHTRANSFORM m_hTransform;
     int                 m_nSrcComponents;
     int                 m_nDstComponents;
     FX_BOOL             m_bLab;
 };
 extern "C" {
@@ skipping 31 matching lines @@
             }
             break;
         default:
             if (nComponents != 3) {
                 return FALSE;
             }
             break;
     }
     return TRUE;
 }
-FX_INT32 GetCSComponents(cmsColorSpaceSignature cs)
+int32_t GetCSComponents(cmsColorSpaceSignature cs)
 {
     FX_DWORD components;
     switch (cs) {
         case cmsSigLabData:
             components =  N_COMPONENT_LAB;
             break;
         case cmsSigGrayData:
             components =  N_COMPONENT_GRAY;
             break;
         case cmsSigRgbData:
             components =  N_COMPONENT_RGB;
             break;
         case cmsSigCmykData:
             components =  N_COMPONENT_CMYK;
             break;
         default:
             components = N_COMPONENT_DEFAULT;
             break;
     }
     return components;
 }
-void* IccLib_CreateTransform(const unsigned char* pSrcProfileData, FX_DWORD dwSrcProfileSize, FX_INT32& nSrcComponents,
-                             const unsigned char* pDstProfileData, FX_DWORD dwDstProfileSize, FX_INT32 nDstComponents,
+void* IccLib_CreateTransform(const unsigned char* pSrcProfileData, FX_DWORD dwSrcProfileSize, int32_t& nSrcComponents,
+                             const unsigned char* pDstProfileData, FX_DWORD dwDstProfileSize, int32_t nDstComponents,
                              int intent, FX_DWORD dwSrcFormat = Icc_FORMAT_DEFAULT, FX_DWORD dwDstFormat = Icc_FORMAT_DEFAULT)
 {
     cmsHPROFILE srcProfile = NULL;
     cmsHPROFILE dstProfile = NULL;
     cmsHTRANSFORM hTransform = NULL;
     CLcmsCmm* pCmm = NULL;
     nSrcComponents = 0;
     srcProfile = cmsOpenProfileFromMem((void*)pSrcProfileData, dwSrcProfileSize);
     if (srcProfile == NULL) {
         return NULL;
@@ skipping 48 matching lines @@
     }
     pCmm = new CLcmsCmm;
     pCmm->m_nSrcComponents = nSrcComponents;
     pCmm->m_nDstComponents = nDstComponents;
     pCmm->m_hTransform = hTransform;
     pCmm->m_bLab = bLab;
     cmsCloseProfile(srcProfile);
     cmsCloseProfile(dstProfile);
     return pCmm;
 }
-void* IccLib_CreateTransform_sRGB(const unsigned char* pProfileData, FX_DWORD dwProfileSize, FX_INT32& nComponents, FX_INT32 intent, FX_DWORD dwSrcFormat)
+void* IccLib_CreateTransform_sRGB(const unsigned char* pProfileData, FX_DWORD dwProfileSize, int32_t& nComponents, int32_t intent, FX_DWORD dwSrcFormat)
 {
     return IccLib_CreateTransform(pProfileData, dwProfileSize, nComponents, NULL, 0, 3, intent, dwSrcFormat);
 }
 void IccLib_DestroyTransform(void* pTransform)
 {
     if (pTransform == NULL) {
         return;
     }
     cmsDeleteTransform(((CLcmsCmm*)pTransform)->m_hTransform);
     delete (CLcmsCmm*)pTransform;
 }
 void IccLib_Translate(void* pTransform, FX_DWORD nSrcComponents, FX_FLOAT* pSrcValues, FX_FLOAT* pDestValues)
 {
     if (pTransform == NULL) {
         return;
     }
     CLcmsCmm* p = (CLcmsCmm*)pTransform;
-    FX_BYTE output[4];
+    uint8_t output[4];
     if (p->m_bLab) {
         CFX_FixedBufGrow<double, 16> inputs(nSrcComponents);
         double* input = inputs;
         for (FX_DWORD i = 0; i < nSrcComponents; i ++) {
             input[i] = pSrcValues[i];
         }
         cmsDoTransform(p->m_hTransform, input, output, 1);
     } else {
-        CFX_FixedBufGrow<FX_BYTE, 16> inputs(nSrcComponents);
-        FX_BYTE* input = inputs;
+        CFX_FixedBufGrow<uint8_t, 16> inputs(nSrcComponents);
+        uint8_t* input = inputs;
         for (FX_DWORD i = 0; i < nSrcComponents; i ++) {
             if (pSrcValues[i] > 1.0f) {
                 input[i] = 255;
             } else if (pSrcValues[i] < 0) {
                 input[i] = 0;
             } else {
                 input[i] = (int)(pSrcValues[i] * 255.0f);
             }
         }
         cmsDoTransform(p->m_hTransform, input, output, 1);
     }
     switch(p->m_nDstComponents) {
         case 1:
             pDestValues[0] = output[0] / 255.0f;
             break;
         case 3:
             pDestValues[0] = output[2] / 255.0f;
             pDestValues[1] = output[1] / 255.0f;
             pDestValues[2] = output[0] / 255.0f;
             break;
         case 4:
             pDestValues[0] = output[0] / 255.0f;
             pDestValues[1] = output[1] / 255.0f;
             pDestValues[2] = output[2] / 255.0f;
             pDestValues[3] = output[3] / 255.0f;
             break;
     }
 }
-void IccLib_TranslateImage(void* pTransform, unsigned char* pDest, const unsigned char* pSrc, FX_INT32 pixels)
+void IccLib_TranslateImage(void* pTransform, unsigned char* pDest, const unsigned char* pSrc, int32_t pixels)
 {
     cmsDoTransform(((CLcmsCmm*)pTransform)->m_hTransform, (void*)pSrc, pDest, pixels);
 }
 FX_LPVOID CreateProfile_Gray(double gamma)
 {
     cmsCIExyY* D50 = (cmsCIExyY*)cmsD50_xyY();
     if (!cmsWhitePointFromTemp(D50, 6504)) {
         return NULL;
     }
     cmsToneCurve* curve = cmsBuildGamma(NULL, gamma);
@@ skipping 49 matching lines @@
     }
     return cs;
 }
 ICodec_IccModule::IccCS CCodec_IccModule::GetProfileCS(IFX_FileRead* pFile)
 {
     if (pFile == NULL) {
         return IccCS_Unknown;
     }
     ICodec_IccModule::IccCS cs;
     FX_DWORD dwSize = (FX_DWORD)pFile->GetSize();
-    FX_LPBYTE pBuf = FX_Alloc(FX_BYTE, dwSize);
+    FX_LPBYTE pBuf = FX_Alloc(uint8_t, dwSize);
     pFile->ReadBlock(pBuf, 0, dwSize);
     cs = GetProfileCS(pBuf, dwSize);
     FX_Free(pBuf);
     return cs;
 }
 FX_DWORD TransferProfileType(FX_LPVOID pProfile, FX_DWORD dwFormat)
 {
     cmsColorSpaceSignature cs = cmsGetColorSpace(pProfile);
     switch (cs) {
         case cmsSigXYZData:
@@ skipping 101 matching lines @@
 {
     AppendBlock(&i, sizeof(FX_DWORD));
     return *this;
 }
 FX_LPVOID CCodec_IccModule::CreateProfile(ICodec_IccModule::IccParam* pIccParam, Icc_CLASS ic, CFX_BinaryBuf* pTransformKey)
 {
     CFX_IccProfileCache* pCache = NULL;
     CFX_ByteStringKey key;
     CFX_ByteString text;
     key << pIccParam->ColorSpace << (pIccParam->dwProfileType | ic << 8);
-    FX_BYTE ID[16];
+    uint8_t ID[16];
     switch (pIccParam->dwProfileType) {
         case Icc_PARAMTYPE_NONE:
             return NULL;
         case Icc_PARAMTYPE_BUFFER:
             MD5ComputeID(pIccParam->pProfileData, pIccParam->dwProfileSize, ID);
             break;
         case Icc_PARAMTYPE_PARAM:
             FXSYS_memset32(ID, 0, 16);
             switch (pIccParam->ColorSpace) {
                 case IccCS_Gray:
@@ skipping 99 matching lines @@
     }
     pos = m_MapTranform.GetStartPosition();
     CFX_IccTransformCache* pTransformCache;
     while (pos) {
         m_MapTranform.GetNextAssoc(pos, key, (FX_LPVOID&)pTransformCache);
         if (pTransformCache) {
             delete pTransformCache;
         }
     }
 }
-void* CCodec_IccModule::CreateTransform_sRGB(FX_LPCBYTE pProfileData, FX_DWORD dwProfileSize, FX_INT32& nComponents, FX_INT32 intent, FX_DWORD dwSrcFormat)
+void* CCodec_IccModule::CreateTransform_sRGB(FX_LPCBYTE pProfileData, FX_DWORD dwProfileSize, int32_t& nComponents, int32_t intent, FX_DWORD dwSrcFormat)
 {
     return IccLib_CreateTransform_sRGB(pProfileData, dwProfileSize, nComponents, intent, dwSrcFormat);
 }
-void* CCodec_IccModule::CreateTransform_CMYK(FX_LPCBYTE pSrcProfileData, FX_DWORD dwSrcProfileSize, FX_INT32& nSrcComponents,
-    FX_LPCBYTE pDstProfileData, FX_DWORD dwDstProfileSize, FX_INT32 intent,
+void* CCodec_IccModule::CreateTransform_CMYK(FX_LPCBYTE pSrcProfileData, FX_DWORD dwSrcProfileSize, int32_t& nSrcComponents,
+    FX_LPCBYTE pDstProfileData, FX_DWORD dwDstProfileSize, int32_t intent,
         FX_DWORD dwSrcFormat , FX_DWORD dwDstFormat)
 {
     return IccLib_CreateTransform(pSrcProfileData, dwSrcProfileSize, nSrcComponents,
                                   pDstProfileData, dwDstProfileSize, 4, intent, dwSrcFormat, dwDstFormat);
 }
 void CCodec_IccModule::DestroyTransform(void* pTransform)
 {
     IccLib_DestroyTransform(pTransform);
 }
 void CCodec_IccModule::Translate(void* pTransform, FX_FLOAT* pSrcValues, FX_FLOAT* pDestValues)
 {
     IccLib_Translate(pTransform, m_nComponents, pSrcValues, pDestValues);
 }
-void CCodec_IccModule::TranslateScanline(void* pTransform, FX_LPBYTE pDest, FX_LPCBYTE pSrc, FX_INT32 pixels)
+void CCodec_IccModule::TranslateScanline(void* pTransform, FX_LPBYTE pDest, FX_LPCBYTE pSrc, int32_t pixels)
 {
     IccLib_TranslateImage(pTransform, pDest, pSrc, pixels);
 }
-const FX_BYTE g_CMYKSamples[81 * 81 * 3] = {
+const uint8_t g_CMYKSamples[81 * 81 * 3] = {
     255, 255, 255, 225, 226, 228, 199, 200, 202, 173, 174, 178, 147, 149, 152, 123, 125, 128,  99, 99, 102,  69, 70, 71,  34, 30, 31,
     255, 253, 229, 226, 224, 203, 200, 199, 182, 173, 173, 158, 149, 148, 135, 125, 124, 113,  99, 99, 90,  70, 69, 63,  33, 29, 24,
     255, 251, 204, 228, 223, 182, 201, 198, 163, 174, 172, 142, 150, 147, 122, 125, 123, 101,  99, 98, 80,  70, 68, 54,  32, 28, 16,
     255, 249, 179, 230, 222, 160, 203, 197, 144, 174, 170, 124, 150, 145, 105, 125, 122, 88,  99, 97, 69,  70, 68, 46,  31, 28,  6,
     255, 247, 154, 229, 220, 138, 203, 195, 122, 176, 169, 107, 150, 145, 91, 125, 121, 74, 100, 96, 57,  70, 67, 35,  29, 26,  0,
     255, 246, 128, 231, 217, 114, 205, 194, 101, 176, 167, 88, 150, 144, 75, 125, 120, 60, 100, 96, 44,  70, 66, 24,  28, 26,  0,
     255, 244, 96, 231, 217, 87, 203, 192, 78, 175, 167, 66, 150, 143, 56, 125, 119, 43, 100, 95, 29,  69, 66,  7,  26, 26,  0,
     255, 243, 51, 232, 215, 51, 204, 191, 43, 176, 165, 38, 150, 142, 28, 125, 118, 17,  99, 94,  0,  68, 65,  0,  24, 25,  0,
     255, 241,  0, 231, 215,  0, 203, 190,  0, 176, 164,  0, 150, 141,  0, 126, 117,  0,  99, 93,  0,  68, 65,  0,  24, 25,  0,
     252, 228, 238, 222, 201, 211, 197, 180, 190, 171, 156, 166, 147, 133, 143, 123, 111, 119,  99, 88, 94,  71, 61, 66,  34, 22, 26,
@@ skipping 710 matching lines @@
     46, 48, 146,  42, 40, 131,  36, 32, 118,  27, 22, 103,  17,  6, 88,   5,  0, 73,   0,  0, 55,   0,  0, 33,   0,  0,  0,
     48, 48, 133,  44, 40, 119,  37, 32, 107,  28, 22, 93,  20,  8, 79,   7,  0, 65,   0,  0, 49,   0,  0, 27,   0,  0,  0,
     48, 50, 123,  44, 41, 109,  37, 33, 97,  30, 23, 83,  21, 11, 71,   8,  0, 58,   0,  0, 42,   0,  0, 21,   0,  0,  0,
     49, 51, 111,  45, 42, 99,  38, 34, 87,  29, 25, 75,  20, 13, 63,   8,  0, 51,   0,  0, 36,   0,  0, 14,   0,  0,  0,
     52, 52, 100,  44, 43, 89,  38, 35, 79,  29, 26, 68,  19, 15, 56,  10,  1, 43,   0,  0, 28,   0,  0,  6,   0,  0,  0,
     52, 52, 90,  47, 44, 79,  39, 36, 70,  30, 27, 59,  20, 16, 47,   9,  2, 36,   0,  0, 22,   0,  0,  2,   0,  0,  0,
     52, 53, 78,  46, 44, 68,  39, 37, 60,  32, 27, 49,  22, 17, 39,  10,  3, 28,   0,  0, 12,   0,  0,  0,   0,  0,  0,
     53, 53, 66,  47, 44, 57,  40, 36, 48,  32, 27, 39,  22, 18, 30,   9,  4, 18,   0,  0,  3,   0,  0,  0,   0,  0,  0,
     54, 53, 57,  48, 45, 49,  41, 37, 41,  33, 28, 32,  22, 19, 23,  11,  6, 10,   1,  0,  0,   0,  0,  0,   0,  0,  0,
 };
-void AdobeCMYK_to_sRGB1(FX_BYTE c, FX_BYTE m, FX_BYTE y, FX_BYTE k, FX_BYTE& R, FX_BYTE& G, FX_BYTE& B)
+void AdobeCMYK_to_sRGB1(uint8_t c, uint8_t m, uint8_t y, uint8_t k, uint8_t& R, uint8_t& G, uint8_t& B)
 {
     int fix_c = c << 8;
     int fix_m = m << 8;
     int fix_y = y << 8;
     int fix_k = k << 8;
     int c_index = (fix_c + 4096) >> 13;
     int m_index = (fix_m + 4096) >> 13;
     int y_index = (fix_y + 4096) >> 13;
     int k_index = (fix_k + 4096) >> 13;
     int pos = (c_index * 9 * 9 * 9 + m_index * 9 * 9 + y_index * 9 + k_index) * 3;
@@ skipping 56 matching lines @@
     }
     if (fix_b < 0) {
         fix_b = 0;
     }
     R = fix_r >> 8;
     G = fix_g >> 8;
     B = fix_b >> 8;
 }
 void AdobeCMYK_to_sRGB(FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B)
 {
-    FX_BYTE c1 = FXSYS_round(c * 255);
-    FX_BYTE m1 = FXSYS_round(m * 255);
-    FX_BYTE y1 = FXSYS_round(y * 255);
-    FX_BYTE k1 = FXSYS_round(k * 255);
-    FX_BYTE r, g, b;
+    uint8_t c1 = FXSYS_round(c * 255);
+    uint8_t m1 = FXSYS_round(m * 255);
+    uint8_t y1 = FXSYS_round(y * 255);
+    uint8_t k1 = FXSYS_round(k * 255);
+    uint8_t r, g, b;
     AdobeCMYK_to_sRGB1(c1, m1, y1, k1, r, g, b);
     R = 1.0f * r / 255;
     G = 1.0f * g / 255;
     B = 1.0f * b / 255;
 }