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

core/src/fxcodec/codec/fx_codec_jpeg.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 <setjmp.h>
 
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "../../../include/fxge/fx_dib.h"
 #include "codec_int.h"
 
 extern "C" {
-    static void _JpegScanSOI(const FX_BYTE*& src_buf, FX_DWORD& src_size)
+    static void _JpegScanSOI(const uint8_t*& src_buf, FX_DWORD& src_size)
     {
         if (src_size == 0) {
             return;
         }
         FX_DWORD offset = 0;
         while (offset < src_size - 1) {
             if (src_buf[offset] == 0xff && src_buf[offset + 1] == 0xd8) {
                 src_buf += offset;
                 src_size -= offset;
                 return;
@@ skipping 62 matching lines @@
 }
 static  FX_BOOL _JpegLoadIccProfile(j_decompress_ptr cinfo, FX_LPBYTE* icc_buf_ptr, FX_DWORD* icc_length)
 {
     if(icc_buf_ptr == NULL || icc_length == NULL) {
         return FALSE;
     }
     *icc_buf_ptr = NULL;
     *icc_length = 0;
     FX_LPBYTE icc_data_ptr = NULL;
     FX_DWORD icc_data_len = 0;
-    FX_BYTE count_icc_marker = 0;
-    FX_BYTE num_icc_marker = 0;
+    uint8_t count_icc_marker = 0;
+    uint8_t num_icc_marker = 0;
     jpeg_saved_marker_ptr marker_list[256] = {NULL};
     for (jpeg_saved_marker_ptr cur_marker = cinfo->marker_list;
             cur_marker != NULL;
             cur_marker = cur_marker->next) {
         if(_JpegIsIccMarker(cur_marker)) {
             if(count_icc_marker == 0) {
                 num_icc_marker = cur_marker->data[13];
             } else if(num_icc_marker != cur_marker->data[13]) {
                 return FALSE;
             }
             int sn = cur_marker->data[12] - 1;
             if(sn < 0 || sn >= num_icc_marker) {
                 return FALSE;
             }
             if(marker_list[sn] == NULL) {
                 marker_list[sn] = cur_marker;
             } else {
                 return FALSE;
             }
             count_icc_marker ++;
             icc_data_len +=     (cur_marker->data_length - JPEG_OVERHEAD_LEN);
         }
     }
     if(count_icc_marker != num_icc_marker) {
         return FALSE;
     }
     if(num_icc_marker == 0) {
         return TRUE;
     }
-    icc_data_ptr = FX_Alloc(FX_BYTE, icc_data_len);
+    icc_data_ptr = FX_Alloc(uint8_t, icc_data_len);
     if(icc_buf_ptr == NULL)     {
         return FALSE;
     }
     *icc_buf_ptr = icc_data_ptr;
     *icc_length = icc_data_len;
     for (int idx = 0; idx < num_icc_marker; idx++) {
         icc_data_len = marker_list[idx]->data_length - JPEG_OVERHEAD_LEN;
         FXSYS_memcpy32(icc_data_ptr, marker_list[idx]->data + JPEG_OVERHEAD_LEN, icc_data_len);
         icc_data_ptr += icc_data_len;
     }
     return TRUE;
 }
 static  FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo, FX_LPCBYTE icc_buf_ptr, FX_DWORD icc_length)
 {
     if(icc_buf_ptr == NULL || icc_length == 0) {
         return FALSE;
     }
     FX_DWORD icc_segment_size = (JPEG_MARKER_MAXSIZE - 2 - JPEG_OVERHEAD_LEN);
     FX_DWORD icc_segment_num = (icc_length / icc_segment_size) + 1;
     if (icc_segment_num > 255)  {
         return FALSE;
     }
     FX_DWORD icc_data_length = JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);
-    FX_LPBYTE icc_data = FX_Alloc(FX_BYTE, icc_data_length);
+    FX_LPBYTE icc_data = FX_Alloc(uint8_t, icc_data_length);
     FXSYS_memcpy32(icc_data, "\x49\x43\x43\x5f\x50\x52\x4f\x46\x49\x4c\x45\x00", 12);
-    icc_data[13] = (FX_BYTE)icc_segment_num;
-    for (FX_BYTE i = 0; i < (icc_segment_num - 1); i++) {
+    icc_data[13] = (uint8_t)icc_segment_num;
+    for (uint8_t i = 0; i < (icc_segment_num - 1); i++) {
         icc_data[12] = i + 1;
         FXSYS_memcpy32(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + i * icc_segment_size, icc_segment_size);
         jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, icc_data_length);
     }
-    icc_data[12] = (FX_BYTE)icc_segment_num;
+    icc_data[12] = (uint8_t)icc_segment_num;
     FX_DWORD icc_size = (icc_segment_num - 1) * icc_segment_size;
     FXSYS_memcpy32(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size, icc_length - icc_size);
     jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, JPEG_OVERHEAD_LEN + icc_length - icc_size);
     FX_Free(icc_data);
     return TRUE;
 }
 extern "C" {
     static void _dest_do_nothing(j_compress_ptr cinfo) {}
 };
 extern "C" {
@@ skipping 27 matching lines @@
     safe_buf_len += 1024;
     if (icc_length) {
         safe_buf_len += 255 * 18;
         safe_buf_len += icc_length;
     }
     FX_DWORD dest_buf_length = 0;
     if (!safe_buf_len.IsValid()) {
         dest_buf = nullptr;
     } else {
         dest_buf_length = safe_buf_len.ValueOrDie();
-        dest_buf = FX_TryAlloc(FX_BYTE, dest_buf_length);
+        dest_buf = FX_TryAlloc(uint8_t, dest_buf_length);
         const int MIN_TRY_BUF_LEN = 1024;
         while (!dest_buf && dest_buf_length > MIN_TRY_BUF_LEN) {
             dest_buf_length >>= 1;
-            dest_buf = FX_TryAlloc(FX_BYTE, dest_buf_length);
+            dest_buf = FX_TryAlloc(uint8_t, dest_buf_length);
         }
     }
     if (!dest_buf) {
         FX_OutOfMemoryTerminate(); 
     }
     struct jpeg_destination_mgr dest;
     dest.init_destination = _dest_do_nothing;
     dest.term_destination = _dest_do_nothing;
     dest.empty_output_buffer = _dest_empty;
     dest.next_output_byte = dest_buf;
     dest.free_in_buffer = dest_buf_length;
     cinfo.dest = &dest;
     cinfo.image_width = width;
     cinfo.image_height = height;
     cinfo.input_components = nComponents;
     if (nComponents == 1) {
         cinfo.in_color_space = JCS_GRAYSCALE;
     } else if (nComponents == 3) {
         cinfo.in_color_space = JCS_RGB;
     } else {
         cinfo.in_color_space = JCS_CMYK;
     }
     FX_LPBYTE line_buf = NULL;
     if (nComponents > 1) {
-        line_buf = FX_Alloc2D(FX_BYTE, width, nComponents);
+        line_buf = FX_Alloc2D(uint8_t, width, nComponents);
     }
     jpeg_set_defaults(&cinfo);
     if(quality != 75) {
         jpeg_set_quality(&cinfo, quality, TRUE);
     }
     jpeg_start_compress(&cinfo, TRUE);
     _JpegEmbedIccProfile(&cinfo, icc_buf, icc_length);
     JSAMPROW row_pointer[1];
     JDIMENSION row;
     while (cinfo.next_scanline < cinfo.image_height) {
@@ skipping 13 matching lines @@
                     *dest_scan++ = ~*src_scan++;
                 }
             }
             row_pointer[0] = line_buf;
         } else {
             row_pointer[0] = (FX_LPBYTE)src_scan;
         }
         row = cinfo.next_scanline;
         jpeg_write_scanlines(&cinfo, row_pointer, 1);
         if (cinfo.next_scanline == row) {
-            dest_buf = FX_Realloc(FX_BYTE, dest_buf, dest_buf_length + JPEG_BLOCK_SIZE);
+            dest_buf = FX_Realloc(uint8_t, dest_buf, dest_buf_length + JPEG_BLOCK_SIZE);
             dest.next_output_byte = dest_buf + dest_buf_length - dest.free_in_buffer;
             dest_buf_length += JPEG_BLOCK_SIZE;
             dest.free_in_buffer += JPEG_BLOCK_SIZE;
         }
     }
     jpeg_finish_compress(&cinfo);
     jpeg_destroy_compress(&cinfo);
     if (line_buf) {
         FX_Free(line_buf);
     }
