Cleanup JBig2_GeneralDecoder.cpp.

core/src/fxcodec/jbig2/JBig2_GeneralDecoder.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 "JBig2_GeneralDecoder.h"
+
+#include "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "JBig2_ArithDecoder.h"
 #include "JBig2_ArithIntDecoder.h"
 #include "JBig2_HuffmanDecoder.h"
 #include "JBig2_HuffmanTable.h"
 #include "JBig2_PatternDict.h"
 
 extern const JBig2ArithQe QeTable[] = {
     {0x5601, 1, 1, 1},   {0x3401, 2, 6, 0},   {0x1801, 3, 9, 0},
     {0x0AC1, 4, 12, 0},  {0x0521, 5, 29, 0},  {0x0221, 38, 33, 0},
     {0x5601, 7, 6, 1},   {0x5401, 8, 14, 0},  {0x4801, 9, 14, 0},
@@ skipping 49 matching lines @@
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
-  if (GBREG->m_pData == NULL) {
-    delete GBREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
+  if (!GBREG->m_pData)
+    return nullptr;
+
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   FX_DWORD height = GBH & 0x7fffffff;
   for (FX_DWORD h = 0; h < height; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
@@ skipping 53 matching lines @@
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
           cVal |= bVal << (7 - k);
           CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
                      (((line2 >> (7 - k))) & 0x0010));
         }
         pLine[nLineBytes] = cVal;
       }
     }
     pLine += nStride;
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 2);
@@ skipping 17 matching lines @@
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
         line3 = ((line3 << 1) | bVal) & 0x0f;
       }
     }
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
-  if (GBREG->m_pData == NULL) {
-    delete GBREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
+  if (!GBREG->m_pData)
+    return nullptr;
+
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
       LTP = LTP ^ SLTP;
     }
@@ skipping 52 matching lines @@
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
           cVal |= bVal << (7 - k);
           CONTEXT =
               ((CONTEXT & 0x0efb) << 1) | bVal | ((line2 >> (8 - k)) & 0x0008);
         }
         pLine[nLineBytes] = cVal;
       }
     }
     pLine += nStride;
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(2, h - 2);
@@ skipping 15 matching lines @@
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
         line3 = ((line3 << 1) | bVal) & 0x07;
       }
     }
   }
-  return GBREG;
+  return GBREG.release();
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
-  if (GBREG->m_pData == NULL) {
-    delete GBREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
+  if (!GBREG->m_pData)
+    return nullptr;
+
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
       LTP = LTP ^ SLTP;
     }
@@ skipping 52 matching lines @@
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
           cVal |= bVal << (7 - k);
           CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
                     (((line2 >> (10 - k))) & 0x0004);
         }
         pLine[nLineBytes] = cVal;
       }
     }
     pLine += nStride;
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 2);
@@ skipping 13 matching lines @@
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
         line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x0f;
         line3 = ((line3 << 1) | bVal) & 0x03;
       }
     }
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1;
   uint8_t *pLine, *pLine1, cVal;
   int32_t nStride, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
-  if (GBREG->m_pData == NULL) {
-    delete GBREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
+  if (!GBREG->m_pData)
+    return nullptr;
+
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
@@ skipping 38 matching lines @@
         for (k = 0; k < nBitsLeft; k++) {
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
           cVal |= bVal << (7 - k);
           CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
         }
         pLine[nLineBytes] = cVal;
       }
     }
     pLine += nStride;
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   LTP = 0;
-  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
+  nonstd::unique_ptr<CJBig2_Image> GBREG(new CJBig2_Image(GBW, GBH));
   GBREG->fill(0);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 1) {
       GBREG->copyLine(h, h - 1);
     } else {
       line1 = GBREG->getPixel(1, h - 1);
       line1 |= GBREG->getPixel(0, h - 1) << 1;
       line2 = 0;
       for (FX_DWORD w = 0; w < GBW; w++) {
         if (USESKIP && SKIP->getPixel(w, h)) {
           bVal = 0;
         } else {
           CONTEXT = line2;
           CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
           CONTEXT |= line1 << 5;
           bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
         }
         if (bVal) {
           GBREG->setPixel(w, h, bVal);
         }
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f;
         line2 = ((line2 << 1) | bVal) & 0x0f;
       }
     }
   }
-  return GBREG;
+  return GBREG.release();
 }
+
 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder,
                                       JBig2ArithCtx* grContext) {
   if (GRW == 0 || GRH == 0) {
     return new CJBig2_Image(GRW, GRH);
   }
   if (GRTEMPLATE == 0) {
     if ((GRAT[0] == (int8_t)-1) && (GRAT[1] == (int8_t)-1) &&
         (GRAT[2] == (int8_t)-1) && (GRAT[3] == (int8_t)-1) &&
         (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {
       return decode_Template0_opt(pArithDecoder, grContext);
     } else {
       return decode_Template0_unopt(pArithDecoder, grContext);
     }
   } else {
     if ((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {
       return decode_Template1_opt(pArithDecoder, grContext);
     } else {
       return decode_Template1_unopt(pArithDecoder, grContext);
     }
   }
 }
+
 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3, line4, line5;
   LTP = 0;
-  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
+  nonstd::unique_ptr<CJBig2_Image> GRREG(new CJBig2_Image(GRW, GRH));
   GRREG->fill(0);
   for (FX_DWORD h = 0; h < GRH; h++) {
     if (TPGRON) {
       SLTP = pArithDecoder->DECODE(&grContext[0x0010]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 0) {
       line1 = GRREG->getPixel(1, h - 1);
       line1 |= GRREG->getPixel(0, h - 1) << 1;
       line2 = 0;
@@ skipping 84 matching lines @@
             ((line4 << 1) |
              GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
             0x07;
         line5 = ((line5 << 1) |
                  GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
                                        h - GRREFERENCEDY + 1)) &
                 0x07;
       }
     }
   }
-  return GRREG;
+  return GRREG.release();
 }
+
 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   if (!GRREFERENCE->m_pData)
     return nullptr;
 
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line1_r, line2_r, line3_r;
   uint8_t *pLine, *pLineR, cVal;
   intptr_t nStride, nStrideR, nOffset;
   int32_t k, nBits;
   int32_t GRWR, GRHR;
   int32_t GRW, GRH;
   GRW = (int32_t)CJBig2_GRRDProc::GRW;
   GRH = (int32_t)CJBig2_GRRDProc::GRH;
   LTP = 0;
-  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
-  if (GRREG->m_pData == NULL) {
-    delete GRREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GRREG(new CJBig2_Image(GRW, GRH));
+  if (!GRREG->m_pData)
+    return nullptr;
+
   pLine = GRREG->m_pData;
   pLineR = GRREFERENCE->m_pData;
   nStride = GRREG->m_nStride;
   nStrideR = GRREFERENCE->m_nStride;
   GRWR = (int32_t)GRREFERENCE->m_nWidth;
   GRHR = (int32_t)GRREFERENCE->m_nHeight;
   if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
     GRREFERENCEDY = 0;
   }
   nOffset = -GRREFERENCEDY * nStrideR;
@@ skipping 93 matching lines @@
                     ((line3_r >> (13 - k)) & 0x0001);
         }
         pLine[w >> 3] = cVal;
       }
     }
     pLine += nStride;
     if (h < GRHR + GRREFERENCEDY) {
       pLineR += nStrideR;
     }
   }
-  return GRREG;
+  return GRREG.release();
 }
+
 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3, line4, line5;
   LTP = 0;
-  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
+  nonstd::unique_ptr<CJBig2_Image> GRREG(new CJBig2_Image(GRW, GRH));
   GRREG->fill(0);
   for (FX_DWORD h = 0; h < GRH; h++) {
     if (TPGRON) {
       SLTP = pArithDecoder->DECODE(&grContext[0x0008]);
       LTP = LTP ^ SLTP;
     }
     if (LTP == 0) {
       line1 = GRREG->getPixel(1, h - 1);
       line1 |= GRREG->getPixel(0, h - 1) << 1;
       line1 |= GRREG->getPixel(-1, h - 1) << 2;
@@ skipping 70 matching lines @@
             ((line4 << 1) |
              GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
             0x07;
         line5 = ((line5 << 1) |
                  GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
                                        h - GRREFERENCEDY + 1)) &
                 0x03;
       }
     }
   }
