Make a bunch of JBig2 classes independent of CJBig2_Object.

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 11 matching lines @@
     {0x2801, 22, 19, 0}, {0x2401, 23, 20, 0}, {0x2201, 24, 21, 0},
     {0x1C01, 25, 22, 0}, {0x1801, 26, 23, 0}, {0x1601, 27, 24, 0},
     {0x1401, 28, 25, 0}, {0x1201, 29, 26, 0}, {0x1101, 30, 27, 0},
     {0x0AC1, 31, 28, 0}, {0x09C1, 32, 29, 0}, {0x08A1, 33, 30, 0},
     {0x0521, 34, 31, 0}, {0x0441, 35, 32, 0}, {0x02A1, 36, 33, 0},
     {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 = sizeof(QeTable) / sizeof(JBig2ArithQe);
+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;
   }
   if (GBTEMPLATE == 0) {
     if ((GBAT[0] == 3) && (GBAT[1] == (int8_t)-1) && (GBAT[2] == (int8_t)-3) &&
@@ skipping 1088 matching lines @@
   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_HuffmanDecoder* pHuffmanDecoder;
   CJBig2_GRRDProc* pGRRD;
   CJBig2_ArithDecoder* pArithDecoder;
-  JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
+  CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
   JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
   if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {
     m_pModule->JBig2_Error(
         "text region decoding procedure (huffman): too short.");
     goto failed;
   }
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
   FIRSTS = 0;
@@ skipping 104 matching lines @@
         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];
-        JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
+        pArithDecoder = new CJBig2_ArithDecoder(pStream);
         IBI = pGRRD->decode(pArithDecoder, grContext);
         if (IBI == NULL) {
           delete pGRRD;
           delete pArithDecoder;
           goto failed;
         }
         delete pArithDecoder;
         pStream->alignByte();
         pStream->offset(2);
         if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
@@ skipping 101 matching lines @@
     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 {
-    JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
-    JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder(SBSYMCODELEN));
+    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;
   }
   JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
   if (IADT->decode(pArithDecoder, &STRIPT) == -1) {
     m_pModule->JBig2_Error(
         "text region decoding procedure (arith): too short.");
     goto failed;
   }
   STRIPT *= SBSTRIPS;
@@ skipping 215 matching lines @@
   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;
-  JBIG2_ALLOC(IADH, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IADW, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IAAI, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IAEX, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());
-  JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());
+  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();
   nTmp = 0;
   while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
     nTmp++;
   }
-  JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((uint8_t)nTmp));
+  IAID = new CJBig2_ArithIaidDecoder((uint8_t)nTmp);
   SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,
                                                        sizeof(CJBig2_Image*));
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     BS = NULL;
     if (IADH->decode(pArithDecoder, &HCDH) == -1) {
       m_pModule->JBig2_Error(
           "symbol dictionary decoding procedure (arith): too short.");
@@ skipping 86 matching lines @@
               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;
-          JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
-                                                    sizeof(HuffmanTable_B6) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B6));
-          JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
-                                                    sizeof(HuffmanTable_B8) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B8));
-          JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
-                                                    sizeof(HuffmanTable_B11) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B11));
-          JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRSIZE,
-                      CJBig2_HuffmanTable(
-                          HuffmanTable_B1,
-                          sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
-                          HuffmanTable_HTOOB_B1));
+          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;
           pDecoder->SBRTEMPLATE = SDRTEMPLATE;
           pDecoder->SBRAT[0] = SDRAT[0];
@@ skipping 204 matching lines @@
   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;
-  JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
+  pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
   SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(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));
     FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
   }
@@ skipping 79 matching lines @@
               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;
-          JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
-                                                    sizeof(HuffmanTable_B6) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B6));
-          JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
-                                                    sizeof(HuffmanTable_B8) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B8));
-          JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
-                                                    sizeof(HuffmanTable_B11) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B11));
-          JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRSIZE,
-                      CJBig2_HuffmanTable(
-                          HuffmanTable_B1,
-                          sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
-                          HuffmanTable_HTOOB_B1));
+          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;
           pDecoder->SBRTEMPLATE = SDRTEMPLATE;
           pDecoder->SBRAT[0] = SDRAT[0];
@@ skipping 53 matching lines @@
               if ((nVal == SBSYMCODES[IDI].code) &&
                   (nBits == SBSYMCODES[IDI].codelen)) {
                 break;
               }
             }
             if (IDI < SBNUMSYMS) {
               break;
             }
           }
           m_pModule->JBig2_Free(SBSYMCODES);
-          JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                     sizeof(HuffmanTable_B15) /
-                                                         sizeof(JBig2TableLine),
-                                                     HuffmanTable_HTOOB_B15));
-          JBIG2_ALLOC(SBHUFFRSIZE,
-                      CJBig2_HuffmanTable(
-                          HuffmanTable_B1,
-                          sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
-                          HuffmanTable_HTOOB_B1));
+          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;
             m_pModule->JBig2_Error(
                 "symbol dictionary decoding procedure (huffman): too short.");
             goto failed;
           }
           delete SBHUFFRDX;
@@ skipping 10 matching lines @@
           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];
-          JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
+          pArithDecoder = new CJBig2_ArithDecoder(pStream);
           BS = pGRRD->decode(pArithDecoder, grContext);
           if (BS == NULL) {
             m_pModule->JBig2_Free(SBSYMS);
             delete pGRRD;
             delete pArithDecoder;
             goto failed;
           }
           pStream->alignByte();
           pStream->offset(2);
           if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
@@ skipping 58 matching lines @@
       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;
-  JBIG2_ALLOC(pTable, CJBig2_HuffmanTable(
-                          HuffmanTable_B1,
-                          sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
-                          HuffmanTable_HTOOB_B1));
+  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));
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
       delete pTable;
       m_pModule->JBig2_Free(EXFLAGS);
       m_pModule->JBig2_Error(
           "symbol dictionary decoding procedure (huffman): too short.");
       goto failed;
     }
@@ skipping 161 matching lines @@
   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;
-  JBIG2_ALLOC(pDict, CJBig2_PatternDict());
+  pDict = new CJBig2_PatternDict();
   pDict->NUMPATS = GRAYMAX + 1;
   pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
       sizeof(CJBig2_Image*), pDict->NUMPATS);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
   JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
   pGRD->MMR = HDMMR;
   pGRD->GBW = (GRAYMAX + 1) * HDPW;
   pGRD->GBH = HDPH;
   pGRD->GBTEMPLATE = HDTEMPLATE;
   pGRD->TPGDON = 0;
@@ skipping 27 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_PatternDict* pDict;
   CJBig2_GRDProc* pGRD;
-  JBIG2_ALLOC(pDict, 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);
   JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
   JBIG2_ALLOC(pGRD, 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) {
@@ skipping 840 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;
 }