@@ skipping 187 matching lines @@
     if (!InitDecode()) {
         return FALSE;
     }
     if (cinfo.num_components < nComps) {
         return FALSE;
     }
     if ((int)cinfo.image_width < width) {
         return FALSE;
     }
     m_Pitch = (cinfo.image_width * cinfo.num_components + 3) / 4 * 4;
-    m_pScanlineBuf = FX_Alloc(FX_BYTE, m_Pitch);
+    m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
     m_nComps = cinfo.num_components;
     m_bpc = 8;
     m_bColorTransformed = FALSE;
     m_bStarted = FALSE;
     return TRUE;
 }
 extern "C" {
-    FX_INT32 FX_GetDownsampleRatio(FX_INT32 originWidth, FX_INT32 originHeight, FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
+    int32_t FX_GetDownsampleRatio(int32_t originWidth, int32_t originHeight, int32_t downsampleWidth, int32_t downsampleHeight)
     {
         int iratio_w = originWidth / downsampleWidth;
         int iratio_h = originHeight / downsampleHeight;
         int ratio = (iratio_w > iratio_h) ? iratio_h : iratio_w;
         if (ratio >= 8) {
             return 8;
         } else if (ratio >= 4) {
             return 4;
         } else if (ratio >= 2) {
             return 2;
@@ skipping 131 matching lines @@
 }
 static void jpeg_free_func(void* p)
 {
     FX_Free(p);
 }
 void* CCodec_JpegModule::Start()
 {
     if (m_pExtProvider) {
         return m_pExtProvider->Start();
     }
-    FXJPEG_Context* p = (FXJPEG_Context*)FX_Alloc(FX_BYTE, sizeof(FXJPEG_Context));
+    FXJPEG_Context* p = (FXJPEG_Context*)FX_Alloc(uint8_t, sizeof(FXJPEG_Context));
     p->m_AllocFunc = jpeg_alloc_func;
     p->m_FreeFunc = jpeg_free_func;
     p->m_ErrMgr.error_exit = _error_fatal1;
     p->m_ErrMgr.emit_message = _error_do_nothing1;
     p->m_ErrMgr.output_message = _error_do_nothing;
     p->m_ErrMgr.format_message = _error_do_nothing2;
     p->m_ErrMgr.reset_error_mgr = _error_do_nothing;
     p->m_SrcMgr.init_source = _src_do_nothing;
     p->m_SrcMgr.term_source = _src_do_nothing;
     p->m_SrcMgr.skip_input_data = _src_skip_data1;
@@ skipping 91 matching lines @@
         return m_pExtProvider->GetAvailInput(pContext, avail_buf_ptr);
     }
     if(avail_buf_ptr != NULL) {
         *avail_buf_ptr = NULL;
         if(((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer > 0) {
             *avail_buf_ptr = (FX_LPBYTE)((FXJPEG_Context*)pContext)->m_SrcMgr.next_input_byte;
         }
     }
     return (FX_DWORD)((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer;
 }