-  return GRREG;
+  return GRREG.release();
 }
+
 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   if (!GRREFERENCE->m_pData)
     return nullptr;
 
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line1_r, line2_r, line3_r;
   uint8_t *pLine, *pLineR, cVal;
   intptr_t nStride, nStrideR, nOffset;
   int32_t k, nBits;
   int32_t GRWR, GRHR;
   int32_t GRW, GRH;
   GRW = (int32_t)CJBig2_GRRDProc::GRW;
   GRH = (int32_t)CJBig2_GRRDProc::GRH;
   LTP = 0;
-  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
-  if (GRREG->m_pData == NULL) {
-    delete GRREG;
-    return NULL;
-  }
+  nonstd::unique_ptr<CJBig2_Image> GRREG(new CJBig2_Image(GRW, GRH));
+  if (!GRREG->m_pData)
+    return nullptr;
+
   pLine = GRREG->m_pData;
   pLineR = GRREFERENCE->m_pData;
   nStride = GRREG->m_nStride;
   nStrideR = GRREFERENCE->m_nStride;
   GRWR = (int32_t)GRREFERENCE->m_nWidth;
   GRHR = (int32_t)GRREFERENCE->m_nHeight;
   if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
     GRREFERENCEDY = 0;
   }
   nOffset = -GRREFERENCEDY * nStrideR;
@@ skipping 87 matching lines @@
                     ((line3_r >> (13 - k)) & 0x0001);
         }
         pLine[w >> 3] = cVal;
       }
     }
     pLine += nStride;
     if (h < GRHR + GRREFERENCEDY) {
       pLineR += nStrideR;
     }
   }
-  return GRREG;
+  return GRREG.release();
 }
 
 CJBig2_Image* CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream* pStream,
                                              JBig2ArithCtx* grContext) {
   int32_t STRIPT, FIRSTS;
   FX_DWORD NINSTANCES;
   int32_t DT, DFS, CURS;
   uint8_t CURT;
   int32_t SI, TI;
   FX_DWORD IDI;
   CJBig2_Image* IBI;
   FX_DWORD WI, HI;
   int32_t IDS;
   FX_BOOL RI;
   int32_t RDWI, RDHI, RDXI, RDYI;
   CJBig2_Image* IBOI;
   FX_DWORD WOI, HOI;
   FX_BOOL bFirst;
   FX_DWORD nTmp;
   int32_t nVal, nBits;
-  CJBig2_GRRDProc* pGRRD;
-  CJBig2_ArithDecoder* pArithDecoder;
-  CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
-  CJBig2_Image* SBREG = new CJBig2_Image(SBW, SBH);
+  nonstd::unique_ptr<CJBig2_HuffmanDecoder> pHuffmanDecoder(
+      new CJBig2_HuffmanDecoder(pStream));
+  nonstd::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
-  if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {
-    goto failed;
-  }
+  if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0)
+    return nullptr;
+
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
   FIRSTS = 0;
   NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
-    if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {
-      goto failed;
-    }
+    if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0)
+      return nullptr;
+
     DT *= SBSTRIPS;
     STRIPT = STRIPT + DT;
     bFirst = TRUE;
     for (;;) {
       if (bFirst) {
-        if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {
-          goto failed;
-        }
+        if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0)
+          return nullptr;
+
         FIRSTS = FIRSTS + DFS;
         CURS = FIRSTS;
         bFirst = FALSE;
       } else {
         nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
         if (nVal == JBIG2_OOB) {
           break;
         } else if (nVal != 0) {
-          goto failed;
+          return nullptr;
         } else {
           CURS = CURS + IDS + SBDSOFFSET;
         }
       }
       if (SBSTRIPS == 1) {
         CURT = 0;
       } else {
         nTmp = 1;
         while ((FX_DWORD)(1 << nTmp) < SBSTRIPS) {
           nTmp++;
         }
-        if (pStream->readNBits(nTmp, &nVal) != 0) {
-          goto failed;
-        }
+        if (pStream->readNBits(nTmp, &nVal) != 0)
+          return nullptr;
+
         CURT = nVal;
       }
       TI = STRIPT + CURT;
       nVal = 0;
       nBits = 0;
       for (;;) {
-        if (pStream->read1Bit(&nTmp) != 0) {
-          goto failed;
-        }
+        if (pStream->read1Bit(&nTmp) != 0)
+          return nullptr;
+
         nVal = (nVal << 1) | nTmp;
         nBits++;
         for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
           if ((nBits == SBSYMCODES[IDI].codelen) &&
               (nVal == SBSYMCODES[IDI].code)) {
             break;
           }
         }
         if (IDI < SBNUMSYMS) {
           break;
         }
       }
       if (SBREFINE == 0) {
         RI = 0;
       } else {
         if (pStream->read1Bit(&RI) != 0) {
-          goto failed;
+          return nullptr;
         }
       }
       if (RI == 0) {
         IBI = SBSYMS[IDI];
       } else {
         if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
-          goto failed;
+          return nullptr;
         }
         pStream->alignByte();
         nTmp = pStream->getOffset();
         IBOI = SBSYMS[IDI];
-        if (!IBOI) {
-          goto failed;
-        }
+        if (!IBOI)
+          return nullptr;
+
         WOI = IBOI->m_nWidth;
         HOI = IBOI->m_nHeight;
-        if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
-          goto failed;
-        }
-        pGRRD = new CJBig2_GRRDProc();
+        if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0)
+          return nullptr;
+
+        nonstd::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
         pGRRD->TPGRON = 0;
         pGRRD->GRAT[0] = SBRAT[0];
         pGRRD->GRAT[1] = SBRAT[1];
         pGRRD->GRAT[2] = SBRAT[2];
         pGRRD->GRAT[3] = SBRAT[3];
-        pArithDecoder = new CJBig2_ArithDecoder(pStream);
-        IBI = pGRRD->decode(pArithDecoder, grContext);
-        if (IBI == NULL) {
-          delete pGRRD;
-          delete pArithDecoder;
-          goto failed;
-        }
-        delete pArithDecoder;
+        nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+            new CJBig2_ArithDecoder(pStream));
+        IBI = pGRRD->decode(pArithDecoder.get(), grContext);
+        if (!IBI)
+          return nullptr;
+
         pStream->alignByte();
         pStream->offset(2);
         if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
           delete IBI;
-          delete pGRRD;
-          goto failed;
+          return nullptr;
         }
-        delete pGRRD;
       }
       if (!IBI) {
         continue;
       }
       WI = IBI->m_nWidth;
       HI = IBI->m_nHeight;
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
                               (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS = CURS + WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
@@ skipping 38 matching lines @@
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
                               (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
         CURS = CURS + WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
                                      (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
         CURS = CURS + HI - 1;
       }
       NINSTANCES = NINSTANCES + 1;
     }
   }
-  delete pHuffmanDecoder;
-  return SBREG;
-failed:
-  delete pHuffmanDecoder;
-  delete SBREG;
-  return NULL;
+  return SBREG.release();
 }
