Get rid of NULLs in core/

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>
 
@@ skipping 22 matching lines @@
   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);
-  if (bmp_ptr == NULL) {
-    return NULL;
-  }
   FXSYS_memset(bmp_ptr, 0, sizeof(bmp_decompress_struct));
   bmp_ptr->decode_status = BMP_D_STATUS_HEADER;
   bmp_ptr->bmp_header_ptr = FX_Alloc(BmpFileHeader, 1);
   return bmp_ptr;
 }
 void bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr) {
-  if (bmp_ptr_ptr == NULL || *bmp_ptr_ptr == NULL) {
+  if (!bmp_ptr_ptr || !*bmp_ptr_ptr)
     return;
-  }
+
   bmp_decompress_struct_p bmp_ptr = *bmp_ptr_ptr;
-  *bmp_ptr_ptr = NULL;
+  *bmp_ptr_ptr = nullptr;
   if (bmp_ptr->out_row_buffer) {
     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) {
+  if (!bmp_ptr)
     return 0;
-  }
+
   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) {
+    BmpFileHeader* bmp_header_ptr = nullptr;
+    if (!bmp_read_data(bmp_ptr, (uint8_t**)&bmp_header_ptr, 14))
       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(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");
     switch (bmp_ptr->img_ifh_size) {
       case kBmpCoreHeaderSize: {
         bmp_ptr->pal_type = 1;
-        BmpCoreHeaderPtr bmp_core_header_ptr = NULL;
-        if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_core_header_ptr,
-                          bmp_ptr->img_ifh_size) == NULL) {
+        BmpCoreHeaderPtr bmp_core_header_ptr = nullptr;
+        if (!bmp_read_data(bmp_ptr, (uint8_t**)&bmp_core_header_ptr,
+                           bmp_ptr->img_ifh_size)) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         bmp_ptr->width =
             GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcWidth);
         bmp_ptr->height =
             GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcHeight);
         bmp_ptr->bitCounts =
             GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcBitCount);
         bmp_ptr->compress_flag = BMP_RGB;
         bmp_ptr->imgTB_flag = FALSE;
       } break;
       case kBmpInfoHeaderSize: {
-        BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
-        if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
-                          bmp_ptr->img_ifh_size) == NULL) {
+        BmpInfoHeaderPtr bmp_info_header_ptr = nullptr;
+        if (!bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
+                           bmp_ptr->img_ifh_size)) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         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);
         bmp_ptr->dpi_x = (int32_t)GetDWord_LSBFirst(
             (uint8_t*)&bmp_info_header_ptr->biXPelsPerMeter);
         bmp_ptr->dpi_y = (int32_t)GetDWord_LSBFirst(
             (uint8_t*)&bmp_info_header_ptr->biYPelsPerMeter);
         if (bmp_ptr->height < 0) {
           bmp_ptr->height = -bmp_ptr->height;
           bmp_ptr->imgTB_flag = TRUE;
         }
       } 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) {
+          BmpInfoHeaderPtr bmp_info_header_ptr = nullptr;
+          if (!bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
+                             bmp_ptr->img_ifh_size)) {
             bmp_ptr->skip_size = skip_size_org;
             return 2;
           }
           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);
@@ skipping 67 matching lines @@
   }
   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;
       }
       uint32_t* mask;
       if (bmp_read_data(bmp_ptr, (uint8_t**)&mask, 3 * sizeof(uint32_t)) ==
-          NULL) {
+          nullptr) {
         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) {
         bmp_error(bmp_ptr, "The Bitfield Bmp File Is Corrupt");
         return 0;
       }
       if (bmp_ptr->bmp_header_ptr->bfOffBits < 26 + bmp_ptr->img_ifh_size) {
         bmp_ptr->bmp_header_ptr->bfOffBits = 26 + bmp_ptr->img_ifh_size;
       }
       bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA_PRE);
       return 1;
     } else if (bmp_ptr->bitCounts == 16) {
       bmp_ptr->mask_red = 0x7C00;
       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;
+      uint8_t* src_pal_ptr = nullptr;
       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) {
+          nullptr) {
         bmp_ptr->skip_size = skip_size_org;
         return 2;
       }
       FX_Free(bmp_ptr->pal_ptr);
       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]);
@@ skipping 39 matching lines @@
         return bmp_decode_rle8(bmp_ptr);
       case BMP_RLE4:
         return bmp_decode_rle4(bmp_ptr);
     }
   }
   bmp_error(bmp_ptr, "Any Uncontrol Error");
   return 0;
 }
 int32_t bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
   uint8_t* row_buf = bmp_ptr->out_row_buffer;
