Remove foo != NULL outside of xfa/

core/src/fxcodec/lgif/fx_gif.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/src/fxcodec/lgif/fx_gif.h"
 void CGifLZWDecoder::Input(uint8_t* src_buf, FX_DWORD src_size) {
   next_in = src_buf;
   avail_in = src_size;
@@ skipping 358 matching lines @@
   gif_ptr->pt_ptr_arr_ptr = new CFX_ArrayTemplate<GifPlainText*>;
 #endif
   return gif_ptr;
 }
 void _gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
   if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
     return;
   }
   gif_decompress_struct_p gif_ptr = *gif_ptr_ptr;
   *gif_ptr_ptr = NULL;
-  if (gif_ptr->global_pal_ptr != NULL) {
-    FX_Free(gif_ptr->global_pal_ptr);
-  }
-  if (gif_ptr->img_decoder_ptr != NULL) {
-    delete gif_ptr->img_decoder_ptr;
-  }
-  if (gif_ptr->img_ptr_arr_ptr != NULL) {
+  FX_Free(gif_ptr->global_pal_ptr);
+  delete gif_ptr->img_decoder_ptr;
+  if (gif_ptr->img_ptr_arr_ptr) {
     int32_t size_img_arr = gif_ptr->img_ptr_arr_ptr->GetSize();
     for (int32_t i = 0; i < size_img_arr; i++) {
       GifImage* p = gif_ptr->img_ptr_arr_ptr->GetAt(i);
-      if (p->image_info_ptr != NULL) {
-        FX_Free(p->image_info_ptr);
-      }
-      if (p->image_gce_ptr != NULL) {
-        FX_Free(p->image_gce_ptr);
-      }
-      if (p->image_row_buf != NULL) {
-        FX_Free(p->image_row_buf);
-      }
-      if (p->local_pal_ptr != NULL &&
-          p->local_pal_ptr != gif_ptr->global_pal_ptr) {
+      FX_Free(p->image_info_ptr);
+      FX_Free(p->image_gce_ptr);
+      FX_Free(p->image_row_buf);
+      if (p->local_pal_ptr && p->local_pal_ptr != gif_ptr->global_pal_ptr) {
         FX_Free(p->local_pal_ptr);
       }
       FX_Free(p);
     }
     gif_ptr->img_ptr_arr_ptr->RemoveAll();
     delete gif_ptr->img_ptr_arr_ptr;
   }
 #ifdef GIF_SUPPORT_APPLICATION_EXTENSION
-  if (gif_ptr->app_data != NULL) {
-    FX_Free(gif_ptr->app_data);
-  }
+  FX_Free(gif_ptr->app_data);
 #endif
 #ifdef GIF_SUPPORT_COMMENT_EXTENSION
-  if (gif_ptr->cmt_data_ptr != NULL) {
-    delete gif_ptr->cmt_data_ptr;
-  }
+  delete gif_ptr->cmt_data_ptr;
 #endif
 #ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
-  if (gif_ptr->gce_ptr != NULL) {
-    FX_Free(gif_ptr->gce_ptr);
-  }
+  FX_Free(gif_ptr->gce_ptr);
 #endif
 #ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
-  if (gif_ptr->pt_ptr_arr_ptr != NULL) {
+  if (gif_ptr->pt_ptr_arr_ptr) {
     int32_t size_pt_arr = gif_ptr->pt_ptr_arr_ptr->GetSize();
     for (int32_t i = 0; i < size_pt_arr; i++) {
       GifPlainText* p = gif_ptr->pt_ptr_arr_ptr->GetAt(i);
-      if (p->gce_ptr != NULL) {
-        FX_Free(p->gce_ptr);
-      }
-      if (p->pte_ptr != NULL) {
-        FX_Free(p->pte_ptr);
-      }
-      if (p->string_ptr != NULL) {
-        delete p->string_ptr;
-      }
+      FX_Free(p->gce_ptr);
+      FX_Free(p->pte_ptr);
+      delete p->string_ptr;
     }
     gif_ptr->pt_ptr_arr_ptr->RemoveAll();
     delete gif_ptr->pt_ptr_arr_ptr;
   }
 #endif
   FX_Free(gif_ptr);
 }
 gif_compress_struct_p _gif_create_compress() {
   gif_compress_struct_p gif_ptr =
       (gif_compress_struct*)FX_Alloc(uint8_t, sizeof(gif_compress_struct));
@@ skipping 58 matching lines @@
   gif_ptr->pte_ptr->block_size = 12;
 #endif
   return gif_ptr;
 }
 void _gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr) {
   if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
     return;
   }
   gif_compress_struct_p gif_ptr = *gif_ptr_ptr;
   *gif_ptr_ptr = NULL;
-  if (gif_ptr->header_ptr != NULL) {
-    FX_Free(gif_ptr->header_ptr);
-  }
-  if (gif_ptr->lsd_ptr != NULL) {
-    FX_Free(gif_ptr->lsd_ptr);
-  }
-  if (gif_ptr->global_pal != NULL) {
-    FX_Free(gif_ptr->global_pal);
-  }
-  if (gif_ptr->image_info_ptr != NULL) {
-    FX_Free(gif_ptr->image_info_ptr);
-  }
-  if (gif_ptr->local_pal != NULL) {
-    FX_Free(gif_ptr->local_pal);
-  }
-  if (gif_ptr->img_encoder_ptr != NULL) {
-    delete gif_ptr->img_encoder_ptr;
-  }
+  FX_Free(gif_ptr->header_ptr);
+  FX_Free(gif_ptr->lsd_ptr);
+  FX_Free(gif_ptr->global_pal);
+  FX_Free(gif_ptr->image_info_ptr);
+  FX_Free(gif_ptr->local_pal);
+  delete gif_ptr->img_encoder_ptr;
 #ifdef GIF_SUPPORT_APPLICATION_EXTENSION
-  if (gif_ptr->app_data != NULL) {
-    FX_Free(gif_ptr->app_data);
-  }
+  FX_Free(gif_ptr->app_data);
 #endif
 #ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
-  if (gif_ptr->gce_ptr != NULL) {
-    FX_Free(gif_ptr->gce_ptr);
-  }
+  FX_Free(gif_ptr->gce_ptr);
 #endif
 #ifdef GIF_SUPPORT_COMMENT_EXTENSION
-  if (gif_ptr->cmt_data_ptr != NULL) {
-    FX_Free(gif_ptr->cmt_data_ptr);
-  }
+  FX_Free(gif_ptr->cmt_data_ptr);
 #endif
 #ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
-  if (gif_ptr->pte_ptr != NULL) {
-    FX_Free(gif_ptr->pte_ptr);
-  }
+  FX_Free(gif_ptr->pte_ptr);
 #endif
   FX_Free(gif_ptr);
 }
 void _gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {
-  if (gif_ptr != NULL && gif_ptr->_gif_error_fn != NULL) {
+  if (gif_ptr && gif_ptr->_gif_error_fn) {
     gif_ptr->_gif_error_fn(gif_ptr, err_msg);
   }
 }
 void _gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {}
 int32_t _gif_read_header(gif_decompress_struct_p gif_ptr) {
   if (gif_ptr == NULL) {
     return 0;
   }
   FX_DWORD skip_size_org = gif_ptr->skip_size;
   ASSERT(sizeof(GifHeader) == 6);
@@ skipping 18 matching lines @@
     ASSERT(sizeof(GifPalette) == 3);
     int32_t global_pal_size = gif_ptr->global_pal_num * 3;
     uint8_t* global_pal_ptr = NULL;
     if (_gif_read_data(gif_ptr, &global_pal_ptr, global_pal_size) == NULL) {
       gif_ptr->skip_size = skip_size_org;
       return 2;
     }
     gif_ptr->global_sort_flag = ((GifGF*)&gif_lsd_ptr->global_flag)->sort_flag;
     gif_ptr->global_color_resolution =
         ((GifGF*)&gif_lsd_ptr->global_flag)->color_resolution;
-    if (gif_ptr->global_pal_ptr != NULL) {
-      FX_Free(gif_ptr->global_pal_ptr);
-    }
-    gif_ptr->global_pal_ptr = NULL;
+    FX_Free(gif_ptr->global_pal_ptr);
     gif_ptr->global_pal_ptr = (GifPalette*)FX_Alloc(uint8_t, global_pal_size);
-    GIF_PTR_NOT_NULL(gif_ptr->global_pal_ptr, gif_ptr);
     FXSYS_memcpy(gif_ptr->global_pal_ptr, global_pal_ptr, global_pal_size);
   }
   gif_ptr->width = (int)_GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->width);
   gif_ptr->height = (int)_GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->height);
   gif_ptr->bc_index = gif_lsd_ptr->bc_index;
   gif_ptr->pixel_aspect = gif_lsd_ptr->pixel_aspect;
   return 1;
 }
 int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr) {
   if (gif_ptr == NULL) {
@@ skipping 103 matching lines @@
         continue;
       }
     }
   }
   return 1;
 }
 void _gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
                            GifGCE** gce_ptr_ptr) {
   *gce_ptr_ptr = NULL;
 #ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
-  if (gif_ptr->gce_ptr != NULL && gce_ptr_ptr != NULL) {
+  if (gif_ptr->gce_ptr && gce_ptr_ptr) {
     *gce_ptr_ptr = gif_ptr->gce_ptr;
     gif_ptr->gce_ptr = NULL;
   }
 #endif
 }
 int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
   uint8_t* data_size_ptr = NULL;
   uint8_t* data_ptr = NULL;
   FX_DWORD skip_size_org = gif_ptr->skip_size;
   switch (gif_ptr->decode_status) {
@@ skipping 15 matching lines @@
             _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
           gif_ptr->skip_size = skip_size_org;
           return 2;
         }
         gif_ae_data_str += CFX_ByteString((const uint8_t*)data_ptr, data_size);
       }
       FXSYS_memcpy(gif_ptr->app_identify, gif_ae_ptr->app_identify, 8);
       FXSYS_memcpy(gif_ptr->app_authentication, gif_ae_ptr->app_authentication,
                    3);
       gif_ptr->app_data_size = gif_ae_data_str.GetLength();