+
 CJBig2_Image* CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
                                            JBig2ArithCtx* grContext,
                                            JBig2IntDecoderState* pIDS) {
   int32_t STRIPT, FIRSTS;
   FX_DWORD NINSTANCES;
   int32_t DT, DFS, CURS;
   int32_t CURT;
   int32_t SI, TI;
   FX_DWORD IDI;
   CJBig2_Image* IBI;
   FX_DWORD WI, HI;
   int32_t IDS;
   int RI;
   int32_t RDWI, RDHI, RDXI, RDYI;
   CJBig2_Image* IBOI;
   FX_DWORD WOI, HOI;
-  CJBig2_Image* SBREG;
   FX_BOOL bFirst;
   int32_t nRet, nVal;
   int32_t bRetained;
   CJBig2_ArithIntDecoder *IADT, *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH,
       *IARDX, *IARDY;
   CJBig2_ArithIaidDecoder* IAID;
-  CJBig2_GRRDProc* pGRRD;
   if (pIDS) {
     IADT = pIDS->IADT;
     IAFS = pIDS->IAFS;
     IADS = pIDS->IADS;
     IAIT = pIDS->IAIT;
     IARI = pIDS->IARI;
     IARDW = pIDS->IARDW;
     IARDH = pIDS->IARDH;
     IARDX = pIDS->IARDX;
     IARDY = pIDS->IARDY;
     IAID = pIDS->IAID;
     bRetained = TRUE;
   } else {
     IADT = new CJBig2_ArithIntDecoder();
     IAFS = new CJBig2_ArithIntDecoder();
     IADS = new CJBig2_ArithIntDecoder();
     IAIT = new CJBig2_ArithIntDecoder();
     IARI = new CJBig2_ArithIntDecoder();
     IARDW = new CJBig2_ArithIntDecoder();
     IARDH = new CJBig2_ArithIntDecoder();
     IARDX = new CJBig2_ArithIntDecoder();
     IARDY = new CJBig2_ArithIntDecoder();
     IAID = new CJBig2_ArithIaidDecoder(SBSYMCODELEN);
     bRetained = FALSE;
   }
-  SBREG = new CJBig2_Image(SBW, SBH);
+  nonstd::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
   if (IADT->decode(pArithDecoder, &STRIPT) == -1) {
     goto failed;
   }
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
   FIRSTS = 0;
   NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     if (IADT->decode(pArithDecoder, &DT) == -1) {
@@ skipping 57 matching lines @@
             (IARDX->decode(pArithDecoder, &RDXI) == -1) ||
             (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
           goto failed;
         }
         IBOI = SBSYMS[IDI];
         WOI = IBOI->m_nWidth;
         HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
           goto failed;
         }
-        pGRRD = new CJBig2_GRRDProc();
+        nonstd::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
         pGRRD->TPGRON = 0;
         pGRRD->GRAT[0] = SBRAT[0];
         pGRRD->GRAT[1] = SBRAT[1];
         pGRRD->GRAT[2] = SBRAT[2];
         pGRRD->GRAT[3] = SBRAT[3];
         IBI = pGRRD->decode(pArithDecoder, grContext);
-        if (IBI == NULL) {
-          delete pGRRD;
+        if (!IBI)
           goto failed;
-        }
-        delete pGRRD;
       }
       WI = IBI->m_nWidth;
       HI = IBI->m_nHeight;
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
                               (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS = CURS + WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
                                      (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS = CURS + HI - 1;
       }
@@ skipping 47 matching lines @@
     delete IAFS;
     delete IADS;
     delete IAIT;
     delete IARI;
     delete IARDW;
     delete IARDH;
     delete IARDX;
     delete IARDY;
     delete IAID;
   }
-  return SBREG;
+  return SBREG.release();
 failed:
   if (bRetained == FALSE) {
     delete IADT;
     delete IAFS;
     delete IADS;
     delete IAIT;
     delete IARI;
     delete IARDW;
     delete IARDH;
     delete IARDX;
     delete IARDY;
     delete IAID;
   }
-  delete SBREG;
-  return NULL;
+  return nullptr;
 }
+
 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Arith(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     JBig2ArithCtx* grContext) {
   CJBig2_Image** SDNEWSYMS;
   FX_DWORD HCHEIGHT, NSYMSDECODED;
   int32_t HCDH;
   FX_DWORD SYMWIDTH, TOTWIDTH;
   int32_t DW;
   CJBig2_Image* BS;
   FX_DWORD I, J, REFAGGNINST;
   FX_BOOL* EXFLAGS;
   FX_DWORD EXINDEX;
   FX_BOOL CUREXFLAG;
   FX_DWORD EXRUNLENGTH;
   int32_t nVal;
   FX_DWORD nTmp;
   FX_DWORD SBNUMSYMS;
   uint8_t SBSYMCODELEN;
   FX_DWORD IDI;
   int32_t RDXI, RDYI;
   CJBig2_Image** SBSYMS;
-  CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH,
-      *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE;
-  CJBig2_GRRDProc* pGRRD;
-  CJBig2_GRDProc* pGRD;
-  CJBig2_ArithIntDecoder *IADH, *IADW, *IAAI, *IARDX, *IARDY, *IAEX, *IADT,
-      *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH;
-  CJBig2_ArithIaidDecoder* IAID;
-  CJBig2_SymbolDict* pDict;
-  IADH = new CJBig2_ArithIntDecoder();
-  IADW = new CJBig2_ArithIntDecoder();
-  IAAI = new CJBig2_ArithIntDecoder();
-  IARDX = new CJBig2_ArithIntDecoder();
-  IARDY = new CJBig2_ArithIntDecoder();
-  IAEX = new CJBig2_ArithIntDecoder();
-  IADT = new CJBig2_ArithIntDecoder();
-  IAFS = new CJBig2_ArithIntDecoder();
-  IADS = new CJBig2_ArithIntDecoder();
-  IAIT = new CJBig2_ArithIntDecoder();
-  IARI = new CJBig2_ArithIntDecoder();
-  IARDW = new CJBig2_ArithIntDecoder();
-  IARDH = new CJBig2_ArithIntDecoder();
+  nonstd::unique_ptr<CJBig2_ArithIaidDecoder> IAID;
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IADH(new CJBig2_ArithIntDecoder());

[Tom Sepez, 2015/09/11 23:41:40]

nit: if you lost the () in the new expression, I bet these all fit on one line
which makes my eyes much happier.

[Lei Zhang, 2015/09/12 01:19:28]

Done.

+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IADW(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IAAI(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IARDX(
+      new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IARDY(
+      new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IAEX(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IADT(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IAFS(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IADS(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IAIT(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IARI(new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IARDW(
+      new CJBig2_ArithIntDecoder());
+  nonstd::unique_ptr<CJBig2_ArithIntDecoder> IARDH(
+      new CJBig2_ArithIntDecoder());
   nTmp = 0;
   while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
     nTmp++;
   }
-  IAID = new CJBig2_ArithIaidDecoder((uint8_t)nTmp);
+  IAID.reset(new CJBig2_ArithIaidDecoder((uint8_t)nTmp));
   SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS);
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
+  nonstd::unique_ptr<CJBig2_SymbolDict> pDict(new CJBig2_SymbolDict());
+
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
-    BS = NULL;
+    BS = nullptr;
     if (IADH->decode(pArithDecoder, &HCDH) == -1) {
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
     if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
       goto failed;
     }
     SYMWIDTH = 0;
     TOTWIDTH = 0;
     for (;;) {
       nVal = IADW->decode(pArithDecoder, &DW);
       if (nVal == JBIG2_OOB) {
         break;
       } else if (nVal != 0) {
         goto failed;
       } else {
         if (NSYMSDECODED >= SDNUMNEWSYMS) {
           goto failed;
         }
         SYMWIDTH = SYMWIDTH + DW;
         if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
           goto failed;
         } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
           TOTWIDTH = TOTWIDTH + SYMWIDTH;
-          SDNEWSYMS[NSYMSDECODED] = NULL;
+          SDNEWSYMS[NSYMSDECODED] = nullptr;
           NSYMSDECODED = NSYMSDECODED + 1;
           continue;
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 0) {
-        pGRD = new CJBig2_GRDProc();
+        nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
         pGRD->MMR = 0;
         pGRD->GBW = SYMWIDTH;
         pGRD->GBH = HCHEIGHT;
         pGRD->GBTEMPLATE = SDTEMPLATE;
         pGRD->TPGDON = 0;
         pGRD->USESKIP = 0;
         pGRD->GBAT[0] = SDAT[0];
         pGRD->GBAT[1] = SDAT[1];
         pGRD->GBAT[2] = SDAT[2];
         pGRD->GBAT[3] = SDAT[3];
         pGRD->GBAT[4] = SDAT[4];
         pGRD->GBAT[5] = SDAT[5];
         pGRD->GBAT[6] = SDAT[6];
         pGRD->GBAT[7] = SDAT[7];
         BS = pGRD->decode_Arith(pArithDecoder, gbContext);
-        if (BS == NULL) {
-          delete pGRD;
+        if (!BS) {
           goto failed;
         }
-        delete pGRD;
       } else {
         if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {
           goto failed;
         }
         if (REFAGGNINST > 1) {
-          CJBig2_TRDProc* pDecoder;
-          pDecoder = new CJBig2_TRDProc();
+          nonstd::unique_ptr<CJBig2_TRDProc> pDecoder(new CJBig2_TRDProc());
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
           pDecoder->SBNUMINSTANCES = REFAGGNINST;
           pDecoder->SBSTRIPS = 1;
           pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           SBNUMSYMS = pDecoder->SBNUMSYMS;
           nTmp = 0;
           while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           SBSYMCODELEN = (uint8_t)nTmp;
           pDecoder->SBSYMCODELEN = SBSYMCODELEN;
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           pDecoder->SBSYMS = SBSYMS;
           pDecoder->SBDEFPIXEL = 0;
           pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
           pDecoder->TRANSPOSED = 0;
           pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
           pDecoder->SBDSOFFSET = 0;
-          SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6,
-                                             FX_ArraySize(HuffmanTable_B6),
-                                             HuffmanTable_HTOOB_B6);
-          SBHUFFDS = new CJBig2_HuffmanTable(HuffmanTable_B8,
-                                             FX_ArraySize(HuffmanTable_B8),
-                                             HuffmanTable_HTOOB_B8);
-          SBHUFFDT = new CJBig2_HuffmanTable(HuffmanTable_B11,
-                                             FX_ArraySize(HuffmanTable_B11),
-                                             HuffmanTable_HTOOB_B11);
-          SBHUFFRDW = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDH = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDX = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDY = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRSIZE = new CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                FX_ArraySize(HuffmanTable_B1),
-                                                HuffmanTable_HTOOB_B1);
-          pDecoder->SBHUFFFS = SBHUFFFS;
-          pDecoder->SBHUFFDS = SBHUFFDS;
-          pDecoder->SBHUFFDT = SBHUFFDT;
-          pDecoder->SBHUFFRDW = SBHUFFRDW;
-          pDecoder->SBHUFFRDH = SBHUFFRDH;
-          pDecoder->SBHUFFRDX = SBHUFFRDX;
-          pDecoder->SBHUFFRDY = SBHUFFRDY;
-          pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFFS(
+              new CJBig2_HuffmanTable(HuffmanTable_B6,
+                                      FX_ArraySize(HuffmanTable_B6),
+                                      HuffmanTable_HTOOB_B6));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFDS(
+              new CJBig2_HuffmanTable(HuffmanTable_B8,
+                                      FX_ArraySize(HuffmanTable_B8),
+                                      HuffmanTable_HTOOB_B8));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFDT(
+              new CJBig2_HuffmanTable(HuffmanTable_B11,
+                                      FX_ArraySize(HuffmanTable_B11),
+                                      HuffmanTable_HTOOB_B11));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDW(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDH(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDX(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDY(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRSIZE(
+              new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                      FX_ArraySize(HuffmanTable_B1),
+                                      HuffmanTable_HTOOB_B1));
+          pDecoder->SBHUFFFS = SBHUFFFS.get();
+          pDecoder->SBHUFFDS = SBHUFFDS.get();
+          pDecoder->SBHUFFDT = SBHUFFDT.get();
+          pDecoder->SBHUFFRDW = SBHUFFRDW.get();
+          pDecoder->SBHUFFRDH = SBHUFFRDH.get();
+          pDecoder->SBHUFFRDX = SBHUFFRDX.get();
+          pDecoder->SBHUFFRDY = SBHUFFRDY.get();
+          pDecoder->SBHUFFRSIZE = SBHUFFRSIZE.get();
           pDecoder->SBRTEMPLATE = SDRTEMPLATE;
           pDecoder->SBRAT[0] = SDRAT[0];
           pDecoder->SBRAT[1] = SDRAT[1];
           pDecoder->SBRAT[2] = SDRAT[2];
           pDecoder->SBRAT[3] = SDRAT[3];
           JBig2IntDecoderState ids;
-          ids.IADT = IADT;
-          ids.IAFS = IAFS;
-          ids.IADS = IADS;
-          ids.IAIT = IAIT;
-          ids.IARI = IARI;
-          ids.IARDW = IARDW;
-          ids.IARDH = IARDH;
-          ids.IARDX = IARDX;
-          ids.IARDY = IARDY;
-          ids.IAID = IAID;
+          ids.IADT = IADT.get();
+          ids.IAFS = IAFS.get();
+          ids.IADS = IADS.get();
+          ids.IAIT = IAIT.get();
+          ids.IARI = IARI.get();
+          ids.IARDW = IARDW.get();
+          ids.IARDH = IARDH.get();
+          ids.IARDX = IARDX.get();
+          ids.IARDY = IARDY.get();
+          ids.IAID = IAID.get();
           BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);
-          if (BS == NULL) {
+          if (!BS) {
             FX_Free(SBSYMS);
-            delete SBHUFFFS;
-            delete SBHUFFDS;
-            delete SBHUFFDT;
-            delete SBHUFFRDW;
-            delete SBHUFFRDH;
-            delete SBHUFFRDX;
-            delete SBHUFFRDY;
-            delete SBHUFFRSIZE;
-            delete pDecoder;
             goto failed;
           }
           FX_Free(SBSYMS);
-          delete SBHUFFFS;
-          delete SBHUFFDS;
-          delete SBHUFFDT;
-          delete SBHUFFRDW;
-          delete SBHUFFRDH;
-          delete SBHUFFRDX;
-          delete SBHUFFRDY;
-          delete SBHUFFRSIZE;
-          delete pDecoder;
         } else if (REFAGGNINST == 1) {
           SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) {
             goto failed;
           }
           if ((IARDX->decode(pArithDecoder, &RDXI) == -1) ||
               (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
             goto failed;
           }
           if (IDI >= SBNUMSYMS) {
             goto failed;
           }
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           if (!SBSYMS[IDI]) {
             FX_Free(SBSYMS);
             goto failed;
           }
-          pGRRD = new CJBig2_GRRDProc();
+          nonstd::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
           pGRRD->GRW = SYMWIDTH;
           pGRRD->GRH = HCHEIGHT;
           pGRRD->GRTEMPLATE = SDRTEMPLATE;
           pGRRD->GRREFERENCE = SBSYMS[IDI];
           pGRRD->GRREFERENCEDX = RDXI;
           pGRRD->GRREFERENCEDY = RDYI;
           pGRRD->TPGRON = 0;
           pGRRD->GRAT[0] = SDRAT[0];
           pGRRD->GRAT[1] = SDRAT[1];
           pGRRD->GRAT[2] = SDRAT[2];
           pGRRD->GRAT[3] = SDRAT[3];
           BS = pGRRD->decode(pArithDecoder, grContext);
-          if (BS == NULL) {
+          if (!BS) {
             FX_Free(SBSYMS);
-            delete pGRRD;
             goto failed;
           }
           FX_Free(SBSYMS);
-          delete pGRRD;
         }
       }
       SDNEWSYMS[NSYMSDECODED] = BS;
-      BS = NULL;
+      BS = nullptr;
       NSYMSDECODED = NSYMSDECODED + 1;
     }
   }
   EXINDEX = 0;
   CUREXFLAG = 0;
   EXFLAGS = FX_Alloc(FX_BOOL, SDNUMINSYMS + SDNUMNEWSYMS);
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
     if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
       FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
       FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXRUNLENGTH != 0) {
       for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
         EXFLAGS[I] = CUREXFLAG;
       }
     }
     EXINDEX = EXINDEX + EXRUNLENGTH;
     CUREXFLAG = !CUREXFLAG;
   }
-  pDict = new CJBig2_SymbolDict();
   pDict->SDNUMEXSYMS = SDNUMEXSYMS;
   pDict->SDEXSYMS = FX_Alloc(CJBig2_Image*, SDNUMEXSYMS);
   I = J = 0;
   for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
     if (EXFLAGS[I] && J < SDNUMEXSYMS) {
       if (I < SDNUMINSYMS) {
         pDict->SDEXSYMS[J] = new CJBig2_Image(*SDINSYMS[I]);
       } else {
         pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
       }
       J = J + 1;
     } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
       delete SDNEWSYMS[I - SDNUMINSYMS];
     }
   }
   if (J < SDNUMEXSYMS) {
     pDict->SDNUMEXSYMS = J;
   }
   FX_Free(EXFLAGS);
   FX_Free(SDNEWSYMS);
-  delete IADH;
-  delete IADW;
-  delete IAAI;
-  delete IARDX;
-  delete IARDY;
-  delete IAEX;
-  delete IAID;
-  delete IADT;
-  delete IAFS;
-  delete IADS;
-  delete IAIT;
-  delete IARI;
-  delete IARDW;
-  delete IARDH;
-  return pDict;
+  return pDict.release();
 failed:
   for (I = 0; I < NSYMSDECODED; I++) {
     if (SDNEWSYMS[I]) {
       delete SDNEWSYMS[I];
-      SDNEWSYMS[I] = NULL;
+      SDNEWSYMS[I] = nullptr;
     }
   }
   FX_Free(SDNEWSYMS);
-  delete IADH;
-  delete IADW;
-  delete IAAI;
-  delete IARDX;
-  delete IARDY;
-  delete IAEX;
-  delete IAID;
-  delete IADT;
-  delete IAFS;
-  delete IADS;
-  delete IAIT;
-  delete IARI;
-  delete IARDW;
-  delete IARDH;
-  return NULL;
+  return nullptr;
 }
+
 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream* pStream,
                                                   JBig2ArithCtx* gbContext,
                                                   JBig2ArithCtx* grContext,
                                                   IFX_Pause* pPause) {
   CJBig2_Image** SDNEWSYMS;
   FX_DWORD* SDNEWSYMWIDTHS;
   FX_DWORD HCHEIGHT, NSYMSDECODED;
   int32_t HCDH;
   FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;
   int32_t DW;
   CJBig2_Image *BS, *BHC;
   FX_DWORD I, J, REFAGGNINST;
   FX_BOOL* EXFLAGS;
   FX_DWORD EXINDEX;
   FX_BOOL CUREXFLAG;
   FX_DWORD EXRUNLENGTH;
   int32_t nVal, nBits;
   FX_DWORD nTmp;
   FX_DWORD SBNUMSYMS;
   uint8_t SBSYMCODELEN;
   JBig2HuffmanCode* SBSYMCODES;
   FX_DWORD IDI;
   int32_t RDXI, RDYI;
   FX_DWORD BMSIZE;
   FX_DWORD stride;
   CJBig2_Image** SBSYMS;
-  CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH,
-      *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE, *pTable;
-  CJBig2_HuffmanDecoder* pHuffmanDecoder;
-  CJBig2_GRRDProc* pGRRD;
-  CJBig2_ArithDecoder* pArithDecoder;
-  CJBig2_GRDProc* pGRD;
-  CJBig2_SymbolDict* pDict;
-  pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
+  nonstd::unique_ptr<CJBig2_HuffmanDecoder> pHuffmanDecoder(
+      new CJBig2_HuffmanDecoder(pStream));
   SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS);
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
-  SDNEWSYMWIDTHS = NULL;
-  BHC = NULL;
+  SDNEWSYMWIDTHS = nullptr;
+  BHC = nullptr;
   if (SDREFAGG == 0) {
     SDNEWSYMWIDTHS = FX_Alloc(FX_DWORD, SDNUMNEWSYMS);
     FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
   }
+  nonstd::unique_ptr<CJBig2_SymbolDict> pDict(new CJBig2_SymbolDict());
+  nonstd::unique_ptr<CJBig2_HuffmanTable> pTable;
+
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
-  BS = NULL;
+  BS = nullptr;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
     if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
       goto failed;
     }
     SYMWIDTH = 0;
     TOTWIDTH = 0;
     HCFIRSTSYM = NSYMSDECODED;
     for (;;) {
       nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW);
       if (nVal == JBIG2_OOB) {
         break;
       } else if (nVal != 0) {
         goto failed;
       } else {
         if (NSYMSDECODED >= SDNUMNEWSYMS) {
           goto failed;
         }
         SYMWIDTH = SYMWIDTH + DW;
         if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
           goto failed;
         } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
           TOTWIDTH = TOTWIDTH + SYMWIDTH;
-          SDNEWSYMS[NSYMSDECODED] = NULL;
+          SDNEWSYMS[NSYMSDECODED] = nullptr;
           NSYMSDECODED = NSYMSDECODED + 1;
           continue;
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 1) {
         if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) !=
             0) {
           goto failed;
         }
