Remove FX_DWORD from core/ and delete definition

core/fxcodec/lbmp/fx_bmp.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 "core/fxcodec/lbmp/fx_bmp.h"
 
 #include <algorithm>
 
 namespace {
 
 const size_t kBmpCoreHeaderSize = 12;
 const size_t kBmpInfoHeaderSize = 40;
 
 // TODO(thestig): Replace with FXDWORD_GET_LSBFIRST?
-FX_DWORD GetDWord_LSBFirst(uint8_t* p) {
+uint32_t GetDWord_LSBFirst(uint8_t* p) {
   return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 }
 
-void SetDWord_LSBFirst(uint8_t* p, FX_DWORD v) {
+void SetDWord_LSBFirst(uint8_t* p, uint32_t v) {
   p[0] = (uint8_t)v;
   p[1] = (uint8_t)(v >> 8);
   p[2] = (uint8_t)(v >> 16);
   p[3] = (uint8_t)(v >> 24);
 }
 }  // namespace
 
 uint16_t GetWord_LSBFirst(uint8_t* p) {
   return p[0] | (p[1] << 8);
 }
@@ skipping 26 matching lines @@
     FX_Free(bmp_ptr->out_row_buffer);
   }
   FX_Free(bmp_ptr->pal_ptr);
   FX_Free(bmp_ptr->bmp_header_ptr);
   FX_Free(bmp_ptr);
 }
 int32_t bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
   if (bmp_ptr == NULL) {
     return 0;
   }
-  FX_DWORD skip_size_org = bmp_ptr->skip_size;
+  uint32_t skip_size_org = bmp_ptr->skip_size;
   if (bmp_ptr->decode_status == BMP_D_STATUS_HEADER) {
     ASSERT(sizeof(BmpFileHeader) == 14);
     BmpFileHeader* bmp_header_ptr = NULL;
     if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_header_ptr, 14) == NULL) {
       return 2;
     }
     bmp_ptr->bmp_header_ptr->bfType =
         GetWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfType);
     bmp_ptr->bmp_header_ptr->bfOffBits =
         GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfOffBits);
     bmp_ptr->data_size = GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfSize);
     if (bmp_ptr->bmp_header_ptr->bfType != BMP_SIGNATURE) {
       bmp_error(bmp_ptr, "Not A Bmp Image");
       return 0;
     }