-      if (gif_ptr->app_data != NULL) {
-        FX_Free(gif_ptr->app_data);
-        gif_ptr->app_data = NULL;
-      }
+      FX_Free(gif_ptr->app_data);
       gif_ptr->app_data = FX_Alloc(uint8_t, gif_ptr->app_data_size);
-      GIF_PTR_NOT_NULL(gif_ptr->app_data, gif_ptr);
       FXSYS_memcpy(gif_ptr->app_data, const uint8_t*(gif_ae_data_str),
                    gif_ptr->app_data_size);
     } break;
 #endif
 #ifdef GIF_SUPPORT_COMMENT_EXTENSION
     case GIF_D_STATUS_EXT_CE: {
       if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
         gif_ptr->skip_size = skip_size_org;
         return 2;
       }
@@ skipping 11 matching lines @@
     } break;
 #endif
 #ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
     case GIF_D_STATUS_EXT_PTE: {
       ASSERT(sizeof(GifPTE) == 13);
       GifPTE* gif_pte_ptr = NULL;
       if (_gif_read_data(gif_ptr, (uint8_t**)&gif_pte_ptr, 13) == NULL) {
         return 2;
       }
       GifPlainText* gif_pt_ptr = FX_Alloc(GifPlainText, 1);
-      GIF_PTR_NOT_NULL(gif_pt_ptr, gif_ptr);
       FXSYS_memset(gif_pt_ptr, 0, sizeof(GifPlainText));
       _gif_takeover_gce_ptr(gif_ptr, &gif_pt_ptr->gce_ptr);
       gif_pt_ptr->pte_ptr = (GifPTE*)FX_Alloc(uint8_t, sizeof(GifPTE));
-      GIF_PTR_NOT_NULL(gif_pt_ptr->pte_ptr, gif_ptr);
       gif_pt_ptr->string_ptr = new CFX_ByteString;
-      GIF_PTR_NOT_NULL(gif_pt_ptr->string_ptr, gif_ptr);
       gif_pt_ptr->pte_ptr->block_size = gif_pte_ptr->block_size;
       gif_pt_ptr->pte_ptr->grid_left =
           _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_left);
       gif_pt_ptr->pte_ptr->grid_top =
           _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_top);
       gif_pt_ptr->pte_ptr->grid_width =
           _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_width);
       gif_pt_ptr->pte_ptr->grid_height =
           _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_height);
       gif_pt_ptr->pte_ptr->char_width = gif_pte_ptr->char_width;
       gif_pt_ptr->pte_ptr->char_height = gif_pte_ptr->char_height;
       gif_pt_ptr->pte_ptr->fc_index = gif_pte_ptr->fc_index;
       gif_pt_ptr->pte_ptr->bc_index = gif_pte_ptr->bc_index;
       if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
         gif_ptr->skip_size = skip_size_org;