-        BS = NULL;
+        BS = nullptr;
         if (REFAGGNINST > 1) {
-          CJBig2_TRDProc* pDecoder = new CJBig2_TRDProc();
+          nonstd::unique_ptr<CJBig2_TRDProc> pDecoder(new CJBig2_TRDProc());
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
           pDecoder->SBNUMINSTANCES = REFAGGNINST;
           pDecoder->SBSTRIPS = 1;
           pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           SBNUMSYMS = pDecoder->SBNUMSYMS;
           SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS);
           nTmp = 1;
           while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = nTmp;
             SBSYMCODES[I].code = I;
           }
           pDecoder->SBSYMCODES = SBSYMCODES;
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           pDecoder->SBSYMS = SBSYMS;
           pDecoder->SBDEFPIXEL = 0;
           pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
           pDecoder->TRANSPOSED = 0;
           pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
           pDecoder->SBDSOFFSET = 0;
-          SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6,
-                                             FX_ArraySize(HuffmanTable_B6),
-                                             HuffmanTable_HTOOB_B6);
-          SBHUFFDS = new CJBig2_HuffmanTable(HuffmanTable_B8,
-                                             FX_ArraySize(HuffmanTable_B8),
-                                             HuffmanTable_HTOOB_B8);
-          SBHUFFDT = new CJBig2_HuffmanTable(HuffmanTable_B11,
-                                             FX_ArraySize(HuffmanTable_B11),
-                                             HuffmanTable_HTOOB_B11);
-          SBHUFFRDW = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDH = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDX = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRDY = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRSIZE = new CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                FX_ArraySize(HuffmanTable_B1),
-                                                HuffmanTable_HTOOB_B1);
-          pDecoder->SBHUFFFS = SBHUFFFS;
-          pDecoder->SBHUFFDS = SBHUFFDS;
-          pDecoder->SBHUFFDT = SBHUFFDT;
-          pDecoder->SBHUFFRDW = SBHUFFRDW;
-          pDecoder->SBHUFFRDH = SBHUFFRDH;
-          pDecoder->SBHUFFRDX = SBHUFFRDX;
-          pDecoder->SBHUFFRDY = SBHUFFRDY;
-          pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFFS(
+              new CJBig2_HuffmanTable(HuffmanTable_B6,
+                                      FX_ArraySize(HuffmanTable_B6),
+                                      HuffmanTable_HTOOB_B6));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFDS(
+              new CJBig2_HuffmanTable(HuffmanTable_B8,
+                                      FX_ArraySize(HuffmanTable_B8),
+                                      HuffmanTable_HTOOB_B8));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFDT(
+              new CJBig2_HuffmanTable(HuffmanTable_B11,
+                                      FX_ArraySize(HuffmanTable_B11),
+                                      HuffmanTable_HTOOB_B11));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDW(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDH(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDX(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDY(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRSIZE(
+              new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                      FX_ArraySize(HuffmanTable_B1),
+                                      HuffmanTable_HTOOB_B1));
+          pDecoder->SBHUFFFS = SBHUFFFS.get();
+          pDecoder->SBHUFFDS = SBHUFFDS.get();
+          pDecoder->SBHUFFDT = SBHUFFDT.get();
+          pDecoder->SBHUFFRDW = SBHUFFRDW.get();
+          pDecoder->SBHUFFRDH = SBHUFFRDH.get();
+          pDecoder->SBHUFFRDX = SBHUFFRDX.get();
+          pDecoder->SBHUFFRDY = SBHUFFRDY.get();
+          pDecoder->SBHUFFRSIZE = SBHUFFRSIZE.get();
           pDecoder->SBRTEMPLATE = SDRTEMPLATE;
           pDecoder->SBRAT[0] = SDRAT[0];
           pDecoder->SBRAT[1] = SDRAT[1];
           pDecoder->SBRAT[2] = SDRAT[2];
           pDecoder->SBRAT[3] = SDRAT[3];
           BS = pDecoder->decode_Huffman(pStream, grContext);
-          if (BS == NULL) {
+          if (!BS) {
             FX_Free(SBSYMCODES);
             FX_Free(SBSYMS);
-            delete SBHUFFFS;
-            delete SBHUFFDS;
-            delete SBHUFFDT;
-            delete SBHUFFRDW;
-            delete SBHUFFRDH;
-            delete SBHUFFRDX;
-            delete SBHUFFRDY;
-            delete SBHUFFRSIZE;
-            delete pDecoder;
             goto failed;
           }
           FX_Free(SBSYMCODES);
           FX_Free(SBSYMS);
-          delete SBHUFFFS;
-          delete SBHUFFDS;
-          delete SBHUFFDT;
-          delete SBHUFFRDW;
-          delete SBHUFFRDH;
-          delete SBHUFFRDX;
-          delete SBHUFFRDY;
-          delete SBHUFFRSIZE;
-          delete pDecoder;
         } else if (REFAGGNINST == 1) {
           SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;
           nTmp = 1;
           while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           SBSYMCODELEN = (uint8_t)nTmp;
           SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS);
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = SBSYMCODELEN;
@@ skipping 11 matching lines @@
               if ((nVal == SBSYMCODES[IDI].code) &&
                   (nBits == SBSYMCODES[IDI].codelen)) {
                 break;
               }
             }
             if (IDI < SBNUMSYMS) {
               break;
             }
           }
           FX_Free(SBSYMCODES);
-          SBHUFFRDX = new CJBig2_HuffmanTable(HuffmanTable_B15,
-                                              FX_ArraySize(HuffmanTable_B15),
-                                              HuffmanTable_HTOOB_B15);
-          SBHUFFRSIZE = new CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                FX_ArraySize(HuffmanTable_B1),
-                                                HuffmanTable_HTOOB_B1);
-          if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
-              (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0) ||
-              (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
-            delete SBHUFFRDX;
-            delete SBHUFFRSIZE;
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRDX(
+              new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                      FX_ArraySize(HuffmanTable_B15),
+                                      HuffmanTable_HTOOB_B15));
+          nonstd::unique_ptr<CJBig2_HuffmanTable> SBHUFFRSIZE(
+              new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                      FX_ArraySize(HuffmanTable_B1),
+                                      HuffmanTable_HTOOB_B1));
+          if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX.get(), &RDXI) != 0) ||
+              (pHuffmanDecoder->decodeAValue(SBHUFFRDX.get(), &RDYI) != 0) ||
+              (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE.get(), &nVal) != 0)) {
             goto failed;
           }
-          delete SBHUFFRDX;
-          delete SBHUFFRSIZE;
           pStream->alignByte();
           nTmp = pStream->getOffset();
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
-          pGRRD = new CJBig2_GRRDProc();
+          nonstd::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
           pGRRD->GRW = SYMWIDTH;
           pGRRD->GRH = HCHEIGHT;
           pGRRD->GRTEMPLATE = SDRTEMPLATE;
           pGRRD->GRREFERENCE = SBSYMS[IDI];
           pGRRD->GRREFERENCEDX = RDXI;
           pGRRD->GRREFERENCEDY = RDYI;
           pGRRD->TPGRON = 0;
           pGRRD->GRAT[0] = SDRAT[0];
           pGRRD->GRAT[1] = SDRAT[1];
           pGRRD->GRAT[2] = SDRAT[2];
           pGRRD->GRAT[3] = SDRAT[3];
-          pArithDecoder = new CJBig2_ArithDecoder(pStream);
-          BS = pGRRD->decode(pArithDecoder, grContext);
-          if (BS == NULL) {
+          nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+              new CJBig2_ArithDecoder(pStream));
+          BS = pGRRD->decode(pArithDecoder.get(), grContext);
+          if (!BS) {
             FX_Free(SBSYMS);
-            delete pGRRD;
-            delete pArithDecoder;
             goto failed;
           }
           pStream->alignByte();
           pStream->offset(2);
           if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
             delete BS;
             FX_Free(SBSYMS);
-            delete pGRRD;
-            delete pArithDecoder;
             goto failed;
           }
           FX_Free(SBSYMS);
-          delete pGRRD;
-          delete pArithDecoder;
         }
         SDNEWSYMS[NSYMSDECODED] = BS;
       }
       if (SDREFAGG == 0) {
         SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;
       }
       NSYMSDECODED = NSYMSDECODED + 1;
     }
     if (SDREFAGG == 0) {
       if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) {
         goto failed;
       }
       pStream->alignByte();
       if (BMSIZE == 0) {
         stride = (TOTWIDTH + 7) >> 3;
         if (pStream->getByteLeft() >= stride * HCHEIGHT) {
           BHC = new CJBig2_Image(TOTWIDTH, HCHEIGHT);
           for (I = 0; I < HCHEIGHT; I++) {
             JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride,
                          pStream->getPointer(), stride);
             pStream->offset(stride);
           }
         } else {
           goto failed;
         }
       } else {
-        pGRD = new CJBig2_GRDProc();
+        nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
         pGRD->MMR = 1;
         pGRD->GBW = TOTWIDTH;
         pGRD->GBH = HCHEIGHT;
         FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);
         while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
           pGRD->Continue_decode(pPause);
         }
-        delete pGRD;
         pStream->alignByte();
       }
       nTmp = 0;
       if (!BHC) {
         continue;
       }
       for (I = HCFIRSTSYM; I < NSYMSDECODED; I++) {
         SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT);
         nTmp += SDNEWSYMWIDTHS[I];
       }
       delete BHC;
-      BHC = NULL;
+      BHC = nullptr;
     }
   }
   EXINDEX = 0;
   CUREXFLAG = 0;
-  pTable = new CJBig2_HuffmanTable(
-      HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1);
+  pTable.reset(new CJBig2_HuffmanTable(
+      HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1));
   EXFLAGS = FX_Alloc(FX_BOOL, SDNUMINSYMS + SDNUMNEWSYMS);
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
-    if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
-      delete pTable;
+    if (pHuffmanDecoder->decodeAValue(pTable.get(), (int*)&EXRUNLENGTH) != 0) {
       FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
-      delete pTable;
       FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXRUNLENGTH != 0) {
       for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
         EXFLAGS[I] = CUREXFLAG;
       }
     }
     EXINDEX = EXINDEX + EXRUNLENGTH;
     CUREXFLAG = !CUREXFLAG;
   }
-  delete pTable;
-  pDict = new CJBig2_SymbolDict();
   pDict->SDNUMEXSYMS = SDNUMEXSYMS;
   pDict->SDEXSYMS = FX_Alloc(CJBig2_Image*, SDNUMEXSYMS);
   I = J = 0;
   for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
     if (EXFLAGS[I] && J < SDNUMEXSYMS) {
       if (I < SDNUMINSYMS) {
         pDict->SDEXSYMS[J] = new CJBig2_Image(*SDINSYMS[I]);
       } else {
         pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
       }
       J = J + 1;
     } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
       delete SDNEWSYMS[I - SDNUMINSYMS];
     }
   }
   if (J < SDNUMEXSYMS) {
     pDict->SDNUMEXSYMS = J;
   }
   FX_Free(EXFLAGS);
   FX_Free(SDNEWSYMS);
   if (SDREFAGG == 0) {
     FX_Free(SDNEWSYMWIDTHS);
   }
-  delete pHuffmanDecoder;
-  return pDict;
+  return pDict.release();
 failed:
   for (I = 0; I < NSYMSDECODED; I++) {
     delete SDNEWSYMS[I];
   }
   FX_Free(SDNEWSYMS);
   if (SDREFAGG == 0) {
     FX_Free(SDNEWSYMWIDTHS);
   }
-  delete pHuffmanDecoder;
-  return NULL;
+  return nullptr;
 }
