Remove foo != NULL outside of xfa/

core/src/fxcodec/codec/fx_codec_progress.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/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_dib.h"
 #include "core/src/fxcodec/codec/fx_codec_progress.h"
 void CFXCODEC_WeightTable::Calc(int dest_len,
@@ skipping 254 matching lines @@
   m_SrcPaletteNumber = 0;
   m_GifPltNumber = 0;
   m_GifBgIndex = 0;
   m_pGifPalette = NULL;
   m_GifTransIndex = -1;
   m_GifFrameRect = FX_RECT(0, 0, 0, 0);
   m_BmpIsTopBottom = FALSE;
 }
 CCodec_ProgressiveDecoder::~CCodec_ProgressiveDecoder() {
   m_pFile = NULL;
-  if (m_pJpegContext != NULL) {
+  if (m_pJpegContext) {
     m_pCodecMgr->GetJpegModule()->Finish(m_pJpegContext);
   }
-  if (m_pPngContext != NULL) {
+  if (m_pPngContext) {
     m_pCodecMgr->GetPngModule()->Finish(m_pPngContext);
   }
-  if (m_pGifContext != NULL) {
+  if (m_pGifContext) {
     m_pCodecMgr->GetGifModule()->Finish(m_pGifContext);
   }
-  if (m_pBmpContext != NULL) {
+  if (m_pBmpContext) {
     m_pCodecMgr->GetBmpModule()->Finish(m_pBmpContext);
   }
-  if (m_pTiffContext != NULL) {
+  if (m_pTiffContext) {
     m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
   }
-  if (m_pSrcBuf != NULL) {
-    FX_Free(m_pSrcBuf);
-  }
-  if (m_pDecodeBuf != NULL) {
-    FX_Free(m_pDecodeBuf);
-  }
-  if (m_pSrcPalette != NULL) {
-    FX_Free(m_pSrcPalette);
-  }
+  FX_Free(m_pSrcBuf);
+  FX_Free(m_pDecodeBuf);
+  FX_Free(m_pSrcPalette);
 }
 FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
     ICodec_JpegModule* pJpegModule,
     FXCODEC_STATUS& err_status) {
   FX_DWORD dwSize = (FX_DWORD)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
   FX_DWORD dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, NULL);
@@ skipping 71 matching lines @@
       return FALSE;
   }
   *gamma = FXCODEC_PNG_GAMMA;
   return TRUE;
 }
 FX_BOOL CCodec_ProgressiveDecoder::PngAskScanlineBufFunc(void* pModule,
                                                          int line,
                                                          uint8_t*& src_buf) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
-  ASSERT(pDIBitmap != NULL);
-  if (pDIBitmap == NULL) {
+  if (!pDIBitmap) {
+    ASSERT(false);
     return FALSE;
   }
   if (line >= pCodec->m_clipBox.top && line < pCodec->m_clipBox.bottom) {
     double scale_y =
         (double)pCodec->m_sizeY / (double)pCodec->m_clipBox.Height();
     int32_t row =
         (int32_t)((line - pCodec->m_clipBox.top) * scale_y) + pCodec->m_startY;
     uint8_t* src_scan = (uint8_t*)pDIBitmap->GetScanline(row);
     uint8_t* des_scan = pCodec->m_pDecodeBuf;
     src_buf = pCodec->m_pDecodeBuf;
     int32_t src_Bpp = pDIBitmap->GetBPP() >> 3;
     int32_t des_Bpp = (pCodec->m_SrcFormat & 0xff) >> 3;
     int32_t src_left = pCodec->m_startX;
     int32_t des_left = pCodec->m_clipBox.left;
     src_scan += src_left * src_Bpp;
     des_scan += des_left * des_Bpp;
     for (int32_t src_col = 0; src_col < pCodec->m_sizeX; src_col++) {
       PixelWeight* pPixelWeights =
           pCodec->m_WeightHorzOO.GetPixelWeight(src_col);
       if (pPixelWeights->m_SrcStart != pPixelWeights->m_SrcEnd) {
         continue;
       }
       switch (pDIBitmap->GetFormat()) {
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
           ASSERT(FALSE);
           return FALSE;
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb: {
-          if (pDIBitmap->GetPalette() != NULL) {
+          if (pDIBitmap->GetPalette()) {
             return FALSE;
           }
           FX_DWORD des_g = 0;
           des_g += pPixelWeights->m_Weights[0] * src_scan[src_col];
           des_scan[pPixelWeights->m_SrcStart] = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
           FX_DWORD des_b = 0, des_g = 0, des_r = 0;
           const uint8_t* p = src_scan + src_col * src_Bpp;
@@ skipping 38 matching lines @@
   des_scan += des_left * des_Bpp;
   for (int32_t des_col = 0; des_col < m_sizeX; des_col++) {
     PixelWeight* pPixelWeights = m_WeightHorzOO.GetPixelWeight(des_col);
     switch (pDeviceBitmap->GetFormat()) {
       case FXDIB_1bppMask:
       case FXDIB_1bppRgb:
         ASSERT(FALSE);
         return;
       case FXDIB_8bppMask:
       case FXDIB_8bppRgb: {
-        if (pDeviceBitmap->GetPalette() != NULL) {
+        if (pDeviceBitmap->GetPalette()) {
           return;
         }
         FX_DWORD des_g = 0;
         des_g +=
             pPixelWeights->m_Weights[0] * src_scan[pPixelWeights->m_SrcStart];
         des_g +=
             pPixelWeights->m_Weights[1] * src_scan[pPixelWeights->m_SrcEnd];
         *des_scan++ = (uint8_t)(des_g >> 16);
       } break;
       case FXDIB_Rgb:
@@ skipping 34 matching lines @@
       default:
         return;
     }
   }
 }
 void CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc(void* pModule,
                                                                 int pass,
                                                                 int line) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
-  ASSERT(pDIBitmap != NULL);
+  ASSERT(pDIBitmap);
   int src_top = pCodec->m_clipBox.top;
   int src_bottom = pCodec->m_clipBox.bottom;
   int des_top = pCodec->m_startY;
   int src_hei = pCodec->m_clipBox.Height();
   int des_hei = pCodec->m_sizeY;
   if (line >= src_top && line < src_bottom) {
     double scale_y = (double)des_hei / (double)src_hei;
     int src_row = line - src_top;
     int des_row = (int)(src_row * scale_y) + des_top;
     if (des_row >= des_top + des_hei) {
@@ skipping 147 matching lines @@
       }
     }
   }
   return TRUE;
 }
 void CCodec_ProgressiveDecoder::GifReadScanlineCallback(void* pModule,
                                                         int32_t row_num,
                                                         uint8_t* row_buf) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
-  ASSERT(pDIBitmap != NULL);
+  ASSERT(pDIBitmap);
   int32_t img_width = pCodec->m_GifFrameRect.Width();
   if (!pDIBitmap->HasAlpha()) {
     uint8_t* byte_ptr = row_buf;
     for (int i = 0; i < img_width; i++) {
       if (*byte_ptr == pCodec->m_GifTransIndex) {
         *byte_ptr = pCodec->m_GifBgIndex;
       }
       byte_ptr++;
     }
   }
@@ skipping 67 matching lines @@
     const uint8_t* scan_src2 =
         pDeviceBitmap->GetScanline(pWeight->m_SrcEnd + des_top) + des_ScanOffet;
     for (int des_col = 0; des_col < m_sizeX; des_col++) {
       switch (pDeviceBitmap->GetFormat()) {
         case FXDIB_Invalid:
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
           return;
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb: {
-          if (pDeviceBitmap->GetPalette() != NULL) {
+          if (pDeviceBitmap->GetPalette()) {
             return;
           }
           int des_g = 0;
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
           FX_DWORD des_b = 0, des_g = 0, des_r = 0;
@@ skipping 82 matching lines @@
                                error_status)) {
     return FALSE;
   }
   return TRUE;
 }
 void CCodec_ProgressiveDecoder::BmpReadScanlineCallback(void* pModule,
                                                         int32_t row_num,
                                                         uint8_t* row_buf) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   CFX_DIBitmap* pDIBitmap = pCodec->m_pDeviceBitmap;
-  ASSERT(pDIBitmap != NULL);
+  ASSERT(pDIBitmap);
   FXSYS_memcpy(pCodec->m_pDecodeBuf, row_buf, pCodec->m_ScanlineSize);
   int src_top = pCodec->m_clipBox.top;
   int src_bottom = pCodec->m_clipBox.bottom;
   int des_top = pCodec->m_startY;
   int src_hei = pCodec->m_clipBox.Height();
   int des_hei = pCodec->m_sizeY;
   if (row_num >= src_top && row_num < src_bottom) {
     double scale_y = (double)des_hei / (double)src_hei;
     int src_row = row_num - src_top;
     int des_row = (int)(src_row * scale_y) + des_top;
@@ skipping 41 matching lines @@
     const uint8_t* scan_src2 =
         pDeviceBitmap->GetScanline(pWeight->m_SrcEnd + des_top) + des_ScanOffet;
     for (int des_col = 0; des_col < m_sizeX; des_col++) {
       switch (pDeviceBitmap->GetFormat()) {
         case FXDIB_Invalid:
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
           return;
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb: {
-          if (pDeviceBitmap->GetPalette() != NULL) {
+          if (pDeviceBitmap->GetPalette()) {
             return;
           }
           int des_g = 0;
           des_g += pWeight->m_Weights[0] * (*scan_src1++);
           des_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(des_g >> 16);
         } break;
         case FXDIB_Rgb:
         case FXDIB_Rgb32: {
           FX_DWORD des_b = 0, des_g = 0, des_r = 0;
@@ skipping 32 matching lines @@
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
     FXCODEC_IMAGE_TYPE imageType,
     CFX_DIBAttribute* pAttribute) {
   m_offSet = 0;
   FX_DWORD size = (FX_DWORD)m_pFile->GetSize();
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
-  if (m_pSrcBuf != NULL) {
-    FX_Free(m_pSrcBuf);
-    m_pSrcBuf = NULL;
-  }
+  FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
-  if (m_pSrcBuf == NULL) {
-    m_status = FXCODEC_STATUS_ERR_MEMORY;
-    return FALSE;
-  }
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
       ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (pBmpModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pBmpModule->InputImagePositionBufCallback =
@@ skipping 21 matching lines @@
           m_status = error_status;
           return FALSE;
         }
         readResult = pBmpModule->ReadHeader(
             m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
             &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       }
       if (readResult == 1) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
-        if (m_pSrcPalette != NULL) {
-          FX_Free(m_pSrcPalette);
-          m_pSrcPalette = NULL;
-        }
+        FX_Free(m_pSrcPalette);
         if (m_SrcPaletteNumber) {
           m_pSrcPalette = FX_Alloc(FX_ARGB, m_SrcPaletteNumber);
-          if (m_pSrcPalette == NULL) {
-            m_status = FXCODEC_STATUS_ERR_MEMORY;
-            return FALSE;
-          }
           FXSYS_memcpy(m_pSrcPalette, pPalette,
                        m_SrcPaletteNumber * sizeof(FX_DWORD));
+        } else {
+          m_pSrcPalette = nullptr;
         }
         return TRUE;
       }
-      if (m_pBmpContext != NULL) {
+      if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
         m_pBmpContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_JPG: {
       ICodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       if (pJpegModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
@@ skipping 22 matching lines @@
         }
         readResult =
             pJpegModule->ReadHeader(m_pJpegContext, &m_SrcWidth, &m_SrcHeight,
                                     &m_SrcComponents, pAttribute);
       }
       if (!readResult) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
         return TRUE;
       }
-      if (m_pJpegContext != NULL) {
+      if (m_pJpegContext) {
         pJpegModule->Finish(m_pJpegContext);
         m_pJpegContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_PNG: {
       ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       if (pPngModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
@@ skipping 15 matching lines @@
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       bResult = pPngModule->Input(m_pPngContext, m_pSrcBuf, size, pAttribute);
       while (bResult) {
         FX_DWORD remain_size = (FX_DWORD)m_pFile->GetSize() - m_offSet;
         FX_DWORD input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
-          if (m_pPngContext != NULL) {
+          if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = NULL;
           m_status = FXCODEC_STATUS_ERR_FORMAT;
           return FALSE;
         }
-        if (m_pSrcBuf != NULL && input_size > m_SrcSize) {
+        if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
-          if (m_pSrcBuf == NULL) {
-            m_status = FXCODEC_STATUS_ERR_MEMORY;
-            return FALSE;
-          }
           FXSYS_memset(m_pSrcBuf, 0, input_size);
           m_SrcSize = input_size;
         }
         bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size);
         if (!bResult) {
           m_status = FXCODEC_STATUS_ERR_READ;
           return FALSE;
         }
         m_offSet += input_size;
         bResult =
             pPngModule->Input(m_pPngContext, m_pSrcBuf, input_size, pAttribute);
       }
       ASSERT(!bResult);
-      if (m_pPngContext != NULL) {
+      if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       if (m_SrcPassNumber == 0) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
       ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
@@ skipping 33 matching lines @@
         }
         readResult = pGifModule->ReadHeader(
             m_pGifContext, &m_SrcWidth, &m_SrcHeight, &m_GifPltNumber,
             (void**)&m_pGifPalette, &m_GifBgIndex, nullptr);
       }
       if (readResult == 1) {
         m_SrcBPC = 8;
         m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
         return TRUE;
       }
-      if (m_pGifContext != NULL) {
+      if (m_pGifContext) {
         pGifModule->Finish(m_pGifContext);
         m_pGifContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_TIF: {
       ICodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
       if (pTiffModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
@@ skipping 459 matching lines @@
           pDeviceBitmap->GetScanline(pWeight->m_SrcEnd + des_top) +
           des_ScanOffet;
       for (int des_col = 0; des_col < m_sizeX; des_col++) {
         switch (pDeviceBitmap->GetFormat()) {
           case FXDIB_Invalid:
           case FXDIB_1bppMask:
           case FXDIB_1bppRgb:
             return;
           case FXDIB_8bppMask:
           case FXDIB_8bppRgb: {
-            if (pDeviceBitmap->GetPalette() != NULL) {
+            if (pDeviceBitmap->GetPalette()) {
               return;
             }
             int des_g = 0;
             des_g += pWeight->m_Weights[0] * (*scan_src1++);
             des_g += pWeight->m_Weights[1] * (*scan_src2++);
             *scan_des++ = (uint8_t)(des_g >> 16);
           } break;
           case FXDIB_Rgb:
           case FXDIB_Rgb32: {
             FX_DWORD des_b = 0, des_g = 0, des_r = 0;
@@ skipping 104 matching lines @@
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_FRAME_TOBECONTINUE;
           }
           readResult = pGifModule->LoadFrameInfo(m_pGifContext, &m_FrameNumber);
         }
         if (readResult == 1) {
           frames = m_FrameNumber;
           return m_status = FXCODEC_STATUS_DECODE_READY;
         }
-        if (m_pGifContext != NULL) {
+        if (m_pGifContext) {
           pGifModule->Finish(m_pGifContext);
           m_pGifContext = NULL;
         }
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     default:;
   }
   return FXCODEC_STATUS_ERROR;
 }
@@ skipping 64 matching lines @@
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
         if (!JpegReadMoreData(pJpegModule, error_status)) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = error_status;
         }
         bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
       }
       int scanline_size = (m_SrcWidth + down_scale - 1) / down_scale;
       scanline_size = (scanline_size * m_SrcComponents + 3) / 4 * 4;
-      if (m_pDecodeBuf != NULL) {
-        FX_Free(m_pDecodeBuf);
-        m_pDecodeBuf = NULL;
-      }
+      FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
-      if (m_pDecodeBuf == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
-        return m_status = FXCODEC_STATUS_ERR_MEMORY;
-      }
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                         m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       switch (m_SrcComponents) {
         case 1:
           m_SrcFormat = FXCodec_8bppGray;
           break;
         case 3:
           m_SrcFormat = FXCodec_Rgb;
           break;
         case 4:
           m_SrcFormat = FXCodec_Cmyk;
           break;
       }
       GetTransMethod(pDIBitmap->GetFormat(), m_SrcFormat);
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_PNG: {
       ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       if (pPngModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
-      if (m_pPngContext != NULL) {
+      if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       m_pPngContext = pPngModule->Start((void*)this);
       if (m_pPngContext == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_offSet = 0;
@@ skipping 13 matching lines @@
           m_SrcFormat = FXCodec_Argb;
           break;
         default: {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_PARAMS;
         }
       }
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4;
-      if (m_pDecodeBuf != NULL) {
-        FX_Free(m_pDecodeBuf);
-        m_pDecodeBuf = NULL;
-      }
+      FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
-      if (m_pDecodeBuf == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
-        return m_status = FXCODEC_STATUS_ERR_MEMORY;
-      }
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorzOO.Calc(m_sizeX, m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_GIF: {
       ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       if (pGifModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_SrcFormat = FXCodec_8bppRgb;
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth + 3) / 4 * 4;
-      if (m_pDecodeBuf != NULL) {
-        FX_Free(m_pDecodeBuf);
-        m_pDecodeBuf = NULL;
-      }
+      FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
-      if (m_pDecodeBuf == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
-        return m_status = FXCODEC_STATUS_ERR_MEMORY;
-      }
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                         m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       m_FrameCur = frames;
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_BMP: {
       ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (pBmpModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       switch (m_SrcComponents) {
         case 1:
           m_SrcFormat = FXCodec_8bppRgb;
           break;
         case 3:
           m_SrcFormat = FXCodec_Rgb;
           break;
         case 4:
           m_SrcFormat = FXCodec_Rgb32;
           break;
       }
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       m_ScanlineSize = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4;
-      if (m_pDecodeBuf != NULL) {
-        FX_Free(m_pDecodeBuf);
-        m_pDecodeBuf = NULL;
-      }
+      FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, m_ScanlineSize);
-      if (m_pDecodeBuf == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
-        return m_status = FXCODEC_STATUS_ERR_MEMORY;
-      }
       FXSYS_memset(m_pDecodeBuf, 0, m_ScanlineSize);
       m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                         m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_TIF:
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     default:
       break;
@@ skipping 35 matching lines @@
         }
       }
     } break;
     case FXCODEC_IMAGE_PNG: {
       ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       while (TRUE) {
         FX_DWORD remain_size = (FX_DWORD)m_pFile->GetSize() - m_offSet;
         FX_DWORD input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
-          if (m_pPngContext != NULL) {
+          if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = NULL;
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
-        if (m_pSrcBuf != NULL && input_size > m_SrcSize) {
+        if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
-          if (m_pSrcBuf == NULL) {
-            m_pDeviceBitmap = NULL;
-            m_pFile = NULL;
-            return m_status = FXCODEC_STATUS_ERR_MEMORY;
-          }
           FXSYS_memset(m_pSrcBuf, 0, input_size);
           m_SrcSize = input_size;
         }
         FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size);
         if (!bResult) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_READ;
         }
         m_offSet += input_size;
@@ skipping 199 matching lines @@
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 ICodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }