Get rid of NULLs in core/

core/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/fxcodec/codec/include/ccodec_progressivedecoder.h"
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxge/include/fx_dib.h"
@@ skipping 21 matching lines @@
   if (dest_len < 0) {
     base = (FX_FLOAT)(src_len);
   } else {
     base = 0.0f;
   }
   m_ItemSize =
       (int)(sizeof(int) * 2 +
             sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + 1));
   m_DestMin = dest_min;
   m_pWeightTables = FX_Alloc(uint8_t, (dest_max - dest_min) * m_ItemSize + 4);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   if (FXSYS_fabs((FX_FLOAT)scale) < 1.0f) {
     for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel++) {
       PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
       double src_pos = dest_pixel * scale + scale / 2 + base;
       if (bInterpol) {
         pixel_weights.m_SrcStart =
             (int)FXSYS_floor((FX_FLOAT)src_pos - 1.0f / 2);
         pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos + 1.0f / 2);
         if (pixel_weights.m_SrcStart < src_min) {
           pixel_weights.m_SrcStart = src_min;
@@ skipping 69 matching lines @@
 void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
                                                          int src_len,
                                                          FX_BOOL bInterpol) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   FXSYS_memset(m_pWeightTables, 0, size);
   if (scale > 1) {
     int pre_des_col = 0;
     for (int src_col = 0; src_col < src_len; src_col++) {
       double des_col_f = src_col * scale;
       int des_col = FXSYS_round((FX_FLOAT)des_col_f);
       PixelWeight* pWeight =
           (PixelWeight*)(m_pWeightTables + des_col * m_ItemSize);
       pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
       pWeight->m_Weights[0] = 65536;
@@ skipping 38 matching lines @@
 }
 void CCodec_ProgressiveDecoder::CFXCODEC_VertTable::Calc(int dest_len,
                                                          int src_len) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   FXSYS_memset(m_pWeightTables, 0, size);
   if (scale > 1) {
     double step = 0.0;
     int src_row = 0;
     while (step < (double)dest_len) {
       int start_step = (int)step;
       step = scale * (++src_row);
       int end_step = (int)step;
       if (end_step >= dest_len) {
         end_step = dest_len;
@@ skipping 32 matching lines @@
           (PixelWeight*)(m_pWeightTables + des_row * m_ItemSize);
       pWeight->m_SrcStart = des_row;
       pWeight->m_SrcEnd = des_row;
       pWeight->m_Weights[0] = 65536;
       pWeight->m_Weights[1] = 0;
     }
   }
 }
 CCodec_ProgressiveDecoder::CCodec_ProgressiveDecoder(
     CCodec_ModuleMgr* pCodecMgr) {
-  m_pFile = NULL;
-  m_pJpegContext = NULL;
-  m_pPngContext = NULL;
-  m_pGifContext = NULL;
-  m_pBmpContext = NULL;
-  m_pTiffContext = NULL;
-  m_pCodecMgr = NULL;
-  m_pSrcBuf = NULL;
-  m_pDecodeBuf = NULL;
-  m_pDeviceBitmap = NULL;
-  m_pSrcPalette = NULL;
+  m_pFile = nullptr;
+  m_pJpegContext = nullptr;
+  m_pPngContext = nullptr;
+  m_pGifContext = nullptr;
+  m_pBmpContext = nullptr;
+  m_pTiffContext = nullptr;
+  m_pCodecMgr = nullptr;
+  m_pSrcBuf = nullptr;
+  m_pDecodeBuf = nullptr;
+  m_pDeviceBitmap = nullptr;
+  m_pSrcPalette = nullptr;
   m_pCodecMgr = pCodecMgr;
   m_offSet = 0;
   m_SrcSize = 0;
   m_ScanlineSize = 0;
   m_SrcWidth = m_SrcHeight = 0;
   m_SrcComponents = 0;
   m_SrcBPC = 0;
   m_SrcPassNumber = 0;
   m_clipBox = FX_RECT(0, 0, 0, 0);
   m_imagType = FXCODEC_IMAGE_UNKNOWN;
   m_status = FXCODEC_STATUS_DECODE_FINISH;
   m_TransMethod = -1;
   m_SrcRow = 0;
   m_SrcFormat = FXCodec_Invalid;
   m_bInterpol = TRUE;
   m_FrameNumber = 0;
   m_FrameCur = 0;
   m_SrcPaletteNumber = 0;
   m_GifPltNumber = 0;
   m_GifBgIndex = 0;
-  m_pGifPalette = NULL;
+  m_pGifPalette = nullptr;
   m_GifTransIndex = -1;
   m_GifFrameRect = FX_RECT(0, 0, 0, 0);
   m_BmpIsTopBottom = FALSE;
 }
 CCodec_ProgressiveDecoder::~CCodec_ProgressiveDecoder() {
-  m_pFile = NULL;
+  m_pFile = nullptr;
   if (m_pJpegContext) {
     m_pCodecMgr->GetJpegModule()->Finish(m_pJpegContext);
   }
   if (m_pPngContext) {
     m_pCodecMgr->GetPngModule()->Finish(m_pPngContext);
   }
   if (m_pGifContext) {
     m_pCodecMgr->GetGifModule()->Finish(m_pGifContext);
   }
   if (m_pBmpContext) {
     m_pCodecMgr->GetBmpModule()->Finish(m_pBmpContext);
   }
   if (m_pTiffContext) {
     m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
   }
   FX_Free(m_pSrcBuf);
   FX_Free(m_pDecodeBuf);
   FX_Free(m_pSrcPalette);
 }
 FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
     CCodec_JpegModule* pJpegModule,
     FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  uint32_t dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, NULL);
+  uint32_t dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
@@ skipping 16 matching lines @@
   return TRUE;
 }
 FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
                                                      int width,
                                                      int height,
                                                      int bpc,
                                                      int pass,
                                                      int* color_type,
                                                      double* gamma) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