+
 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
                                             JBig2ArithCtx* gbContext,
                                             IFX_Pause* pPause) {
   FX_DWORD ng, mg;
   int32_t x, y;
   FX_DWORD HBPP;
   FX_DWORD* GI;
-  CJBig2_Image* HSKIP = nullptr;
-  CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH);
+  nonstd::unique_ptr<CJBig2_Image> HSKIP;
+  nonstd::unique_ptr<CJBig2_Image> HTREG(new CJBig2_Image(HBW, HBH));
   HTREG->fill(HDEFPIXEL);
   if (HENABLESKIP == 1) {
-    HSKIP = new CJBig2_Image(HGW, HGH);
+    HSKIP.reset(new CJBig2_Image(HGW, HGH));
     for (mg = 0; mg < HGH; mg++) {
       for (ng = 0; ng < HGW; ng++) {
         x = (HGX + mg * HRY + ng * HRX) >> 8;
         y = (HGY + mg * HRX - ng * HRY) >> 8;
         if ((x + HPW <= 0) | (x >= (int32_t)HBW) | (y + HPH <= 0) |
             (y >= (int32_t)HPH)) {
           HSKIP->setPixel(ng, mg, 1);
         } else {
           HSKIP->setPixel(ng, mg, 0);
         }
       }
     }
   }
   HBPP = 1;
   while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {
     HBPP++;
   }
-  CJBig2_GSIDProc* pGID = new CJBig2_GSIDProc();
+  nonstd::unique_ptr<CJBig2_GSIDProc> pGID(new CJBig2_GSIDProc());
   pGID->GSMMR = HMMR;
   pGID->GSW = HGW;
   pGID->GSH = HGH;
   pGID->GSBPP = (uint8_t)HBPP;
   pGID->GSUSESKIP = HENABLESKIP;
-  pGID->GSKIP = HSKIP;
+  pGID->GSKIP = HSKIP.get();
   pGID->GSTEMPLATE = HTEMPLATE;
   GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);
-  if (GI == NULL) {
-    goto failed;
-  }
+  if (!GI)
+    return nullptr;
+
   for (mg = 0; mg < HGH; mg++) {
     for (ng = 0; ng < HGW; ng++) {
       x = (HGX + mg * HRY + ng * HRX) >> 8;
       y = (HGY + mg * HRX - ng * HRY) >> 8;
       FX_DWORD pat_index = GI[mg * HGW + ng];
       if (pat_index >= HNUMPATS) {
         pat_index = HNUMPATS - 1;
       }
       HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
     }
   }
   FX_Free(GI);
-  delete HSKIP;
-  delete pGID;
-  return HTREG;
-failed:
-  delete HSKIP;
-  delete pGID;
-  delete HTREG;
-  return NULL;
+  return HTREG.release();
 }
+
 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream,
                                           IFX_Pause* pPause) {
   FX_DWORD ng, mg;
   int32_t x, y;
   FX_DWORD* GI;
-  CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH);
+  nonstd::unique_ptr<CJBig2_Image> HTREG(new CJBig2_Image(HBW, HBH));
   HTREG->fill(HDEFPIXEL);
   FX_DWORD HBPP = 1;
   while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {
     HBPP++;
   }
-  CJBig2_GSIDProc* pGID = new CJBig2_GSIDProc();
+  nonstd::unique_ptr<CJBig2_GSIDProc> pGID(new CJBig2_GSIDProc());
   pGID->GSMMR = HMMR;
   pGID->GSW = HGW;
   pGID->GSH = HGH;
   pGID->GSBPP = (uint8_t)HBPP;
   pGID->GSUSESKIP = 0;
   GI = pGID->decode_MMR(pStream, pPause);
-  if (GI == NULL) {
-    goto failed;
-  }
+  if (!GI)
+    return nullptr;
+
   for (mg = 0; mg < HGH; mg++) {
     for (ng = 0; ng < HGW; ng++) {
       x = (HGX + mg * HRY + ng * HRX) >> 8;
       y = (HGY + mg * HRX - ng * HRY) >> 8;
       FX_DWORD pat_index = GI[mg * HGW + ng];
       if (pat_index >= HNUMPATS) {
         pat_index = HNUMPATS - 1;
       }
       HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
     }
   }
   FX_Free(GI);
-  delete pGID;
-  return HTREG;
-failed:
-  delete pGID;
-  delete HTREG;
-  return NULL;
+  return HTREG.release();
 }
+
 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_DWORD GRAY;
-  CJBig2_Image* BHDC = NULL;
-  CJBig2_PatternDict* pDict = new CJBig2_PatternDict();
+  CJBig2_Image* BHDC = nullptr;
+  nonstd::unique_ptr<CJBig2_PatternDict> pDict(new CJBig2_PatternDict());
   pDict->NUMPATS = GRAYMAX + 1;
   pDict->HDPATS = FX_Alloc(CJBig2_Image*, pDict->NUMPATS);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
-  CJBig2_GRDProc* pGRD = new CJBig2_GRDProc();
+
+  nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
   pGRD->MMR = HDMMR;
   pGRD->GBW = (GRAYMAX + 1) * HDPW;
   pGRD->GBH = HDPH;
   pGRD->GBTEMPLATE = HDTEMPLATE;
   pGRD->TPGDON = 0;
   pGRD->USESKIP = 0;
   pGRD->GBAT[0] = -(int32_t)HDPW;
   pGRD->GBAT[1] = 0;
   if (pGRD->GBTEMPLATE == 0) {
     pGRD->GBAT[2] = -3;
     pGRD->GBAT[3] = -1;
     pGRD->GBAT[4] = 2;
     pGRD->GBAT[5] = -2;
     pGRD->GBAT[6] = -2;
     pGRD->GBAT[7] = -2;
   }
   FXCODEC_STATUS status =
       pGRD->Start_decode_Arith(&BHDC, pArithDecoder, gbContext);
   while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     pGRD->Continue_decode(pPause);
   }
-  if (BHDC == NULL) {
-    delete pGRD;
-    goto failed;
-  }
-  delete pGRD;
+  if (!BHDC)
+    return nullptr;
+
   GRAY = 0;
   while (GRAY <= GRAYMAX) {
     pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
     GRAY = GRAY + 1;
   }
   delete BHDC;
-  return pDict;
-failed:
-  delete pDict;
-  return NULL;
+  return pDict.release();
 }
 
 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream,
                                                IFX_Pause* pPause) {
   FX_DWORD GRAY;
-  CJBig2_Image* BHDC = NULL;
-  CJBig2_PatternDict* pDict = new CJBig2_PatternDict();
+  CJBig2_Image* BHDC = nullptr;
+  nonstd::unique_ptr<CJBig2_PatternDict> pDict(new CJBig2_PatternDict());
   pDict->NUMPATS = GRAYMAX + 1;
   pDict->HDPATS = FX_Alloc(CJBig2_Image*, pDict->NUMPATS);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
-  CJBig2_GRDProc* pGRD = new CJBig2_GRDProc();
+
+  nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
   pGRD->MMR = HDMMR;
   pGRD->GBW = (GRAYMAX + 1) * HDPW;
   pGRD->GBH = HDPH;
   FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream);
   while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     pGRD->Continue_decode(pPause);
   }
-  if (BHDC == NULL) {
-    delete pGRD;
-    goto failed;
-  }
-  delete pGRD;
+  if (!BHDC)
+    return nullptr;
+
   GRAY = 0;
   while (GRAY <= GRAYMAX) {
     pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
     GRAY = GRAY + 1;
   }
   delete BHDC;
-  return pDict;
-failed:
-  delete pDict;
-  return NULL;
+  return pDict.release();
 }