-    if (bmp_ptr->avail_in < sizeof(FX_DWORD)) {
+    if (bmp_ptr->avail_in < sizeof(uint32_t)) {
       bmp_ptr->skip_size = skip_size_org;
       return 2;
     }
     bmp_ptr->img_ifh_size =
         GetDWord_LSBFirst(bmp_ptr->next_in + bmp_ptr->skip_size);
     bmp_ptr->pal_type = 0;
     static_assert(sizeof(BmpCoreHeader) == kBmpCoreHeaderSize,
                   "BmpCoreHeader has wrong size");
     static_assert(sizeof(BmpInfoHeader) == kBmpInfoHeaderSize,
                   "BmpInfoHeader has wrong size");
@@ skipping 80 matching lines @@
       }
     }
     ASSERT(bmp_ptr->width > 0);
     ASSERT(bmp_ptr->compress_flag <= BMP_BITFIELDS);
     switch (bmp_ptr->bitCounts) {
       case 1:
       case 4:
       case 8:
       case 16:
       case 24: {
-        if (bmp_ptr->color_used > ((FX_DWORD)1) << bmp_ptr->bitCounts) {
+        if (bmp_ptr->color_used > ((uint32_t)1) << bmp_ptr->bitCounts) {
           bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
           return 0;
         }
       }
       case 32: {
         if (bmp_ptr->width <= 0 || bmp_ptr->compress_flag > BMP_BITFIELDS) {
           bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
           return 0;
         }
       } break;
@@ skipping 24 matching lines @@
     FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
     bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_PAL);
   }
   if (bmp_ptr->decode_status == BMP_D_STATUS_PAL) {
     skip_size_org = bmp_ptr->skip_size;
     if (bmp_ptr->compress_flag == BMP_BITFIELDS) {
       if (bmp_ptr->bitCounts != 16 && bmp_ptr->bitCounts != 32) {
         bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
         return 0;
       }
-      FX_DWORD* mask;
-      if (bmp_read_data(bmp_ptr, (uint8_t**)&mask, 3 * sizeof(FX_DWORD)) ==
+      uint32_t* mask;
+      if (bmp_read_data(bmp_ptr, (uint8_t**)&mask, 3 * sizeof(uint32_t)) ==
           NULL) {
         bmp_ptr->skip_size = skip_size_org;
         return 2;
       }
       bmp_ptr->mask_red = GetDWord_LSBFirst((uint8_t*)&mask[0]);
       bmp_ptr->mask_green = GetDWord_LSBFirst((uint8_t*)&mask[1]);
       bmp_ptr->mask_blue = GetDWord_LSBFirst((uint8_t*)&mask[2]);
       if (bmp_ptr->mask_red & bmp_ptr->mask_green ||
           bmp_ptr->mask_red & bmp_ptr->mask_blue ||
           bmp_ptr->mask_green & bmp_ptr->mask_blue) {
@@ skipping 10 matching lines @@
       bmp_ptr->mask_green = 0x03E0;
       bmp_ptr->mask_blue = 0x001F;
     }
     bmp_ptr->pal_num = 0;
     if (bmp_ptr->bitCounts < 16) {
       bmp_ptr->pal_num = 1 << bmp_ptr->bitCounts;
       if (bmp_ptr->color_used != 0) {
         bmp_ptr->pal_num = bmp_ptr->color_used;
       }
       uint8_t* src_pal_ptr = NULL;
-      FX_DWORD src_pal_size = bmp_ptr->pal_num * (bmp_ptr->pal_type ? 3 : 4);
+      uint32_t src_pal_size = bmp_ptr->pal_num * (bmp_ptr->pal_type ? 3 : 4);
       if (bmp_read_data(bmp_ptr, (uint8_t**)&src_pal_ptr, src_pal_size) ==
           NULL) {
         bmp_ptr->skip_size = skip_size_org;
         return 2;
       }
       FX_Free(bmp_ptr->pal_ptr);
-      bmp_ptr->pal_ptr = FX_Alloc(FX_DWORD, bmp_ptr->pal_num);
+      bmp_ptr->pal_ptr = FX_Alloc(uint32_t, bmp_ptr->pal_num);
       int32_t src_pal_index = 0;
       if (bmp_ptr->pal_type == BMP_PAL_OLD) {
         while (src_pal_index < bmp_ptr->pal_num) {
           bmp_ptr->pal_ptr[src_pal_index++] = BMP_PAL_ENCODE(
               0x00, src_pal_ptr[2], src_pal_ptr[1], src_pal_ptr[0]);
           src_pal_ptr += 3;
         }
       } else {
         while (src_pal_index < bmp_ptr->pal_num) {
           bmp_ptr->pal_ptr[src_pal_index++] = BMP_PAL_ENCODE(
@@ skipping 101 matching lines @@
                             bmp_ptr->out_row_buffer);
   }
   bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
   return 1;
 }
 int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
   uint8_t* first_byte_ptr = NULL;
   uint8_t* second_byte_ptr = NULL;
   bmp_ptr->col_num = 0;
   while (TRUE) {
-    FX_DWORD skip_size_org = bmp_ptr->skip_size;
+    uint32_t skip_size_org = bmp_ptr->skip_size;
     if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
       return 2;
     }
     switch (*first_byte_ptr) {
       case RLE_MARKER: {
         if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         switch (*first_byte_ptr) {
@@ skipping 81 matching lines @@
     }
   }
   bmp_error(bmp_ptr, "Any Uncontrol Error");
   return 0;
 }
 int32_t bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
   uint8_t* first_byte_ptr = NULL;
   uint8_t* second_byte_ptr = NULL;
   bmp_ptr->col_num = 0;
   while (TRUE) {
-    FX_DWORD skip_size_org = bmp_ptr->skip_size;
+    uint32_t skip_size_org = bmp_ptr->skip_size;
     if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
       return 2;
     }
     switch (*first_byte_ptr) {
       case RLE_MARKER: {
         if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         switch (*first_byte_ptr) {
@@ skipping 97 matching lines @@
           }
         }
       }
     }
   }
   bmp_error(bmp_ptr, "Any Uncontrol Error");
   return 0;
 }
 uint8_t* bmp_read_data(bmp_decompress_struct_p bmp_ptr,
                        uint8_t** des_buf_pp,
-                       FX_DWORD data_size) {
+                       uint32_t data_size) {
   if (bmp_ptr == NULL || bmp_ptr->avail_in < bmp_ptr->skip_size + data_size) {
     return NULL;
   }
   *des_buf_pp = bmp_ptr->next_in + bmp_ptr->skip_size;
   bmp_ptr->skip_size += data_size;
   return *des_buf_pp;
 }
 void bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr, int32_t status) {
   bmp_ptr->decode_status = status;
   bmp_ptr->next_in += bmp_ptr->skip_size;
   bmp_ptr->avail_in -= bmp_ptr->skip_size;
   bmp_ptr->skip_size = 0;
 }
 void bmp_input_buffer(bmp_decompress_struct_p bmp_ptr,
                       uint8_t* src_buf,
-                      FX_DWORD src_size) {
+                      uint32_t src_size) {
   bmp_ptr->next_in = src_buf;
   bmp_ptr->avail_in = src_size;
   bmp_ptr->skip_size = 0;
 }