-  if (pCodec->m_pDeviceBitmap == NULL) {
+  if (!pCodec->m_pDeviceBitmap) {
     pCodec->m_SrcWidth = width;
     pCodec->m_SrcHeight = height;
     pCodec->m_SrcBPC = bpc;
     pCodec->m_SrcPassNumber = pass;
     pCodec->m_SrcComponents =
         *color_type == 0 ? 1 : *color_type == 2
                                    ? 3
                                    : *color_type == 3
                                          ? 4
                                          : *color_type == 4
@@ skipping 200 matching lines @@
     }
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
                                                    FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  uint32_t dwAvail = pGifModule->GetAvailInput(m_pGifContext, NULL);
+  uint32_t dwAvail = pGifModule->GetAvailInput(m_pGifContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
@@ skipping 40 matching lines @@
     int32_t trans_index,
     int32_t disposal_method,
     FX_BOOL interlace) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
   pCodec->m_offSet = rcd_pos;
   FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
   if (!pCodec->GifReadMoreData(pCodec->m_pCodecMgr->GetGifModule(),
                                error_status)) {
     return FALSE;
   }
-  uint8_t* pPalette = NULL;
+  uint8_t* pPalette = nullptr;
   if (pal_num != 0 && pal_ptr) {
     pPalette = (uint8_t*)pal_ptr;
   } else {
     pal_num = pCodec->m_GifPltNumber;
     pPalette = pCodec->m_pGifPalette;
   }
-  if (pCodec->m_pSrcPalette == NULL) {
+  if (!pCodec->m_pSrcPalette) {
     pCodec->m_pSrcPalette = FX_Alloc(FX_ARGB, pal_num);
   } else if (pal_num > pCodec->m_SrcPaletteNumber) {
     pCodec->m_pSrcPalette = FX_Realloc(FX_ARGB, pCodec->m_pSrcPalette, pal_num);
   }
-  if (pCodec->m_pSrcPalette == NULL) {
+  if (!pCodec->m_pSrcPalette)
     return FALSE;
-  }
+
   pCodec->m_SrcPaletteNumber = pal_num;
   for (int i = 0; i < pal_num; i++) {
     uint32_t j = i * 3;
     pCodec->m_pSrcPalette[i] =
         ArgbEncode(0xff, pPalette[j], pPalette[j + 1], pPalette[j + 2]);
   }
   pCodec->m_GifTransIndex = trans_index;
   pCodec->m_GifFrameRect = img_rc;
   pCodec->m_SrcPassNumber = interlace ? 4 : 1;
   int32_t pal_index = pCodec->m_GifBgIndex;
@@ skipping 186 matching lines @@
     GifDoubleLineResampleVert(pDeviceBitmap, scale_y, des_row + (int)scale_y);
   }
 }
 FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
                                                    FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