+
 FX_DWORD* CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
                                         JBig2ArithCtx* gbContext,
                                         IFX_Pause* pPause) {
   CJBig2_Image** GSPLANES;
   int32_t J, K;
   FX_DWORD x, y;
   FX_DWORD* GSVALS;
   GSPLANES = FX_Alloc(CJBig2_Image*, GSBPP);
-  if (!GSPLANES) {
-    return NULL;
-  }
   GSVALS = FX_Alloc2D(FX_DWORD, GSW, GSH);
-  if (!GSVALS) {
-    FX_Free(GSPLANES);
-    return NULL;
-  }
   JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
   JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
-  CJBig2_GRDProc* pGRD = new CJBig2_GRDProc();
+
+  nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
   pGRD->MMR = GSMMR;
   pGRD->GBW = GSW;
   pGRD->GBH = GSH;
   pGRD->GBTEMPLATE = GSTEMPLATE;
   pGRD->TPGDON = 0;
   pGRD->USESKIP = GSUSESKIP;
   pGRD->SKIP = GSKIP;
   if (GSTEMPLATE <= 1) {
     pGRD->GBAT[0] = 3;
   } else {
     pGRD->GBAT[0] = 2;
   }
   pGRD->GBAT[1] = -1;
   if (pGRD->GBTEMPLATE == 0) {
     pGRD->GBAT[2] = -3;
     pGRD->GBAT[3] = -1;
     pGRD->GBAT[4] = 2;
     pGRD->GBAT[5] = -2;
     pGRD->GBAT[6] = -2;
     pGRD->GBAT[7] = -2;
   }
   FXCODEC_STATUS status =
       pGRD->Start_decode_Arith(&GSPLANES[GSBPP - 1], pArithDecoder, gbContext);
   while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     pGRD->Continue_decode(pPause);
   }
-  if (GSPLANES[GSBPP - 1] == NULL) {
+  if (!GSPLANES[GSBPP - 1]) {
     goto failed;
   }
   J = GSBPP - 2;
   while (J >= 0) {
     FXCODEC_STATUS status =
         pGRD->Start_decode_Arith(&GSPLANES[J], pArithDecoder, gbContext);
     while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       pGRD->Continue_decode(pPause);
     }
-    if (GSPLANES[J] == NULL) {
+    if (!GSPLANES[J]) {
       for (K = GSBPP - 1; K > J; K--) {
         delete GSPLANES[K];
         goto failed;
       }
     }
     GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);
     J = J - 1;
   }
   for (y = 0; y < GSH; y++) {
     for (x = 0; x < GSW; x++) {
       for (J = 0; J < GSBPP; J++) {
         GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
       }
     }
   }
   for (J = 0; J < GSBPP; J++) {
     delete GSPLANES[J];
   }
   FX_Free(GSPLANES);
-  delete pGRD;
   return GSVALS;
 failed:
   FX_Free(GSPLANES);
-  delete pGRD;
   FX_Free(GSVALS);
-  return NULL;
+  return nullptr;
 }
+
 FX_DWORD* CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream* pStream,
                                       IFX_Pause* pPause) {
   CJBig2_Image** GSPLANES;
   int32_t J, K;
   FX_DWORD x, y;
   FX_DWORD* GSVALS;
   GSPLANES = FX_Alloc(CJBig2_Image*, GSBPP);
-  if (!GSPLANES) {
-    return NULL;
-  }
   GSVALS = FX_Alloc2D(FX_DWORD, GSW, GSH);
-  if (!GSVALS) {
-    FX_Free(GSPLANES);
-    return NULL;
-  }
   JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
   JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
-  CJBig2_GRDProc* pGRD = new CJBig2_GRDProc();
+
+  nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc());
   pGRD->MMR = GSMMR;
   pGRD->GBW = GSW;
   pGRD->GBH = GSH;
   FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream);
   while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     pGRD->Continue_decode(pPause);
   }
-  if (GSPLANES[GSBPP - 1] == NULL) {
+  if (!GSPLANES[GSBPP - 1]) {
     goto failed;
   }
   pStream->alignByte();
   pStream->offset(3);
   J = GSBPP - 2;
   while (J >= 0) {
     FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[J], pStream);
     while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       pGRD->Continue_decode(pPause);
     }
-    if (GSPLANES[J] == NULL) {
+    if (!GSPLANES[J]) {
       for (K = GSBPP - 1; K > J; K--) {
         delete GSPLANES[K];
         goto failed;
       }
     }
     pStream->alignByte();
     pStream->offset(3);
     GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);
     J = J - 1;
   }
   for (y = 0; y < GSH; y++) {
     for (x = 0; x < GSW; x++) {
       for (J = 0; J < GSBPP; J++) {
         GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
       }
     }
   }
   for (J = 0; J < GSBPP; J++) {
     delete GSPLANES[J];
   }
   FX_Free(GSPLANES);
-  delete pGRD;
   return GSVALS;
 failed:
   FX_Free(GSPLANES);
-  delete pGRD;
   FX_Free(GSVALS);
-  return NULL;
+  return nullptr;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith(
     CJBig2_Image** pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   if (GBW == 0 || GBH == 0) {
     m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
     return FXCODEC_STATUS_DECODE_FINISH;
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
   m_pPause = pPause;
   if (!*pImage)
     *pImage = new CJBig2_Image(GBW, GBH);
-  if ((*pImage)->m_pData == NULL) {
+  if (!(*pImage)->m_pData) {
     delete *pImage;
-    *pImage = NULL;
+    *pImage = nullptr;
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return FXCODEC_STATUS_ERROR;
   }
   m_DecodeType = 1;
   m_pImage = pImage;
   (*m_pImage)->fill(0);
   m_pArithDecoder = pArithDecoder;
   m_gbContext = gbContext;
   LTP = 0;
-  m_pLine = NULL;
+  m_pLine = nullptr;
   m_loopIndex = 0;
   return decode_Arith(pPause);
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith(IFX_Pause* pPause) {
   int iline = m_loopIndex;
   CJBig2_Image* pImage = *m_pImage;
   if (GBTEMPLATE == 0) {
     if ((GBAT[0] == 3) && (GBAT[1] == (int8_t)-1) && (GBAT[2] == (int8_t)-3) &&
         (GBAT[3] == (int8_t)-1) && (GBAT[4] == 2) && (GBAT[5] == (int8_t)-2) &&
         (GBAT[6] == (int8_t)-2) && (GBAT[7] == (int8_t)-2)) {
       m_ProssiveStatus = decode_Arith_Template0_opt3(pImage, m_pArithDecoder,
                                                      m_gbContext, pPause);
     } else {
@@ skipping 27 matching lines @@
   }
   m_ReplaceRect.left = 0;
   m_ReplaceRect.right = pImage->m_nWidth;
   m_ReplaceRect.top = iline;
   m_ReplaceRect.bottom = m_loopIndex;
   if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) {
     m_loopIndex = 0;
   }
   return m_ProssiveStatus;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage,
                                                 CJBig2_BitStream* pStream,
                                                 IFX_Pause* pPause) {
   int bitpos, i;
   *pImage = new CJBig2_Image(GBW, GBH);
-  if ((*pImage)->m_pData == NULL) {
+  if (!(*pImage)->m_pData) {
     delete (*pImage);
-    (*pImage) = NULL;
+    (*pImage) = nullptr;
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return m_ProssiveStatus;
   }
   bitpos = (int)pStream->getBitPos();
   _FaxG4Decode(pStream->getBuf(), pStream->getLength(), &bitpos,
                (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride);
   pStream->setBitPos(bitpos);
   for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) {
     (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i];
   }
@@ skipping 17 matching lines @@
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
-  if (m_pLine == NULL) {
+  if (!m_pLine) {
     m_pLine = pImage->m_pData;
   }
   nStride = pImage->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   FX_DWORD height = GBH & 0x7fffffff;
   for (; m_loopIndex < height; m_loopIndex++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
@@ skipping 62 matching lines @@
     m_pLine += nStride;
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
@@ skipping 34 matching lines @@
     }
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
@@ skipping 73 matching lines @@
     m_pLine += nStride;
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
@@ skipping 30 matching lines @@
     }
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   uint8_t *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
@@ skipping 73 matching lines @@
     m_pLine += nStride;
     if (pPause && m_loopIndex % 50 == 0 && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2, line3;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
@@ skipping 30 matching lines @@
     }
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1;
   uint8_t *pLine1, cVal;
   int32_t nStride, k;
@@ skipping 59 matching lines @@
     m_pLine += nStride;
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }
+
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(
     CJBig2_Image* pImage,
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_BOOL SLTP, bVal;
   FX_DWORD CONTEXT;
   FX_DWORD line1, line2;
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
@@ skipping 25 matching lines @@
     }
     if (pPause && pPause->NeedToPauseNow()) {
       m_loopIndex++;
       m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return FXCODEC_STATUS_DECODE_FINISH;
 }