-        if (gif_pt_ptr != NULL) {
-          if (gif_pt_ptr->gce_ptr != NULL) {
-            FX_Free(gif_pt_ptr->gce_ptr);
-          }
-          if (gif_pt_ptr->pte_ptr != NULL) {
-            FX_Free(gif_pt_ptr->pte_ptr);
-          }
-          if (gif_pt_ptr->string_ptr != NULL) {
-            delete gif_pt_ptr->string_ptr;
-          }
+        if (gif_pt_ptr) {
+          FX_Free(gif_pt_ptr->gce_ptr);
+          FX_Free(gif_pt_ptr->pte_ptr);
+          delete gif_pt_ptr->string_ptr;
           FX_Free(gif_pt_ptr);
         }
         return 2;
       }
       while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
         uint8_t data_size = *data_size_ptr;
         if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
             _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
           gif_ptr->skip_size = skip_size_org;
-          if (gif_pt_ptr != NULL) {
-            if (gif_pt_ptr->gce_ptr != NULL) {
-              FX_Free(gif_pt_ptr->gce_ptr);
-            }
-            if (gif_pt_ptr->pte_ptr != NULL) {
-              FX_Free(gif_pt_ptr->pte_ptr);
-            }
-            if (gif_pt_ptr->string_ptr != NULL) {
-              delete gif_pt_ptr->string_ptr;
-            }
+          if (gif_pt_ptr) {
+            FX_Free(gif_pt_ptr->gce_ptr);
+            FX_Free(gif_pt_ptr->pte_ptr);
+            delete gif_pt_ptr->string_ptr;
             FX_Free(gif_pt_ptr);
           }
           return 2;
         }
         *(gif_pt_ptr->string_ptr) +=
             CFX_ByteString((const FX_CHAR*)data_ptr, data_size);
       }
       gif_ptr->pt_ptr_arr_ptr->Add(gif_pt_ptr);
     } break;
 #endif
 #ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
     case GIF_D_STATUS_EXT_GCE: {
       ASSERT(sizeof(GifGCE) == 5);
       GifGCE* gif_gce_ptr = NULL;
       if (_gif_read_data(gif_ptr, (uint8_t**)&gif_gce_ptr, 6) == NULL) {
         return 2;
       }
       if (gif_ptr->gce_ptr == NULL) {
         gif_ptr->gce_ptr = (GifGCE*)FX_Alloc(uint8_t, sizeof(GifGCE));
-        GIF_PTR_NOT_NULL(gif_ptr->gce_ptr, gif_ptr);
       }
       gif_ptr->gce_ptr->block_size = gif_gce_ptr->block_size;
       gif_ptr->gce_ptr->gce_flag = gif_gce_ptr->gce_flag;
       gif_ptr->gce_ptr->delay_time =
           _GetWord_LSBFirst((uint8_t*)&gif_gce_ptr->delay_time);
       gif_ptr->gce_ptr->trans_index = gif_gce_ptr->trans_index;
     } break;
 #endif
     default: {
 #ifndef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
+#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
       if (gif_ptr->decode_status == GIF_D_STATUS_EXT_PTE) {
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
-        if (gif_ptr->gce_ptr != NULL) {
-          FX_Free(gif_ptr->gce_ptr);
-          gif_ptr->gce_ptr = NULL;
-        }
+        FX_Free(gif_ptr->gce_ptr);
+        gif_ptr->gce_ptr = NULL;
+      }
 #endif
-      }
 #endif
       if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
         return 2;
       }
       while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
         if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
             _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
           gif_ptr->skip_size = skip_size_org;
           return 2;
         }
       }
     }
   }
   _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
   return 1;
 }
 int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
   if (gif_ptr->width == 0 || gif_ptr->height == 0) {
     _gif_error(gif_ptr, "No Image Header Info");
     return 0;
   }
   FX_DWORD skip_size_org = gif_ptr->skip_size;
   ASSERT(sizeof(GifImageInfo) == 9);
   GifImageInfo* gif_img_info_ptr = NULL;
   if (_gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) {
     return 2;
   }
   GifImage* gif_image_ptr = (GifImage*)FX_Alloc(uint8_t, sizeof(GifImage));
