Remove FX_WORD in favor of uint16_t.

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) {
   return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 }
 
 void SetDWord_LSBFirst(uint8_t* p, FX_DWORD 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
 
-FX_WORD GetWord_LSBFirst(uint8_t* p) {
+uint16_t GetWord_LSBFirst(uint8_t* p) {
   return p[0] | (p[1] << 8);
 }
-void SetWord_LSBFirst(uint8_t* p, FX_WORD v) {
+void SetWord_LSBFirst(uint8_t* p, uint16_t v) {
   p[0] = (uint8_t)v;
   p[1] = (uint8_t)(v >> 8);
 }
 void bmp_error(bmp_decompress_struct_p bmp_ptr, const FX_CHAR* err_msg) {
   if (bmp_ptr && bmp_ptr->bmp_error_fn) {
     bmp_ptr->bmp_error_fn(bmp_ptr, err_msg);
   }
 }
 bmp_decompress_struct_p bmp_create_decompress() {
   bmp_decompress_struct_p bmp_ptr = FX_Alloc(bmp_decompress_struct, 1);
@@ skipping 95 matching lines @@
       } break;
       default: {
         if (bmp_ptr->img_ifh_size >
             std::min(kBmpInfoHeaderSize, sizeof(BmpInfoHeader))) {
           BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
           if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
                             bmp_ptr->img_ifh_size) == NULL) {
             bmp_ptr->skip_size = skip_size_org;
             return 2;
           }
-          FX_WORD biPlanes;
+          uint16_t biPlanes;
           bmp_ptr->width =
               GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biWidth);
           bmp_ptr->height =
               GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biHeight);
           bmp_ptr->bitCounts =
               GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biBitCount);
           bmp_ptr->compress_flag =
               GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biCompression);
           bmp_ptr->color_used =
               GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biClrUsed);
@@ skipping 174 matching lines @@
           *row_buf++ = des_buf[col >> 3] & (0x80 >> (col % 8)) ? 0x01 : 0x00;
         }
       } break;
       case 4: {
         for (int32_t col = 0; col < bmp_ptr->width; col++) {
           *row_buf++ = (col & 0x01) ? (des_buf[col >> 1] & 0x0F)
                                     : ((des_buf[col >> 1] & 0xF0) >> 4);
         }
       } break;
       case 16: {
-        FX_WORD* buf = (FX_WORD*)des_buf;
+        uint16_t* buf = (uint16_t*)des_buf;
         uint8_t blue_bits = 0;
         uint8_t green_bits = 0;
         uint8_t red_bits = 0;
         for (int32_t i = 0; i < 16; i++) {
           if ((bmp_ptr->mask_blue >> i) & 0x01) {
             blue_bits++;
           }
           if ((bmp_ptr->mask_green >> i) & 0x01) {
             green_bits++;
           }
@@ skipping 190 matching lines @@
             while (bmp_ptr->row_num < bmp_row_num_next) {
               FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
               bmp_ptr->bmp_get_row_fn(
                   bmp_ptr, bmp_ptr->imgTB_flag
                                ? bmp_ptr->row_num++
                                : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
                   bmp_ptr->out_row_buffer);
             }
           } break;
           default: {
-            uint8_t size = (uint8_t)(((FX_WORD)(*first_byte_ptr) + 1) >> 1);
+            uint8_t size = (uint8_t)(((uint16_t)(*first_byte_ptr) + 1) >> 1);
             if ((int32_t)*first_byte_ptr >=
                 bmp_ptr->out_row_bytes - bmp_ptr->col_num) {
               if (size + (bmp_ptr->col_num >> 1) > bmp_ptr->src_row_bytes) {
                 bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
                 return 0;
               }
               *first_byte_ptr = bmp_ptr->out_row_bytes - bmp_ptr->col_num - 1;
             }
             if (bmp_read_data(bmp_ptr, &second_byte_ptr,
                               size & 1 ? size + 1 : size) == NULL) {
@@ skipping 12 matching lines @@
           }
         }
       } break;
       default: {
         if (bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         if ((int32_t)*first_byte_ptr >
             bmp_ptr->out_row_bytes - bmp_ptr->col_num) {
-          uint8_t size = (uint8_t)(((FX_WORD)(*first_byte_ptr) + 1) >> 1);
+          uint8_t size = (uint8_t)(((uint16_t)(*first_byte_ptr) + 1) >> 1);
           if (size + (bmp_ptr->col_num >> 1) > bmp_ptr->src_row_bytes) {
             bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
             return 0;
           }
           *first_byte_ptr = bmp_ptr->out_row_bytes - bmp_ptr->col_num - 1;
         }
         for (uint8_t i = 0; i < *first_byte_ptr; i++) {
           if (i & 0x01) {
             *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) =
                 (*second_byte_ptr & 0x0F);
@@ skipping 341 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;
 }