Remove FX_DWORD from core/ and delete definition

core/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 "core/fxcodec/codec/codec_int.h"
 #include "core/fxcrt/include/fx_safe_types.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_dib.h"
 
 extern "C" {
 #undef FAR
 #if defined(USE_SYSTEM_LIBJPEG)
 #include <jpeglib.h>
 #elif defined(USE_LIBJPEG_TURBO)
 #include "third_party/libjpeg_turbo/jpeglib.h"
 #else
 #include "third_party/libjpeg/jpeglib.h"
 #endif
 }
 
 extern "C" {
-static void _JpegScanSOI(const uint8_t*& src_buf, FX_DWORD& src_size) {
+static void _JpegScanSOI(const uint8_t*& src_buf, uint32_t& src_size) {
   if (src_size == 0) {
     return;
   }
-  FX_DWORD offset = 0;
+  uint32_t offset = 0;
   while (offset < src_size - 1) {
     if (src_buf[offset] == 0xff && src_buf[offset + 1] == 0xd8) {
       src_buf += offset;
       src_size -= offset;
       return;
     }
     offset++;
   }
 }
 };
@@ skipping 33 matching lines @@
 extern "C" {
 static void _error_do_nothing2(j_common_ptr cinfo, char*) {}
 };
 #define JPEG_MARKER_EXIF (JPEG_APP0 + 1)
 #define JPEG_MARKER_ICC (JPEG_APP0 + 2)
 #define JPEG_MARKER_AUTHORTIME (JPEG_APP0 + 3)
 #define JPEG_MARKER_MAXSIZE 0xFFFF
 #define JPEG_OVERHEAD_LEN 14
 static FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo,
                                     const uint8_t* icc_buf_ptr,
-                                    FX_DWORD icc_length) {
+                                    uint32_t icc_length) {
   if (!icc_buf_ptr || 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;
+  uint32_t icc_segment_size = (JPEG_MARKER_MAXSIZE - 2 - JPEG_OVERHEAD_LEN);
+  uint32_t icc_segment_num = (icc_length / icc_segment_size) + 1;
   if (icc_segment_num > 255) {
     return FALSE;
   }
-  FX_DWORD icc_data_length =
+  uint32_t icc_data_length =
       JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);
   uint8_t* icc_data = FX_Alloc(uint8_t, icc_data_length);
   FXSYS_memcpy(icc_data, "\x49\x43\x43\x5f\x50\x52\x4f\x46\x49\x4c\x45\x00",
                12);
   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_memcpy(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] = (uint8_t)icc_segment_num;
-  FX_DWORD icc_size = (icc_segment_num - 1) * icc_segment_size;
+  uint32_t icc_size = (icc_segment_num - 1) * icc_segment_size;
   FXSYS_memcpy(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" {
 static boolean _dest_empty(j_compress_ptr cinfo) {
   return FALSE;
 }
 };
 #define JPEG_BLOCK_SIZE 1048576
 static void _JpegEncode(const CFX_DIBSource* pSource,
                         uint8_t*& dest_buf,
                         FX_STRSIZE& dest_size,
                         int quality,
                         const uint8_t* icc_buf,
-                        FX_DWORD icc_length) {
+                        uint32_t icc_length) {
   struct jpeg_error_mgr jerr;
   jerr.error_exit = _error_do_nothing;
   jerr.emit_message = _error_do_nothing1;
   jerr.output_message = _error_do_nothing;
   jerr.format_message = _error_do_nothing2;
   jerr.reset_error_mgr = _error_do_nothing;
 
   struct jpeg_compress_struct cinfo;
   memset(&cinfo, 0, sizeof(cinfo));
   cinfo.err = &jerr;
   jpeg_create_compress(&cinfo);
   int Bpp = pSource->GetBPP() / 8;
-  FX_DWORD nComponents = Bpp >= 3 ? (pSource->IsCmykImage() ? 4 : 3) : 1;
-  FX_DWORD pitch = pSource->GetPitch();
-  FX_DWORD width = pdfium::base::checked_cast<FX_DWORD>(pSource->GetWidth());
-  FX_DWORD height = pdfium::base::checked_cast<FX_DWORD>(pSource->GetHeight());
+  uint32_t nComponents = Bpp >= 3 ? (pSource->IsCmykImage() ? 4 : 3) : 1;
+  uint32_t pitch = pSource->GetPitch();
+  uint32_t width = pdfium::base::checked_cast<uint32_t>(pSource->GetWidth());
+  uint32_t height = pdfium::base::checked_cast<uint32_t>(pSource->GetHeight());
   FX_SAFE_DWORD safe_buf_len = width;
   safe_buf_len *= height;
   safe_buf_len *= nComponents;
   safe_buf_len += 1024;
   if (icc_length) {
     safe_buf_len += 255 * 18;
     safe_buf_len += icc_length;
   }
-  FX_DWORD dest_buf_length = 0;
+  uint32_t dest_buf_length = 0;
   if (!safe_buf_len.IsValid()) {
     dest_buf = nullptr;
   } else {
     dest_buf_length = safe_buf_len.ValueOrDie();
     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(uint8_t, dest_buf_length);
     }
@@ skipping 28 matching lines @@
   }
   jpeg_start_compress(&cinfo, TRUE);
   _JpegEmbedIccProfile(&cinfo, icc_buf, icc_length);
   JSAMPROW row_pointer[1];
   JDIMENSION row;
   while (cinfo.next_scanline < cinfo.image_height) {
     const uint8_t* src_scan = pSource->GetScanline(cinfo.next_scanline);
     if (nComponents > 1) {
       uint8_t* dest_scan = line_buf;
       if (nComponents == 3) {
-        for (FX_DWORD i = 0; i < width; i++) {
+        for (uint32_t i = 0; i < width; i++) {
           dest_scan[0] = src_scan[2];
           dest_scan[1] = src_scan[1];
           dest_scan[2] = src_scan[0];
           dest_scan += 3;
           src_scan += Bpp;
         }
       } else {
-        for (FX_DWORD i = 0; i < pitch; i++) {
+        for (uint32_t i = 0; i < pitch; i++) {
           *dest_scan++ = ~*src_scan++;
         }
       }
       row_pointer[0] = line_buf;
     } else {
       row_pointer[0] = (uint8_t*)src_scan;
     }
     row = cinfo.next_scanline;
     jpeg_write_scanlines(&cinfo, row_pointer, 1);
     if (cinfo.next_scanline == row) {
@@ skipping 18 matching lines @@
   }
   if (pAttribute) {
     pAttribute->m_nXDPI = pInfo->X_density;
     pAttribute->m_nYDPI = pInfo->Y_density;
     pAttribute->m_wDPIUnit = pInfo->density_unit;
   }
 }
 #endif  // PDF_ENABLE_XFA
 
 static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf,
-                             FX_DWORD src_size,
+                             uint32_t src_size,
                              int& width,
                              int& height,
                              int& num_components,
                              int& bits_per_components,
                              FX_BOOL& color_transform,
                              uint8_t** icc_buf_ptr,
-                             FX_DWORD* icc_length) {
+                             uint32_t* icc_length) {
   _JpegScanSOI(src_buf, src_size);
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   jerr.error_exit = _error_fatal;
   jerr.emit_message = _error_do_nothing1;
   jerr.output_message = _error_do_nothing;
   jerr.format_message = _error_do_nothing2;
   jerr.reset_error_mgr = _error_do_nothing;
   jerr.trace_level = 0;
   cinfo.err = &jerr;
@@ skipping 39 matching lines @@
   jpeg_destroy_decompress(&cinfo);
   return TRUE;
 }
 
 class CCodec_JpegDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_JpegDecoder();
   ~CCodec_JpegDecoder() override;
 
   FX_BOOL Create(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  int width,
                  int height,
                  int nComps,
                  FX_BOOL ColorTransform);
   void Destroy() { delete this; }
 
   // CCodec_ScanlineDecoder
   void v_DownScale(int dest_width, int dest_height) override;
   FX_BOOL v_Rewind() override;
   uint8_t* v_GetNextLine() override;
-  FX_DWORD GetSrcOffset() override;
+  uint32_t GetSrcOffset() override;
 
   FX_BOOL InitDecode();
 
   jmp_buf m_JmpBuf;
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   struct jpeg_source_mgr src;
   const uint8_t* m_SrcBuf;
-  FX_DWORD m_SrcSize;
+  uint32_t m_SrcSize;
   uint8_t* m_pScanlineBuf;
 
   FX_BOOL m_bInited;
   FX_BOOL m_bStarted;
   FX_BOOL m_bJpegTransform;
 
  protected:
-  FX_DWORD m_nDefaultScaleDenom;
+  uint32_t m_nDefaultScaleDenom;
 };
 
 CCodec_JpegDecoder::CCodec_JpegDecoder() {
   m_pScanlineBuf = NULL;
   m_DownScale = 1;
   m_bStarted = FALSE;
   m_bInited = FALSE;
   FXSYS_memset(&cinfo, 0, sizeof(cinfo));
   FXSYS_memset(&jerr, 0, sizeof(jerr));
   FXSYS_memset(&src, 0, sizeof(src));
@@ skipping 34 matching lines @@
     cinfo.out_color_space = cinfo.jpeg_color_space;
   }
   m_OrigWidth = cinfo.image_width;
   m_OrigHeight = cinfo.image_height;
   m_OutputWidth = m_OrigWidth;
   m_OutputHeight = m_OrigHeight;
   m_nDefaultScaleDenom = cinfo.scale_denom;
   return TRUE;
 }
 FX_BOOL CCodec_JpegDecoder::Create(const uint8_t* src_buf,
-                                   FX_DWORD src_size,
+                                   uint32_t src_size,
                                    int width,
                                    int height,
                                    int nComps,
                                    FX_BOOL ColorTransform) {
   _JpegScanSOI(src_buf, src_size);
   m_SrcBuf = src_buf;
   m_SrcSize = src_size;
   jerr.error_exit = _error_fatal;
   jerr.emit_message = _error_do_nothing1;
   jerr.output_message = _error_do_nothing;
@@ skipping 15 matching lines @@
   if (!InitDecode()) {
     return FALSE;
   }
   if (cinfo.num_components < nComps) {
     return FALSE;
   }
   if ((int)cinfo.image_width < width) {
     return FALSE;
   }
   m_Pitch =
-      (static_cast<FX_DWORD>(cinfo.image_width) * cinfo.num_components + 3) /
+      (static_cast<uint32_t>(cinfo.image_width) * cinfo.num_components + 3) /
       4 * 4;
   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" {
 int32_t FX_GetDownsampleRatio(int32_t originWidth,
@@ skipping 14 matching lines @@
   }
   return 1;
 }
 }
 void CCodec_JpegDecoder::v_DownScale(int dest_width, int dest_height) {
   int old_scale = m_DownScale;
   m_DownScale =
       FX_GetDownsampleRatio(m_OrigWidth, m_OrigHeight, dest_width, dest_height);
   m_OutputWidth = (m_OrigWidth + m_DownScale - 1) / m_DownScale;
   m_OutputHeight = (m_OrigHeight + m_DownScale - 1) / m_DownScale;
-  m_Pitch = (static_cast<FX_DWORD>(m_OutputWidth) * m_nComps + 3) / 4 * 4;
+  m_Pitch = (static_cast<uint32_t>(m_OutputWidth) * m_nComps + 3) / 4 * 4;
   if (old_scale != m_DownScale) {
     m_NextLine = -1;
   }
 }
 FX_BOOL CCodec_JpegDecoder::v_Rewind() {
   if (m_bStarted) {
     jpeg_destroy_decompress(&cinfo);
     if (!InitDecode()) {
       return FALSE;
     }
@@ skipping 18 matching lines @@
 uint8_t* CCodec_JpegDecoder::v_GetNextLine() {
   if (setjmp(m_JmpBuf) == -1)
     return nullptr;
 
   int nlines = jpeg_read_scanlines(&cinfo, &m_pScanlineBuf, 1);
   if (nlines < 1) {
     return nullptr;
   }
   return m_pScanlineBuf;
 }
-FX_DWORD CCodec_JpegDecoder::GetSrcOffset() {
-  return (FX_DWORD)(m_SrcSize - src.bytes_in_buffer);
+uint32_t CCodec_JpegDecoder::GetSrcOffset() {
+  return (uint32_t)(m_SrcSize - src.bytes_in_buffer);
 }
 ICodec_ScanlineDecoder* CCodec_JpegModule::CreateDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int nComps,
     FX_BOOL ColorTransform) {
   if (!src_buf || src_size == 0) {
     return NULL;
   }
   CCodec_JpegDecoder* pDecoder = new CCodec_JpegDecoder;
   if (!pDecoder->Create(src_buf, src_size, width, height, nComps,
                         ColorTransform)) {
     delete pDecoder;
     return NULL;
   }
   return pDecoder;
 }
 FX_BOOL CCodec_JpegModule::LoadInfo(const uint8_t* src_buf,
-                                    FX_DWORD src_size,
+                                    uint32_t src_size,
                                     int& width,
                                     int& height,
                                     int& num_components,
                                     int& bits_per_components,
                                     FX_BOOL& color_transform,
                                     uint8_t** icc_buf_ptr,
-                                    FX_DWORD* icc_length) {
+                                    uint32_t* icc_length) {
   return _JpegLoadInfo(src_buf, src_size, width, height, num_components,
                        bits_per_components, color_transform, icc_buf_ptr,
                        icc_length);
 }
 FX_BOOL CCodec_JpegModule::Encode(const CFX_DIBSource* pSource,
                                   uint8_t*& dest_buf,
                                   FX_STRSIZE& dest_size,
                                   int quality,
                                   const uint8_t* icc_buf,
-                                  FX_DWORD icc_length) {
+                                  uint32_t icc_length) {
   if (pSource->GetBPP() < 8 || pSource->GetPalette())
     return FALSE;
 
   _JpegEncode(pSource, dest_buf, dest_size, quality, icc_buf, icc_length);
   return TRUE;
 }
 struct FXJPEG_Context {
   jmp_buf m_JumpMark;
   jpeg_decompress_struct m_Info;
   jpeg_error_mgr m_ErrMgr;
@@ skipping 49 matching lines @@
   p->m_SkipSize = 0;
   return p;
 }
 void CCodec_JpegModule::Finish(void* pContext) {
   FXJPEG_Context* p = (FXJPEG_Context*)pContext;
   jpeg_destroy_decompress(&p->m_Info);
   p->m_FreeFunc(p);
 }
 void CCodec_JpegModule::Input(void* pContext,
                               const unsigned char* src_buf,
-                              FX_DWORD src_size) {
+                              uint32_t src_size) {
   FXJPEG_Context* p = (FXJPEG_Context*)pContext;
   if (p->m_SkipSize) {
     if (p->m_SkipSize > src_size) {
       p->m_SrcMgr.bytes_in_buffer = 0;
       p->m_SkipSize -= src_size;
       return;
     }
     src_size -= p->m_SkipSize;
     src_buf += p->m_SkipSize;
     p->m_SkipSize = 0;
@@ skipping 43 matching lines @@
 }
 FX_BOOL CCodec_JpegModule::ReadScanline(void* pContext,
                                         unsigned char* dest_buf) {
   FXJPEG_Context* p = (FXJPEG_Context*)pContext;
   if (setjmp(p->m_JumpMark) == -1) {
     return FALSE;
   }
   int nlines = jpeg_read_scanlines(&p->m_Info, &dest_buf, 1);
   return nlines == 1;
 }
-FX_DWORD CCodec_JpegModule::GetAvailInput(void* pContext,
+uint32_t CCodec_JpegModule::GetAvailInput(void* pContext,
                                           uint8_t** avail_buf_ptr) {
   if (avail_buf_ptr) {
     *avail_buf_ptr = NULL;
     if (((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer > 0) {
       *avail_buf_ptr =
           (uint8_t*)((FXJPEG_Context*)pContext)->m_SrcMgr.next_input_byte;
     }
   }
-  return (FX_DWORD)((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer;
+  return (uint32_t)((FXJPEG_Context*)pContext)->m_SrcMgr.bytes_in_buffer;
 }