-  uint8_t* des_buf = NULL;
+  uint8_t* des_buf = nullptr;
   while (bmp_ptr->row_num < bmp_ptr->height) {
-    if (bmp_read_data(bmp_ptr, &des_buf, bmp_ptr->src_row_bytes) == NULL) {
+    if (!bmp_read_data(bmp_ptr, &des_buf, bmp_ptr->src_row_bytes))
       return 2;
-    }
+
     bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
     switch (bmp_ptr->bitCounts) {
       case 1: {
         for (int32_t col = 0; col < bmp_ptr->width; col++) {
           *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)
@@ skipping 38 matching lines @@
     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);
   }
   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;
+  uint8_t* first_byte_ptr = nullptr;
+  uint8_t* second_byte_ptr = nullptr;
   bmp_ptr->col_num = 0;
   while (TRUE) {
     uint32_t skip_size_org = bmp_ptr->skip_size;
-    if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+    if (!bmp_read_data(bmp_ptr, &first_byte_ptr, 1))
       return 2;
-    }
+
     switch (*first_byte_ptr) {
       case RLE_MARKER: {
-        if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+        if (!bmp_read_data(bmp_ptr, &first_byte_ptr, 1)) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         switch (*first_byte_ptr) {
           case RLE_EOL: {
             if (bmp_ptr->row_num >= bmp_ptr->height) {
               bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
               bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
               return 0;
             }
@@ skipping 13 matching lines @@
                   bmp_ptr, bmp_ptr->imgTB_flag
                                ? bmp_ptr->row_num++
                                : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
                   bmp_ptr->out_row_buffer);
             }
             bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
             return 1;
           }
           case RLE_DELTA: {
             uint8_t* delta_ptr;
-            if (bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+            if (!bmp_read_data(bmp_ptr, &delta_ptr, 2)) {
               bmp_ptr->skip_size = skip_size_org;
               return 2;
             }
             bmp_ptr->col_num += (int32_t)delta_ptr[0];
             int32_t bmp_row_num_next = bmp_ptr->row_num + (int32_t)delta_ptr[1];
             if (bmp_ptr->col_num >= bmp_ptr->out_row_bytes ||
                 bmp_row_num_next >= bmp_ptr->height) {
               bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
               return 0;
             }
             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: {
             if ((int32_t)(*first_byte_ptr) >
                 bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
               bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
               return 0;
             }
-            if (bmp_read_data(bmp_ptr, &second_byte_ptr,
-                              *first_byte_ptr & 1 ? *first_byte_ptr + 1
-                                                  : *first_byte_ptr) == NULL) {
+            if (!bmp_read_data(bmp_ptr, &second_byte_ptr,
+                               *first_byte_ptr & 1 ? *first_byte_ptr + 1
+                                                   : *first_byte_ptr)) {
               bmp_ptr->skip_size = skip_size_org;
               return 2;
             }
             FXSYS_memcpy(bmp_ptr->out_row_buffer + bmp_ptr->col_num,
                          second_byte_ptr, *first_byte_ptr);
             bmp_ptr->col_num += (int32_t)(*first_byte_ptr);
           }
         }
       } break;
       default: {
-        if (bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+        if (!bmp_read_data(bmp_ptr, &second_byte_ptr, 1)) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         if ((int32_t)(*first_byte_ptr) >
             bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
           bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
           return 0;
         }
         FXSYS_memset(bmp_ptr->out_row_buffer + bmp_ptr->col_num,
                      *second_byte_ptr, *first_byte_ptr);
         bmp_ptr->col_num += (int32_t)(*first_byte_ptr);
       }
     }
   }
   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;
+  uint8_t* first_byte_ptr = nullptr;
+  uint8_t* second_byte_ptr = nullptr;
   bmp_ptr->col_num = 0;
   while (TRUE) {
     uint32_t skip_size_org = bmp_ptr->skip_size;
-    if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+    if (!bmp_read_data(bmp_ptr, &first_byte_ptr, 1))
       return 2;
-    }
+
     switch (*first_byte_ptr) {
       case RLE_MARKER: {
-        if (bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+        if (!bmp_read_data(bmp_ptr, &first_byte_ptr, 1)) {
           bmp_ptr->skip_size = skip_size_org;
           return 2;
         }
         switch (*first_byte_ptr) {
           case RLE_EOL: {
             if (bmp_ptr->row_num >= bmp_ptr->height) {
               bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
               bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
               return 0;
             }
@@ skipping 13 matching lines @@
                   bmp_ptr, bmp_ptr->imgTB_flag
                                ? bmp_ptr->row_num++
                                : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
                   bmp_ptr->out_row_buffer);
             }
             bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
             return 1;
           }
           case RLE_DELTA: {
             uint8_t* delta_ptr;
-            if (bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+            if (!bmp_read_data(bmp_ptr, &delta_ptr, 2)) {
               bmp_ptr->skip_size = skip_size_org;
               return 2;
             }
             bmp_ptr->col_num += (int32_t)delta_ptr[0];
             int32_t bmp_row_num_next = bmp_ptr->row_num + (int32_t)delta_ptr[1];
             if (bmp_ptr->col_num >= bmp_ptr->out_row_bytes ||
                 bmp_row_num_next >= bmp_ptr->height) {
               bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
               return 0;
             }
             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)(((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) {
+            if (!bmp_read_data(bmp_ptr, &second_byte_ptr,
+                               size & 1 ? size + 1 : size)) {
               bmp_ptr->skip_size = skip_size_org;
               return 2;
             }
             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);
               } else {
                 *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) =
                     ((*second_byte_ptr & 0xF0) >> 4);
               }
             }
           }
         }
       } break;
       default: {
-        if (bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+        if (!bmp_read_data(bmp_ptr, &second_byte_ptr, 1)) {
           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)(((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;
           }
@@ skipping 10 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,
                        uint32_t data_size) {
-  if (bmp_ptr == NULL || bmp_ptr->avail_in < bmp_ptr->skip_size + data_size) {
-    return NULL;
-  }
+  if (!bmp_ptr || bmp_ptr->avail_in < bmp_ptr->skip_size + data_size)
+    return nullptr;
+
   *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,
                       uint32_t src_size) {
   bmp_ptr->next_in = src_buf;
   bmp_ptr->avail_in = src_size;
   bmp_ptr->skip_size = 0;
 }
 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;
+    *avial_buf_ptr = nullptr;
     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) {
@@ skipping 55 matching lines @@
   if (bmp_ptr->info_header.biBitCount != 16 &&
       bmp_ptr->info_header.biBitCount != 32) {
     return;
   }
   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);
   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;
@@ skipping 64 matching lines @@
     bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
     return;
   }
   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--) {
     FXSYS_memcpy(&dst_buf[dst_pos],
                  &bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch],
                  bmp_ptr->src_pitch);
     dst_pos += dst_pitch;
   }
   dst_size = dst_pos;
 }
 static uint8_t bmp_rle8_search(const uint8_t* buf, int32_t len) {
   uint8_t num;
   num = 1;
   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,
                             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;) {
     index = row_num * bmp_ptr->src_pitch;
     rle[0] = bmp_rle8_search(&bmp_ptr->src_buf[index + i], size - index - i);
     rle[1] = bmp_ptr->src_buf[index + i];
     if (i + rle[0] >= (int32_t)bmp_ptr->src_pitch) {
       rle[0] = uint8_t(bmp_ptr->src_pitch - i);
       if (rle[0]) {
         dst_buf[dst_pos++] = rle[0];
         dst_buf[dst_pos++] = rle[1];
@@ skipping 25 matching lines @@
 }
 static void bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
                             uint8_t*& dst_buf,
                             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;
        rle[1] = 0) {
     index = row_num * bmp_ptr->src_pitch;
     rle[0] = bmp_rle4_search(&bmp_ptr->src_buf[index + i], size - index - i);
     rle[1] |= (bmp_ptr->src_buf[index + i] & 0x0f) << 4;
     rle[1] |= bmp_ptr->src_buf[index + i + 1] & 0x0f;
     if (i + rle[0] >= (int32_t)bmp_ptr->src_pitch) {
       rle[0] = uint8_t(bmp_ptr->src_pitch - i);
       if (rle[0]) {
@@ skipping 18 matching lines @@
                          uint8_t*& dst_buf,
                          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(uint32_t) * bmp_ptr->info_header.biClrUsed;
   }
   dst_size = head_size + sizeof(uint32_t) * bmp_ptr->pal_num;
   dst_buf = FX_TryAlloc(uint8_t, dst_size);
-  if (dst_buf == NULL) {
+  if (!dst_buf)
     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;
   }
   WriteInfoHeader(&bmp_ptr->info_header, dst_buf);
   switch (bmp_ptr->info_header.biCompression) {
     case BMP_RGB:
       bmp_encode_rgb(bmp_ptr, dst_buf, dst_size);
       break;
     case BMP_BITFIELDS:
       bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
       break;
     case BMP_RLE8:
       bmp_encode_rle8(bmp_ptr, dst_buf, dst_size);
       break;
     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;
 }