-  uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, NULL);
+  uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, nullptr);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
     }
     m_SrcSize = (dwSize + dwAvail + FXCODEC_BLOCK_SIZE - 1) /
                 FXCODEC_BLOCK_SIZE * FXCODEC_BLOCK_SIZE;
     m_pSrcBuf = FX_Realloc(uint8_t, m_pSrcBuf, m_SrcSize);
     if (!m_pSrcBuf) {
       err_status = FXCODEC_STATUS_ERR_MEMORY;
       return FALSE;
@@ skipping 147 matching lines @@
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
   FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
-      if (pBmpModule == NULL) {
+      if (!pBmpModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pBmpModule->InputImagePositionBufCallback =
           BmpInputImagePositionBufCallback;
       pBmpModule->ReadScanlineCallback = BmpReadScanlineCallback;
       m_pBmpContext = pBmpModule->Start((void*)this);
-      if (m_pBmpContext == NULL) {
+      if (!m_pBmpContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pBmpModule->Input(m_pBmpContext, m_pSrcBuf, size);
-      uint32_t* pPalette = NULL;
+      uint32_t* pPalette = nullptr;
       int32_t readResult = pBmpModule->ReadHeader(
           m_pBmpContext, &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
           &m_SrcComponents, &m_SrcPaletteNumber, &pPalette, pAttribute);
       while (readResult == 2) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
         if (!BmpReadMoreData(pBmpModule, error_status)) {
           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);
         FX_Free(m_pSrcPalette);
         if (m_SrcPaletteNumber) {
           m_pSrcPalette = FX_Alloc(FX_ARGB, m_SrcPaletteNumber);
           FXSYS_memcpy(m_pSrcPalette, pPalette,
                        m_SrcPaletteNumber * sizeof(uint32_t));
         } else {
           m_pSrcPalette = nullptr;
         }
         return TRUE;
       }
       if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
-        m_pBmpContext = NULL;
+        m_pBmpContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
-      if (pJpegModule == NULL) {
+      if (!pJpegModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       m_pJpegContext = pJpegModule->Start();
-      if (m_pJpegContext == NULL) {
+      if (!m_pJpegContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pJpegModule->Input(m_pJpegContext, m_pSrcBuf, size);
@@ skipping 10 matching lines @@
             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) {
         pJpegModule->Finish(m_pJpegContext);
-        m_pJpegContext = NULL;
+        m_pJpegContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_PNG: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
-      if (pPngModule == NULL) {
+      if (!pPngModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pPngModule->ReadHeaderCallback =
           CCodec_ProgressiveDecoder::PngReadHeaderFunc;
       pPngModule->AskScanlineBufCallback =
           CCodec_ProgressiveDecoder::PngAskScanlineBufFunc;
       pPngModule->FillScanlineBufCompletedCallback =
           CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc;
       m_pPngContext = pPngModule->Start((void*)this);
-      if (m_pPngContext == NULL) {
+      if (!m_pPngContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       bResult = pPngModule->Input(m_pPngContext, m_pSrcBuf, size, pAttribute);
       while (bResult) {
         uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
         uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
-          m_pPngContext = NULL;
+          m_pPngContext = nullptr;
           m_status = FXCODEC_STATUS_ERR_FORMAT;
           return FALSE;
         }
         if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
           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) {
         pPngModule->Finish(m_pPngContext);
-        m_pPngContext = NULL;
+        m_pPngContext = nullptr;
       }
       if (m_SrcPassNumber == 0) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
-      if (pGifModule == NULL) {
+      if (!pGifModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pGifModule->RecordCurrentPositionCallback =
           CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback;
       pGifModule->AskLocalPaletteBufCallback =
           CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback;
       pGifModule->InputRecordPositionBufCallback =
           CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback;
       pGifModule->ReadScanlineCallback =
           CCodec_ProgressiveDecoder::GifReadScanlineCallback;
       m_pGifContext = pGifModule->Start((void*)this);
-      if (m_pGifContext == NULL) {
+      if (!m_pGifContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pGifModule->Input(m_pGifContext, m_pSrcBuf, size);
@@ skipping 11 matching lines @@
             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) {
         pGifModule->Finish(m_pGifContext);
-        m_pGifContext = NULL;
+        m_pGifContext = nullptr;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_TIF: {
       CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
-      if (pTiffModule == NULL) {
+      if (!pTiffModule) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       m_pTiffContext = pTiffModule->CreateDecoder(m_pFile);
-      if (m_pTiffContext == NULL) {
+      if (!m_pTiffContext) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       int32_t frames = 0;
       pTiffModule->GetFrames(m_pTiffContext, frames);
       uint32_t bpc;
       FX_BOOL ret = pTiffModule->LoadFrameInfo(
           m_pTiffContext, 0, (uint32_t&)m_SrcWidth, (uint32_t&)m_SrcHeight,
           (uint32_t&)m_SrcComponents, bpc, pAttribute);
       m_SrcComponents = 4;
       m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
       if (!ret) {
         pTiffModule->DestroyDecoder(m_pTiffContext);
-        (m_pTiffContext = NULL);
+        (m_pTiffContext = nullptr);
         (m_status = FXCODEC_STATUS_ERR_FORMAT);
         return FALSE;
       }
     } break;
     default:
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
   }
   return TRUE;
 }
 FXCODEC_STATUS CCodec_ProgressiveDecoder::LoadImageInfo(
     IFX_FileRead* pFile,
     FXCODEC_IMAGE_TYPE imageType,
     CFX_DIBAttribute* pAttribute) {
   switch (m_status) {
     case FXCODEC_STATUS_FRAME_READY:
     case FXCODEC_STATUS_FRAME_TOBECONTINUE:
     case FXCODEC_STATUS_DECODE_READY:
     case FXCODEC_STATUS_DECODE_TOBECONTINUE:
       return FXCODEC_STATUS_ERROR;
     default:
       break;
   }
-  if (pFile == NULL) {
+  if (!pFile) {
     m_status = FXCODEC_STATUS_ERR_PARAMS;
-    m_pFile = NULL;
+    m_pFile = nullptr;
     return m_status;
   }
   m_pFile = pFile;
   m_offSet = 0;
   m_SrcWidth = m_SrcHeight = 0;
   m_SrcComponents = m_SrcBPC = 0;
   m_clipBox = FX_RECT(0, 0, 0, 0);
   m_startX = m_startY = 0;
   m_sizeX = m_sizeY = 0;
   m_SrcPassNumber = 0;
   if (imageType != FXCODEC_IMAGE_UNKNOWN &&
       DetectImageType(imageType, pAttribute)) {
     m_imagType = imageType;
     m_status = FXCODEC_STATUS_FRAME_READY;
     return m_status;
   }
   for (int type = FXCODEC_IMAGE_BMP; type < FXCODEC_IMAGE_MAX; type++) {
     if (DetectImageType((FXCODEC_IMAGE_TYPE)type, pAttribute)) {
       m_imagType = (FXCODEC_IMAGE_TYPE)type;
       m_status = FXCODEC_STATUS_FRAME_READY;
       return m_status;
     }
   }
   m_status = FXCODEC_STATUS_ERR_FORMAT;
-  m_pFile = NULL;
+  m_pFile = nullptr;
   return m_status;
 }
 void CCodec_ProgressiveDecoder::SetClipBox(FX_RECT* clip) {
   if (m_status != FXCODEC_STATUS_FRAME_READY) {
     return;
   }
   if (clip->IsEmpty()) {
     m_clipBox = FX_RECT(0, 0, 0, 0);
     return;
   }
@@ skipping 508 matching lines @@
             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) {
           pGifModule->Finish(m_pGifContext);
-          m_pGifContext = NULL;
+          m_pGifContext = nullptr;
         }
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
                                                       int start_x,
                                                       int start_y,
                                                       int size_x,
                                                       int size_y,
                                                       int32_t frames,
                                                       FX_BOOL bInterpol) {
-  if (m_status != FXCODEC_STATUS_DECODE_READY) {
+  if (m_status != FXCODEC_STATUS_DECODE_READY)
     return FXCODEC_STATUS_ERROR;
-  }
-  if (pDIBitmap == NULL || pDIBitmap->GetBPP() < 8 || frames < 0 ||
+
+  if (!pDIBitmap || pDIBitmap->GetBPP() < 8 || frames < 0 ||
       frames >= m_FrameNumber) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   m_pDeviceBitmap = pDIBitmap;
   if (m_clipBox.IsEmpty()) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   if (size_x <= 0 || size_x > 65535 || size_y <= 0 || size_y > 65535) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
@@ skipping 35 matching lines @@
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       int down_scale = 1;
       GetDownScale(down_scale);
       FX_BOOL bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
       while (!bStart) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
         if (!JpegReadMoreData(pJpegModule, error_status)) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           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;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       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: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
-      if (pPngModule == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+      if (!pPngModule) {
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
-        m_pPngContext = NULL;
+        m_pPngContext = nullptr;
       }
       m_pPngContext = pPngModule->Start((void*)this);
-      if (m_pPngContext == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+      if (!m_pPngContext) {
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_offSet = 0;
       switch (m_pDeviceBitmap->GetFormat()) {
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb:
           m_SrcComponents = 1;
           m_SrcFormat = FXCodec_8bppGray;
           break;
         case FXDIB_Rgb:
           m_SrcComponents = 3;
           m_SrcFormat = FXCodec_Rgb;
           break;
         case FXDIB_Rgb32:
         case FXDIB_Argb:
           m_SrcComponents = 4;
           m_SrcFormat = FXCodec_Argb;
           break;
         default: {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_PARAMS;
         }
       }
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       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: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
-      if (pGifModule == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+      if (!pGifModule) {
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         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;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       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: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
-      if (pBmpModule == NULL) {
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+      if (!pBmpModule) {
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         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:
@@ skipping 23 matching lines @@
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       while (TRUE) {
         FX_BOOL readRes =
             pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         while (!readRes) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!JpegReadMoreData(pJpegModule, error_status)) {
-            m_pDeviceBitmap = NULL;
-            m_pFile = NULL;
+            m_pDeviceBitmap = nullptr;
+            m_pFile = nullptr;
             return m_status = error_status;
           }
           readRes = pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         }
         if (m_SrcFormat == FXCodec_Rgb) {
           int src_Bpp = (m_SrcFormat & 0xff) >> 3;
           _RGB2BGR(m_pDecodeBuf + m_clipBox.left * src_Bpp, m_clipBox.Width());
         }
         if (m_SrcRow >= m_clipBox.bottom) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
         Resample(m_pDeviceBitmap, m_SrcRow, m_pDecodeBuf, m_SrcFormat);
         m_SrcRow++;
         if (pPause && pPause->NeedToPauseNow()) {
           return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         }
       }
     } break;
     case FXCODEC_IMAGE_PNG: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       while (TRUE) {
         uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
         uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
-          m_pPngContext = NULL;
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pPngContext = nullptr;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
         if (m_pSrcBuf && input_size > m_SrcSize) {
           FX_Free(m_pSrcBuf);
           m_pSrcBuf = FX_Alloc(uint8_t, input_size);
           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;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_READ;
         }
         m_offSet += input_size;
         bResult =
             pPngModule->Input(m_pPngContext, m_pSrcBuf, input_size, nullptr);
         if (!bResult) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERROR;
         }
         if (pPause && pPause->NeedToPauseNow()) {
           return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         }
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       while (TRUE) {
         int32_t readRes =
             pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
         while (readRes == 2) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!GifReadMoreData(pGifModule, error_status)) {
-            m_pDeviceBitmap = NULL;
-            m_pFile = NULL;
+            m_pDeviceBitmap = nullptr;
+            m_pFile = nullptr;
             return m_status = error_status;
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
           }
           readRes = pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
         }
         if (readRes == 1) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     case FXCODEC_IMAGE_BMP: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       while (TRUE) {
         int32_t readRes = pBmpModule->LoadImage(m_pBmpContext);
         while (readRes == 2) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!BmpReadMoreData(pBmpModule, error_status)) {
-            m_pDeviceBitmap = NULL;
-            m_pFile = NULL;
+            m_pDeviceBitmap = nullptr;
+            m_pFile = nullptr;
             return m_status = error_status;
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
           }
           readRes = pBmpModule->LoadImage(m_pBmpContext);
         }
         if (readRes == 1) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     case FXCODEC_IMAGE_TIF: {
       CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
       FX_BOOL ret = FALSE;
       if (m_pDeviceBitmap->GetBPP() == 32 &&
           m_pDeviceBitmap->GetWidth() == m_SrcWidth && m_SrcWidth == m_sizeX &&
           m_pDeviceBitmap->GetHeight() == m_SrcHeight &&
           m_SrcHeight == m_sizeY && m_startX == 0 && m_startY == 0 &&
           m_clipBox.left == 0 && m_clipBox.top == 0 &&
           m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight) {
         ret = pTiffModule->Decode(m_pTiffContext, m_pDeviceBitmap);
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         if (!ret) {
           return m_status = FXCODEC_STATUS_ERROR;
         }
         return m_status = FXCODEC_STATUS_DECODE_FINISH;
       } else {
         CFX_DIBitmap* pDIBitmap = new CFX_DIBitmap;
         pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Argb);
-        if (pDIBitmap->GetBuffer() == NULL) {
+        if (!pDIBitmap->GetBuffer()) {
           delete pDIBitmap;
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         ret = pTiffModule->Decode(m_pTiffContext, pDIBitmap);
         if (!ret) {
           delete pDIBitmap;
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERROR;
         }
         CFX_DIBitmap* pClipBitmap =
             (m_clipBox.left == 0 && m_clipBox.top == 0 &&
              m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight)
                 ? pDIBitmap
                 : pDIBitmap->Clone(&m_clipBox);
         if (pDIBitmap != pClipBitmap) {
           delete pDIBitmap;
         }
-        if (pClipBitmap == NULL) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+        if (!pClipBitmap) {
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
-        CFX_DIBitmap* pFormatBitmap = NULL;
+        CFX_DIBitmap* pFormatBitmap = nullptr;
         switch (m_pDeviceBitmap->GetFormat()) {
           case FXDIB_8bppRgb:
             pFormatBitmap = new CFX_DIBitmap;
             pFormatBitmap->Create(pClipBitmap->GetWidth(),
                                   pClipBitmap->GetHeight(), FXDIB_8bppRgb);
             break;
           case FXDIB_8bppMask:
             pFormatBitmap = new CFX_DIBitmap;
             pFormatBitmap->Create(pClipBitmap->GetWidth(),
                                   pClipBitmap->GetHeight(), FXDIB_8bppMask);
@@ skipping 49 matching lines @@
                 src_line += 4;
               }
             }
           } break;
           default:
             break;
         }
         if (pClipBitmap != pFormatBitmap) {
           delete pClipBitmap;
         }
-        if (pFormatBitmap == NULL) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+        if (!pFormatBitmap) {
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         CFX_DIBitmap* pStrechBitmap = pFormatBitmap->StretchTo(
             m_sizeX, m_sizeY, m_bInterpol ? FXDIB_INTERPOL : FXDIB_DOWNSAMPLE);
         delete pFormatBitmap;
-        pFormatBitmap = NULL;
-        if (pStrechBitmap == NULL) {
-          m_pDeviceBitmap = NULL;
-          m_pFile = NULL;
+        pFormatBitmap = nullptr;
+        if (!pStrechBitmap) {
+          m_pDeviceBitmap = nullptr;
+          m_pFile = nullptr;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         m_pDeviceBitmap->TransferBitmap(m_startX, m_startY, m_sizeX, m_sizeY,
                                         pStrechBitmap, 0, 0);
         delete pStrechBitmap;
-        pStrechBitmap = NULL;
-        m_pDeviceBitmap = NULL;
-        m_pFile = NULL;
+        pStrechBitmap = nullptr;
+        m_pDeviceBitmap = nullptr;
+        m_pFile = nullptr;
         return m_status = FXCODEC_STATUS_DECODE_FINISH;
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 CCodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }