Remove CJBig2_Object, CJBig2_Module, and friends.

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 "JBig2_ArithDecoder.h"
 #include "JBig2_ArithIntDecoder.h"
 #include "JBig2_HuffmanDecoder.h"
@@ skipping 16 matching lines @@
     {0x0221, 37, 34, 0}, {0x0141, 38, 35, 0}, {0x0111, 39, 36, 0},
     {0x0085, 40, 37, 0}, {0x0049, 41, 38, 0}, {0x0025, 42, 39, 0},
     {0x0015, 43, 40, 0}, {0x0009, 44, 41, 0}, {0x0005, 45, 42, 0},
     {0x0001, 45, 43, 0}, {0x5601, 46, 46, 0}};
 
 extern const unsigned int JBIG2_QE_NUM = FX_ArraySize(QeTable);
 
 CJBig2_Image* CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
                                            JBig2ArithCtx* gbContext) {
   if (GBW == 0 || GBH == 0) {
-    CJBig2_Image* pImage;
-    JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));
-    return pImage;
+    return new CJBig2_Image(GBW, GBH);
   }
   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)) {
       return decode_Arith_Template0_opt3(pArithDecoder, gbContext);
     } else {
       return decode_Arith_Template0_unopt(pArithDecoder, gbContext);
     }
   } else if (GBTEMPLATE == 1) {
@@ skipping 14 matching lines @@
     } else {
       return decode_Arith_Template3_unopt(pArithDecoder, gbContext);
     }
   }
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
   if (GBREG->m_pData == NULL) {
     delete GBREG;
     return NULL;
   }
   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;
@@ skipping 64 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  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 24 matching lines @@
       }
     }
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
   if (GBREG->m_pData == NULL) {
     delete GBREG;
     return NULL;
   }
   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++) {
@@ skipping 63 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  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 22 matching lines @@
       }
     }
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
   if (GBREG->m_pData == NULL) {
     delete GBREG;
     return NULL;
   }
   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++) {
@@ skipping 63 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2, line3;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  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 20 matching lines @@
       }
     }
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1;
   uint8_t *pLine, *pLine1, cVal;
   int32_t nStride, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH);
   if (GBREG->m_pData == NULL) {
     delete GBREG;
     return NULL;
   }
   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) {
@@ skipping 49 matching lines @@
     }
     pLine += nStride;
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   LTP = 0;
-  JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
+  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);
@@ skipping 14 matching lines @@
         line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f;
         line2 = ((line2 << 1) | bVal) & 0x0f;
       }
     }
   }
   return GBREG;
 }
 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder,
                                       JBig2ArithCtx* grContext) {
   if (GRW == 0 || GRH == 0) {
-    CJBig2_Image* pImage;
-    JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH));
-    return pImage;
+    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;
-  CJBig2_Image* GRREG;
   FX_DWORD line1, line2, line3, line4, line5;
   LTP = 0;
-  JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
+  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 91 matching lines @@
       }
     }
   }
   return GRREG;
 }
 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GRREG;
   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;
-  JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
+  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
   if (GRREG->m_pData == NULL) {
     delete GRREG;
     return NULL;
   }
   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;
@@ skipping 104 matching lines @@
       pLineR += nStrideR;
     }
   }
   return GRREG;
 }
 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GRREG;
   FX_DWORD line1, line2, line3, line4, line5;
   LTP = 0;
-  JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
+  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 77 matching lines @@
       }
     }
   }
   return GRREG;
 }
 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* grContext) {
   FX_BOOL LTP, SLTP, bVal;
   FX_DWORD CONTEXT;
-  CJBig2_Image* GRREG;
   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;
-  JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
+  CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH);
   if (GRREG->m_pData == NULL) {
     delete GRREG;
     return NULL;
   }
   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;
@@ skipping 109 matching lines @@
   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;
-  CJBig2_Image* SBREG;
   FX_BOOL bFirst;
   FX_DWORD nTmp;
   int32_t nVal, nBits;
   CJBig2_GRRDProc* pGRRD;
   CJBig2_ArithDecoder* pArithDecoder;
   CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
-  JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
+  CJBig2_Image* SBREG = new CJBig2_Image(SBW, SBH);
   SBREG->fill(SBDEFPIXEL);
   if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {
     goto failed;
   }
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
   FIRSTS = 0;
   NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {
@@ skipping 72 matching lines @@
         nTmp = pStream->getOffset();
         IBOI = SBSYMS[IDI];
         if (!IBOI) {
           goto failed;
         }
         WOI = IBOI->m_nWidth;
         HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
           goto failed;
         }
-        JBIG2_ALLOC(pGRRD, 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];
@@ skipping 121 matching lines @@
     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;
   }
-  JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
+  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;
         }
-        JBIG2_ALLOC(pGRRD, 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];
@@ skipping 129 matching lines @@
   IADS = new CJBig2_ArithIntDecoder();
   IAIT = new CJBig2_ArithIntDecoder();
   IARI = new CJBig2_ArithIntDecoder();
   IARDW = new CJBig2_ArithIntDecoder();
   IARDH = new CJBig2_ArithIntDecoder();
   nTmp = 0;
   while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
     nTmp++;
   }
   IAID = new CJBig2_ArithIaidDecoder((uint8_t)nTmp);
-  SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,
-                                                       sizeof(CJBig2_Image*));
+  SDNEWSYMS =
+      (CJBig2_Image**)FX_Alloc2D(uint8_t, SDNUMNEWSYMS, sizeof(CJBig2_Image*));

[Tom Sepez, 2015/09/04 01:26:47]

ditto

   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     BS = NULL;
     if (IADH->decode(pArithDecoder, &HCDH) == -1) {
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
     if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
@@ skipping 16 matching lines @@
           goto failed;
         } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
           TOTWIDTH = TOTWIDTH + SYMWIDTH;
           SDNEWSYMS[NSYMSDECODED] = NULL;
           NSYMSDECODED = NSYMSDECODED + 1;
           continue;
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 0) {
-        JBIG2_ALLOC(pGRD, 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;
           goto failed;
         }
         delete pGRD;
       } else {
         if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {
           goto failed;
         }
         if (REFAGGNINST > 1) {
           CJBig2_TRDProc* pDecoder;
-          JBIG2_ALLOC(pDecoder, 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 = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(CJBig2_Image*));
+          SBSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, SBNUMSYMS,

[Tom Sepez, 2015/09/04 01:26:47]

ditto ditto

+                                              sizeof(CJBig2_Image*));
           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,
@@ skipping 39 matching lines @@
           ids.IADS = IADS;
           ids.IAIT = IAIT;
           ids.IARI = IARI;
           ids.IARDW = IARDW;
           ids.IARDH = IARDH;
           ids.IARDX = IARDX;
           ids.IARDY = IARDY;
           ids.IAID = IAID;
           BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);
           if (BS == NULL) {
-            m_pModule->JBig2_Free(SBSYMS);
+            FX_Free(SBSYMS);
             delete SBHUFFFS;
             delete SBHUFFDS;
             delete SBHUFFDT;
             delete SBHUFFRDW;
             delete SBHUFFRDH;
             delete SBHUFFRDX;
             delete SBHUFFRDY;
             delete SBHUFFRSIZE;
             delete pDecoder;
             goto failed;
           }
-          m_pModule->JBig2_Free(SBSYMS);
+          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 = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(CJBig2_Image*));
+          SBSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, SBNUMSYMS,

[Tom Sepez, 2015/09/04 01:26:47]

ditto ditto ditto
(Many other places in the CL).

+                                              sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           if (!SBSYMS[IDI]) {
-            m_pModule->JBig2_Free(SBSYMS);
+            FX_Free(SBSYMS);
             goto failed;
           }
-          JBIG2_ALLOC(pGRRD, 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) {
-            m_pModule->JBig2_Free(SBSYMS);
+            FX_Free(SBSYMS);
             delete pGRRD;
             goto failed;
           }
-          m_pModule->JBig2_Free(SBSYMS);
+          FX_Free(SBSYMS);
           delete pGRRD;
         }
       }
       SDNEWSYMS[NSYMSDECODED] = BS;
       BS = NULL;
       NSYMSDECODED = NSYMSDECODED + 1;
     }
   }
   EXINDEX = 0;
   CUREXFLAG = 0;
-  EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
-                                               (SDNUMINSYMS + SDNUMNEWSYMS));
+  EXFLAGS = (FX_BOOL*)FX_Alloc2D(uint8_t, sizeof(FX_BOOL),
+                                 (SDNUMINSYMS + SDNUMNEWSYMS));
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
     if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
-      m_pModule->JBig2_Free(EXFLAGS);
+      FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
-      m_pModule->JBig2_Free(EXFLAGS);
+      FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXRUNLENGTH != 0) {
       for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
         EXFLAGS[I] = CUREXFLAG;
       }
     }
     EXINDEX = EXINDEX + EXRUNLENGTH;
     CUREXFLAG = !CUREXFLAG;
   }