-FX_DWORD bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
+uint32_t bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
                              uint8_t** avial_buf_ptr) {
   if (avial_buf_ptr) {
     *avial_buf_ptr = NULL;
     if (bmp_ptr->avail_in > 0) {
       *avial_buf_ptr = bmp_ptr->next_in;
     }
   }
   return bmp_ptr->avail_in;
 }
 bmp_compress_struct_p bmp_create_compress() {
   bmp_compress_struct_p bmp_ptr;
   bmp_ptr = FX_Alloc(bmp_compress_struct, 1);
   if (bmp_ptr) {
     FXSYS_memset(bmp_ptr, 0, sizeof(bmp_compress_struct));
   }
   return bmp_ptr;
 }
 void bmp_destroy_compress(bmp_compress_struct_p bmp_ptr) {
   if (bmp_ptr) {
     if (bmp_ptr->src_free && bmp_ptr->src_buf) {
       FX_Free(bmp_ptr->src_buf);
     }
     FX_Free(bmp_ptr);
   }
 }
 static void WriteFileHeader(BmpFileHeaderPtr head_ptr, uint8_t* dst_buf) {
-  FX_DWORD offset;
+  uint32_t offset;
   offset = 0;
   SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfType);
   offset += 2;
   SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfSize);
   offset += 4;
   SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved1);
   offset += 2;
   SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved2);
   offset += 2;
   SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfOffBits);
   offset += 4;
 }
 static void WriteInfoHeader(BmpInfoHeaderPtr info_head_ptr, uint8_t* dst_buf) {
-  FX_DWORD offset;
+  uint32_t offset;
   offset = sizeof(BmpFileHeader);
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSize);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biWidth);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biHeight);
   offset += 4;
   SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biPlanes);
   offset += 2;
   SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biBitCount);
   offset += 2;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biCompression);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSizeImage);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biXPelsPerMeter);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biYPelsPerMeter);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrUsed);
   offset += 4;
   SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrImportant);
   offset += 4;
 }
 static void bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr,
                                  uint8_t*& dst_buf,
-                                 FX_DWORD& dst_size) {
+                                 uint32_t& dst_size) {
   if (bmp_ptr->info_header.biBitCount != 16 &&
       bmp_ptr->info_header.biBitCount != 32) {
     return;
   }
-  FX_DWORD size, dst_pos, i;
+  uint32_t size, dst_pos, i;
   size = bmp_ptr->src_pitch * bmp_ptr->src_row *
          bmp_ptr->info_header.biBitCount / 16;
   dst_pos = bmp_ptr->file_header.bfOffBits;
   dst_size += size;
   dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size);
   if (dst_buf == NULL) {
     return;
   }
   FXSYS_memset(&dst_buf[dst_pos], 0, size);