-  GIF_PTR_NOT_NULL(gif_image_ptr, gif_ptr);
   FXSYS_memset(gif_image_ptr, 0, sizeof(GifImage));
   gif_image_ptr->image_info_ptr =
       (GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo));
-  GIF_PTR_NOT_NULL(gif_image_ptr->image_info_ptr, gif_ptr);
   gif_image_ptr->image_info_ptr->left =
       _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->left);
   gif_image_ptr->image_info_ptr->top =
       _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->top);
   gif_image_ptr->image_info_ptr->width =
       _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->width);
   gif_image_ptr->image_info_ptr->height =
       _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->height);
   gif_image_ptr->image_info_ptr->local_flag = gif_img_info_ptr->local_flag;
   if (gif_image_ptr->image_info_ptr->left +
               gif_image_ptr->image_info_ptr->width >
           gif_ptr->width ||
       gif_image_ptr->image_info_ptr->top +
               gif_image_ptr->image_info_ptr->height >
           gif_ptr->height) {
-    if (gif_image_ptr->image_info_ptr != NULL) {
-      FX_Free(gif_image_ptr->image_info_ptr);
-    }
-    if (gif_image_ptr->image_row_buf != NULL) {
-      FX_Free(gif_image_ptr->image_row_buf);
-    }
+    FX_Free(gif_image_ptr->image_info_ptr);
+    FX_Free(gif_image_ptr->image_row_buf);
     FX_Free(gif_image_ptr);
     _gif_error(gif_ptr, "Image Data Out Of LSD, The File May Be Corrupt");
     return 0;
   }
   GifLF* gif_img_info_lf_ptr = (GifLF*)&gif_img_info_ptr->local_flag;
   if (gif_img_info_lf_ptr->local_pal) {
     ASSERT(sizeof(GifPalette) == 3);
     int32_t loc_pal_size = (2 << gif_img_info_lf_ptr->pal_bits) * 3;
     uint8_t* loc_pal_ptr = NULL;
     if (_gif_read_data(gif_ptr, &loc_pal_ptr, loc_pal_size) == NULL) {
       gif_ptr->skip_size = skip_size_org;
-      if (gif_image_ptr->image_info_ptr != NULL) {
-        FX_Free(gif_image_ptr->image_info_ptr);
-      }
-      if (gif_image_ptr->image_row_buf != NULL) {
-        FX_Free(gif_image_ptr->image_row_buf);
-      }
+      FX_Free(gif_image_ptr->image_info_ptr);
+      FX_Free(gif_image_ptr->image_row_buf);
       FX_Free(gif_image_ptr);
       return 2;
     }
     gif_image_ptr->local_pal_ptr =
         (GifPalette*)gif_ptr->_gif_ask_buf_for_pal_fn(gif_ptr, loc_pal_size);
-    if (gif_image_ptr->local_pal_ptr != NULL) {
+    if (gif_image_ptr->local_pal_ptr) {
       FXSYS_memcpy((uint8_t*)gif_image_ptr->local_pal_ptr, loc_pal_ptr,
                    loc_pal_size);
     }
   }
   uint8_t* code_size_ptr = NULL;
   if (_gif_read_data(gif_ptr, &code_size_ptr, 1) == NULL) {
     gif_ptr->skip_size = skip_size_org;
-    if (gif_image_ptr->image_info_ptr != NULL) {
-      FX_Free(gif_image_ptr->image_info_ptr);
-    }
-    if (gif_image_ptr->local_pal_ptr != NULL) {
-      FX_Free(gif_image_ptr->local_pal_ptr);
-    }
-    if (gif_image_ptr->image_row_buf != NULL) {
-      FX_Free(gif_image_ptr->image_row_buf);
-    }
+    FX_Free(gif_image_ptr->image_info_ptr);
+    FX_Free(gif_image_ptr->local_pal_ptr);
+    FX_Free(gif_image_ptr->image_row_buf);
     FX_Free(gif_image_ptr);
     return 2;
   }
   gif_image_ptr->image_code_size = *code_size_ptr;
   gif_ptr->_gif_record_current_position_fn(gif_ptr,
                                            &gif_image_ptr->image_data_pos);
   gif_image_ptr->image_data_pos += gif_ptr->skip_size;
   _gif_takeover_gce_ptr(gif_ptr, &gif_image_ptr->image_gce_ptr);
   gif_ptr->img_ptr_arr_ptr->Add(gif_image_ptr);
   _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
   return 1;
 }
 int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
   if (gif_ptr == NULL || frame_num < 0 ||
       frame_num >= gif_ptr->img_ptr_arr_ptr->GetSize()) {
     return 0;
   }
   uint8_t* data_size_ptr = NULL;
   uint8_t* data_ptr = NULL;
   FX_DWORD skip_size_org = gif_ptr->skip_size;
   GifImage* gif_image_ptr = gif_ptr->img_ptr_arr_ptr->GetAt(frame_num);
   FX_DWORD gif_img_row_bytes = gif_image_ptr->image_info_ptr->width;
   if (gif_ptr->decode_status == GIF_D_STATUS_TAIL) {
     if (gif_image_ptr->image_row_buf) {
       FX_Free(gif_image_ptr->image_row_buf);
       gif_image_ptr->image_row_buf = NULL;
     }
     gif_image_ptr->image_row_buf = FX_Alloc(uint8_t, gif_img_row_bytes);
-    GIF_PTR_NOT_NULL(gif_image_ptr->image_row_buf, gif_ptr);
     GifGCE* gif_img_gce_ptr = gif_image_ptr->image_gce_ptr;
     int32_t loc_pal_num =
         ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)->local_pal
             ? (2 << ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
                         ->pal_bits)
             : 0;
     gif_ptr->avail_in = 0;
     if (gif_img_gce_ptr == NULL) {
       FX_BOOL bRes = gif_ptr->_gif_get_record_position_fn(
           gif_ptr, gif_image_ptr->image_data_pos,
@@ skipping 30 matching lines @@
               ->interlace);
       if (!bRes) {
         FX_Free(gif_image_ptr->image_row_buf);
         gif_image_ptr->image_row_buf = NULL;
         _gif_error(gif_ptr, "Error Read Record Position Data");
         return 0;
       }
     }
     if (gif_ptr->img_decoder_ptr == NULL) {
       gif_ptr->img_decoder_ptr = new CGifLZWDecoder(gif_ptr->err_ptr);
-      GIF_PTR_NOT_NULL(gif_ptr->img_decoder_ptr, gif_ptr);
     }
     gif_ptr->img_decoder_ptr->InitTable(gif_image_ptr->image_code_size);
     gif_ptr->img_row_offset = 0;
     gif_ptr->img_row_avail_size = 0;
     gif_ptr->img_pass_num = 0;
     gif_image_ptr->image_row_num = 0;
     _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
   }
   CGifLZWDecoder* img_decoder_ptr = gif_ptr->img_decoder_ptr;
   if (gif_ptr->decode_status == GIF_D_STATUS_IMG_DATA) {
@@ skipping 104 matching lines @@
 }
 void _gif_input_buffer(gif_decompress_struct_p gif_ptr,
                        uint8_t* src_buf,
                        FX_DWORD src_size) {
   gif_ptr->next_in = src_buf;
   gif_ptr->avail_in = src_size;
   gif_ptr->skip_size = 0;
 }
 FX_DWORD _gif_get_avail_input(gif_decompress_struct_p gif_ptr,
                               uint8_t** avial_buf_ptr) {
-  if (avial_buf_ptr != NULL) {
+  if (avial_buf_ptr) {
     *avial_buf_ptr = NULL;
     if (gif_ptr->avail_in > 0) {
       *avial_buf_ptr = gif_ptr->next_in;
     }
   }
   return gif_ptr->avail_in;
 }
 int32_t _gif_get_frame_num(gif_decompress_struct_p gif_ptr) {
   return gif_ptr->img_ptr_arr_ptr->GetSize();
 }
@@ skipping 224 matching lines @@
     gif_ptr->cur_offset = cur_offset;
     res = FALSE;
   }
   dst_len = gif_ptr->cur_offset;
   dst_buf[dst_len - 1] = GIF_SIG_TRAILER;
   if (res) {
     gif_ptr->frames++;
   }
   return res;
 }