-  JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
+  pDict = new CJBig2_SymbolDict();
   pDict->SDNUMEXSYMS = SDNUMEXSYMS;
-  pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-      sizeof(CJBig2_Image*), SDNUMEXSYMS);
+  pDict->SDEXSYMS =
+      (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*), SDNUMEXSYMS);
   I = J = 0;
   for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
     if (EXFLAGS[I] && J < SDNUMEXSYMS) {
       if (I < SDNUMINSYMS) {
-        JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
+        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;
   }
-  m_pModule->JBig2_Free(EXFLAGS);
-  m_pModule->JBig2_Free(SDNEWSYMS);
+  FX_Free(EXFLAGS);
+  FX_Free(SDNEWSYMS);
   delete IADH;

[Tom Sepez, 2015/09/04 01:26:47]

nit: someone needs an unique_ptr.

[Lei Zhang, 2015/09/04 21:35:00]

Planned in a follow-up, and getting rid of all the gotos.

   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;
 failed:
   for (I = 0; I < NSYMSDECODED; I++) {
     if (SDNEWSYMS[I]) {
       delete SDNEWSYMS[I];
       SDNEWSYMS[I] = NULL;
     }
   }
-  m_pModule->JBig2_Free(SDNEWSYMS);
+  FX_Free(SDNEWSYMS);
   delete IADH;
   delete IADW;
   delete IAAI;
   delete IARDX;
   delete IARDY;
   delete IAEX;
   delete IAID;
   delete IADT;
   delete IAFS;
   delete IADS;
@@ skipping 30 matching lines @@
   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);
-  SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,
-                                                       sizeof(CJBig2_Image*));
+  SDNEWSYMS =
+      (CJBig2_Image**)FX_Alloc2D(uint8_t, SDNUMNEWSYMS, sizeof(CJBig2_Image*));
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
   SDNEWSYMWIDTHS = NULL;
   BHC = NULL;
   if (SDREFAGG == 0) {
     SDNEWSYMWIDTHS =
-        (FX_DWORD*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD));
+        (FX_DWORD*)FX_Alloc2D(uint8_t, SDNUMNEWSYMS, sizeof(FX_DWORD));
     FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
   }
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   BS = NULL;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
@@ skipping 24 matching lines @@
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 1) {
         if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) !=
             0) {
           goto failed;
         }
         BS = NULL;
         if (REFAGGNINST > 1) {
-          CJBig2_TRDProc* pDecoder;
-          JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
+          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 = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(JBig2HuffmanCode));
+          SBSYMCODES = (JBig2HuffmanCode*)FX_Alloc2D(uint8_t, SBNUMSYMS,
+                                                     sizeof(JBig2HuffmanCode));
           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 = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(CJBig2_Image*));
+          SBSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, SBNUMSYMS,
+                                              sizeof(CJBig2_Image*));
           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,
@@ skipping 28 matching lines @@
           pDecoder->SBHUFFRDX = SBHUFFRDX;
           pDecoder->SBHUFFRDY = SBHUFFRDY;
           pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
           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) {
-            m_pModule->JBig2_Free(SBSYMCODES);
-            m_pModule->JBig2_Free(SBSYMS);
+            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;
           }
-          m_pModule->JBig2_Free(SBSYMCODES);
-          m_pModule->JBig2_Free(SBSYMS);
+          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 = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(JBig2HuffmanCode));
+          SBSYMCODES = (JBig2HuffmanCode*)FX_Alloc2D(uint8_t, SBNUMSYMS,
+                                                     sizeof(JBig2HuffmanCode));
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = SBSYMCODELEN;
             SBSYMCODES[I].code = I;
           }
           nVal = 0;
           nBits = 0;
           for (;;) {
             if (pStream->read1Bit(&nTmp) != 0) {
-              m_pModule->JBig2_Free(SBSYMCODES);
+              FX_Free(SBSYMCODES);
               goto failed;
             }
             nVal = (nVal << 1) | nTmp;
             for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
               if ((nVal == SBSYMCODES[IDI].code) &&
                   (nBits == SBSYMCODES[IDI].codelen)) {
                 break;
               }
             }
             if (IDI < SBNUMSYMS) {
               break;
             }
           }
-          m_pModule->JBig2_Free(SBSYMCODES);
+          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;
             goto failed;
           }
           delete SBHUFFRDX;
           delete SBHUFFRSIZE;
           pStream->alignByte();
           nTmp = pStream->getOffset();
-          SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-              SBNUMSYMS, sizeof(CJBig2_Image*));
+          SBSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, SBNUMSYMS,
+                                              sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
-          JBIG2_ALLOC(pGRRD, 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) {
-            m_pModule->JBig2_Free(SBSYMS);
+            FX_Free(SBSYMS);
             delete pGRRD;
             delete pArithDecoder;
             goto failed;
           }
           pStream->alignByte();
           pStream->offset(2);
           if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
             delete BS;
-            m_pModule->JBig2_Free(SBSYMS);
+            FX_Free(SBSYMS);
             delete pGRRD;
             delete pArithDecoder;
             goto failed;
           }
-          m_pModule->JBig2_Free(SBSYMS);
+          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) {
-          JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, 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 {
-        JBIG2_ALLOC(pGRD, 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;
     }
   }
   EXINDEX = 0;
   CUREXFLAG = 0;
   pTable = new CJBig2_HuffmanTable(
       HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1);
-  EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
-                                               (SDNUMINSYMS + SDNUMNEWSYMS));
+  EXFLAGS = (FX_BOOL*)FX_Alloc2D(uint8_t, sizeof(FX_BOOL),
+                                 (SDNUMINSYMS + SDNUMNEWSYMS));
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
       delete pTable;
-      m_pModule->JBig2_Free(EXFLAGS);
+      FX_Free(EXFLAGS);
       goto failed;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
       delete pTable;
-      m_pModule->JBig2_Free(EXFLAGS);
+      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;
-  JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
+  pDict = new CJBig2_SymbolDict();
   pDict->SDNUMEXSYMS = SDNUMEXSYMS;
-  pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-      sizeof(CJBig2_Image*), SDNUMEXSYMS);
+  pDict->SDEXSYMS =
+      (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*), SDNUMEXSYMS);
   I = J = 0;
   for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
     if (EXFLAGS[I] && J < SDNUMEXSYMS) {
       if (I < SDNUMINSYMS) {
-        JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
+        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;
   }
-  m_pModule->JBig2_Free(EXFLAGS);
-  m_pModule->JBig2_Free(SDNEWSYMS);
+  FX_Free(EXFLAGS);
+  FX_Free(SDNEWSYMS);
   if (SDREFAGG == 0) {
-    m_pModule->JBig2_Free(SDNEWSYMWIDTHS);
+    FX_Free(SDNEWSYMWIDTHS);
   }
   delete pHuffmanDecoder;
   return pDict;
 failed:
   for (I = 0; I < NSYMSDECODED; I++) {
     delete SDNEWSYMS[I];
   }
-  m_pModule->JBig2_Free(SDNEWSYMS);
+  FX_Free(SDNEWSYMS);
   if (SDREFAGG == 0) {
-    m_pModule->JBig2_Free(SDNEWSYMWIDTHS);
+    FX_Free(SDNEWSYMWIDTHS);
   }
   delete pHuffmanDecoder;
   return NULL;
 }
 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
                                             JBig2ArithCtx* gbContext,
                                             IFX_Pause* pPause) {
   FX_DWORD ng, mg;
   int32_t x, y;
-  CJBig2_Image* HSKIP;
   FX_DWORD HBPP;
   FX_DWORD* GI;
-  CJBig2_Image* HTREG;
-  CJBig2_GSIDProc* pGID;
-  JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));
+  CJBig2_Image* HSKIP = nullptr;
+  CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH);
   HTREG->fill(HDEFPIXEL);
-  HSKIP = NULL;
   if (HENABLESKIP == 1) {
-    JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH));
+    HSKIP = 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++;
   }
-  JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
+  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->GSTEMPLATE = HTEMPLATE;
   GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);
   if (GI == NULL) {
     goto failed;
   }
   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);
     }
   }
-  m_pModule->JBig2_Free(GI);
+  FX_Free(GI);
   delete HSKIP;
   delete pGID;
   return HTREG;
 failed:
   delete HSKIP;
   delete pGID;
   delete HTREG;
   return NULL;
 }
 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream,
                                           IFX_Pause* pPause) {
   FX_DWORD ng, mg;
   int32_t x, y;
-  FX_DWORD HBPP;
   FX_DWORD* GI;
-  CJBig2_Image* HTREG;
-  CJBig2_GSIDProc* pGID;
-  JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));
+  CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH);
   HTREG->fill(HDEFPIXEL);
-  HBPP = 1;
+  FX_DWORD HBPP = 1;
   while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {
     HBPP++;
   }
-  JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
+  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;
   }
   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);
     }
   }
-  m_pModule->JBig2_Free(GI);
+  FX_Free(GI);
   delete pGID;
   return HTREG;
 failed:
   delete pGID;
   delete HTREG;
   return NULL;
 }
 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith(
     CJBig2_ArithDecoder* pArithDecoder,
     JBig2ArithCtx* gbContext,
     IFX_Pause* pPause) {
   FX_DWORD GRAY;
   CJBig2_Image* BHDC = NULL;
-  CJBig2_PatternDict* pDict;
-  CJBig2_GRDProc* pGRD;
-  pDict = new CJBig2_PatternDict();
+  CJBig2_PatternDict* pDict = new CJBig2_PatternDict();
   pDict->NUMPATS = GRAYMAX + 1;
-  pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-      sizeof(CJBig2_Image*), pDict->NUMPATS);
+  pDict->HDPATS = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*),
+                                             pDict->NUMPATS);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
-  JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
+  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;
@@ skipping 22 matching lines @@
   return pDict;
 failed:
   delete pDict;
   return NULL;
 }
 
 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream,
                                                IFX_Pause* pPause) {
   FX_DWORD GRAY;
   CJBig2_Image* BHDC = NULL;
-  CJBig2_GRDProc* pGRD;
   CJBig2_PatternDict* pDict = new CJBig2_PatternDict();
   pDict->NUMPATS = GRAYMAX + 1;
-  pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-      sizeof(CJBig2_Image*), pDict->NUMPATS);
+  pDict->HDPATS = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*),
+                                             pDict->NUMPATS);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
-  JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
+  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;
@@ skipping 10 matching lines @@
   delete pDict;
   return NULL;
 }
 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;
-  CJBig2_GRDProc* pGRD;
-  GSPLANES =
-      (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
+  GSPLANES = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*), GSBPP);
   if (!GSPLANES) {
     return NULL;
   }
-  GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
+  GSVALS = (FX_DWORD*)FX_Alloc3D(uint8_t, sizeof(FX_DWORD), GSW, GSH);
   if (!GSVALS) {
-    m_pModule->JBig2_Free(GSPLANES);
+    FX_Free(GSPLANES);
     return NULL;
   }
   JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
   JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
-  JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
+  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 {
@@ skipping 35 matching lines @@
   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];
   }
-  m_pModule->JBig2_Free(GSPLANES);
+  FX_Free(GSPLANES);
   delete pGRD;
   return GSVALS;
 failed:
-  m_pModule->JBig2_Free(GSPLANES);
+  FX_Free(GSPLANES);
   delete pGRD;
-  m_pModule->JBig2_Free(GSVALS);
+  FX_Free(GSVALS);
   return NULL;
 }
 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;
-  CJBig2_GRDProc* pGRD;
-  GSPLANES =
-      (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
+  GSPLANES = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*), GSBPP);
   if (!GSPLANES) {
     return NULL;
   }
-  GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
+  GSVALS = (FX_DWORD*)FX_Alloc3D(uint8_t, sizeof(FX_DWORD), GSW, GSH);
   if (!GSVALS) {
-    if (GSPLANES) {
-      m_pModule->JBig2_Free(GSPLANES);
-    }
+    FX_Free(GSPLANES);
     return NULL;
   }
   JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
   JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
-  JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
+  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) {
     goto failed;
   }
@@ skipping 19 matching lines @@
   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];
   }
-  m_pModule->JBig2_Free(GSPLANES);
+  FX_Free(GSPLANES);
   delete pGRD;
   return GSVALS;
 failed:
-  m_pModule->JBig2_Free(GSPLANES);
+  FX_Free(GSPLANES);
   delete pGRD;
-  m_pModule->JBig2_Free(GSVALS);
+  FX_Free(GSVALS);
   return NULL;
 }
 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 == NULL) {
-    JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
-  }
+  if (!*pImage)
+    *pImage = new CJBig2_Image(GBW, GBH);
   if ((*pImage)->m_pData == NULL) {
     delete *pImage;
     *pImage = NULL;
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return FXCODEC_STATUS_ERROR;
   }
   m_DecodeType = 1;
   m_pImage = pImage;
   (*m_pImage)->fill(0);
   m_pArithDecoder = pArithDecoder;
@@ skipping 47 matching lines @@
   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;
-  JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
+  *pImage = new CJBig2_Image(GBW, GBH);
   if ((*pImage)->m_pData == NULL) {
     delete (*pImage);
     (*pImage) = NULL;
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return m_ProssiveStatus;
   }
   bitpos = (int)pStream->getBitPos();
-  _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos,
+  _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];
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
   return m_ProssiveStatus;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) {
@@ skipping 559 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;
 }