-  FX_DWORD mask_red;
-  FX_DWORD mask_green;
-  FX_DWORD mask_blue;
+  uint32_t mask_red;
+  uint32_t mask_green;
+  uint32_t mask_blue;
   mask_red = 0x7C00;
   mask_green = 0x03E0;
   mask_blue = 0x001F;
   if (bmp_ptr->info_header.biCompression == BMP_BITFIELDS) {
     if (bmp_ptr->bit_type == BMP_BIT_565) {
       mask_red = 0xF800;
       mask_green = 0x07E0;
       mask_blue = 0x001F;
     }
     if (bmp_ptr->info_header.biBitCount == 32) {
@@ skipping 30 matching lines @@
   red_bits -= 8;
   i = 0;
   for (int32_t row_num = bmp_ptr->src_row - 1; row_num > -1; row_num--, i = 0) {
     while (i < bmp_ptr->src_width * bmp_ptr->src_bpp / 8) {
       uint8_t b = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
       uint8_t g = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
       uint8_t r = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
       if (bmp_ptr->src_bpp == 32) {
         i++;
       }
-      FX_DWORD pix_val = 0;
+      uint32_t pix_val = 0;
       pix_val |= (b >> blue_bits) & mask_blue;
       pix_val |= (g << green_bits) & mask_green;
       pix_val |= (r << red_bits) & mask_red;
       if (bmp_ptr->info_header.biBitCount == 16) {
         SetWord_LSBFirst(&dst_buf[dst_pos], pix_val);
         dst_pos += 2;
       } else {
         SetDWord_LSBFirst(&dst_buf[dst_pos], pix_val);
         dst_pos += 4;
       }
     }
   }
   dst_size = dst_pos;
 }
 
 static void bmp_encode_rgb(bmp_compress_struct_p bmp_ptr,
                            uint8_t*& dst_buf,
-                           FX_DWORD& dst_size) {
+                           uint32_t& dst_size) {
   if (bmp_ptr->info_header.biBitCount == 16) {
     bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
     return;
   }
-  FX_DWORD size, dst_pos;
-  FX_DWORD dst_pitch =
+  uint32_t size, dst_pos;
+  uint32_t dst_pitch =
       (bmp_ptr->src_width * bmp_ptr->info_header.biBitCount + 31) / 32 * 4;
   size = dst_pitch * bmp_ptr->src_row;
   dst_pos = bmp_ptr->file_header.bfOffBits;
   dst_size += size;
   dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size);
   if (dst_buf == NULL) {
     return;
   }
   FXSYS_memset(&dst_buf[dst_pos], 0, size);
   for (int32_t row_num = bmp_ptr->src_row - 1; row_num > -1; row_num--) {
@@ skipping 10 matching lines @@
   while (num < len) {
     if (buf[num - 1] != buf[num] || num == 0xFF) {
       break;
     }
     num++;
   }
   return num;
 }
 static void bmp_encode_rle8(bmp_compress_struct_p bmp_ptr,
                             uint8_t*& dst_buf,
-                            FX_DWORD& dst_size) {
-  FX_DWORD size, dst_pos, index;
+                            uint32_t& dst_size) {
+  uint32_t size, dst_pos, index;
   uint8_t rle[2] = {0};
   size = bmp_ptr->src_pitch * bmp_ptr->src_row * 2;
   dst_pos = bmp_ptr->file_header.bfOffBits;
   dst_size += size;
   dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size);
   if (dst_buf == NULL) {
     return;
   }
   FXSYS_memset(&dst_buf[dst_pos], 0, size);
   for (int32_t row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1;) {
@@ skipping 26 matching lines @@
   while (num < len) {
     if (buf[num - 2] != buf[num] || num == 0xFF) {
       break;
     }
     num++;
   }
   return num;
 }
 static void bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
                             uint8_t*& dst_buf,
-                            FX_DWORD& dst_size) {
-  FX_DWORD size, dst_pos, index;
+                            uint32_t& dst_size) {
+  uint32_t size, dst_pos, index;
   uint8_t rle[2] = {0};
   size = bmp_ptr->src_pitch * bmp_ptr->src_row;
   dst_pos = bmp_ptr->file_header.bfOffBits;
   dst_size += size;
   dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size);
   if (dst_buf == NULL) {
     return;
   }
   FXSYS_memset(&dst_buf[dst_pos], 0, size);
   for (int32_t row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1;
@@ skipping 17 matching lines @@
       dst_buf[dst_pos++] = rle[0];
       dst_buf[dst_pos++] = rle[1];
     }
   }
   dst_buf[dst_pos++] = RLE_MARKER;
   dst_buf[dst_pos++] = RLE_EOI;
   dst_size = dst_pos;
 }
 FX_BOOL bmp_encode_image(bmp_compress_struct_p bmp_ptr,
                          uint8_t*& dst_buf,
-                         FX_DWORD& dst_size) {
-  FX_DWORD head_size = sizeof(BmpFileHeader) + sizeof(BmpInfoHeader);
-  FX_DWORD pal_size = sizeof(FX_DWORD) * bmp_ptr->pal_num;
+                         uint32_t& dst_size) {
+  uint32_t head_size = sizeof(BmpFileHeader) + sizeof(BmpInfoHeader);
+  uint32_t pal_size = sizeof(uint32_t) * bmp_ptr->pal_num;
   if (bmp_ptr->info_header.biClrUsed > 0 &&
       bmp_ptr->info_header.biClrUsed < bmp_ptr->pal_num) {
-    pal_size = sizeof(FX_DWORD) * bmp_ptr->info_header.biClrUsed;
+    pal_size = sizeof(uint32_t) * bmp_ptr->info_header.biClrUsed;
   }
-  dst_size = head_size + sizeof(FX_DWORD) * bmp_ptr->pal_num;
+  dst_size = head_size + sizeof(uint32_t) * bmp_ptr->pal_num;
   dst_buf = FX_TryAlloc(uint8_t, dst_size);
   if (dst_buf == NULL) {
     return FALSE;
   }
   FXSYS_memset(dst_buf, 0, dst_size);
   bmp_ptr->file_header.bfOffBits = head_size;
   if (bmp_ptr->pal_ptr && pal_size) {
     FXSYS_memcpy(&dst_buf[head_size], bmp_ptr->pal_ptr, pal_size);
     bmp_ptr->file_header.bfOffBits += pal_size;
   }
@@ skipping 11 matching lines @@
     case BMP_RLE4:
       bmp_encode_rle4(bmp_ptr, dst_buf, dst_size);
       break;
     default:
       break;
   }
   bmp_ptr->file_header.bfSize = dst_size;
   WriteFileHeader(&bmp_ptr->file_header, dst_buf);
   return TRUE;
 }