Remove CJBig2_Object, CJBig2_Module, and friends.

core/src/fxcodec/jbig2/JBig2_Context.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 <list>
 #include "JBig2_Context.h"
 
 // Implement a very small least recently used (LRU) cache. It is very
 // common for a JBIG2 dictionary to span multiple pages in a PDF file,
 // and we do not want to decode the same dictionary over and over
 // again. We key off of the memory location of the dictionary. The
 // list keeps track of the freshness of entries, with freshest ones
 // at the front. Even a tiny cache size like 2 makes a dramatic
 // difference for typical JBIG2 documents.
 const int kSymbolDictCacheMaxSize = 2;
 
 CJBig2_Context* CJBig2_Context::CreateContext(
-    CJBig2_Module* pModule,
     uint8_t* pGlobalData,
     FX_DWORD dwGlobalLength,
     uint8_t* pData,
     FX_DWORD dwLength,
     int32_t nStreamType,
     std::list<CJBig2_CachePair>* pSymbolDictCache,
     IFX_Pause* pPause) {
-  return new (pModule)
-      CJBig2_Context(pGlobalData, dwGlobalLength, pData, dwLength, nStreamType,
-                     pSymbolDictCache, pPause);
+  return new CJBig2_Context(pGlobalData, dwGlobalLength, pData, dwLength,
+                            nStreamType, pSymbolDictCache, pPause);
 }
 void CJBig2_Context::DestroyContext(CJBig2_Context* pContext) {
   delete pContext;
 }
 CJBig2_Context::CJBig2_Context(uint8_t* pGlobalData,
                                FX_DWORD dwGlobalLength,
                                uint8_t* pData,
                                FX_DWORD dwLength,
                                int32_t nStreamType,
                                std::list<CJBig2_CachePair>* pSymbolDictCache,
                                IFX_Pause* pPause) {
   if (pGlobalData && (dwGlobalLength > 0)) {
-    JBIG2_ALLOC(m_pGlobalContext,
-                CJBig2_Context(NULL, 0, pGlobalData, dwGlobalLength,
-                               JBIG2_EMBED_STREAM, pSymbolDictCache, pPause));
+    m_pGlobalContext =
+        new CJBig2_Context(NULL, 0, pGlobalData, dwGlobalLength,
+                           JBIG2_EMBED_STREAM, pSymbolDictCache, pPause);
   } else {
     m_pGlobalContext = NULL;
   }
   m_pStream = new CJBig2_BitStream(pData, dwLength);
   m_nStreamType = nStreamType;
   m_nState = JBIG2_OUT_OF_PAGE;
   m_pPage = NULL;
   m_bBufSpecified = FALSE;
   m_pPause = pPause;
   m_nSegmentDecoded = 0;
   m_PauseStep = 10;
   m_pArithDecoder = NULL;
   m_pGRD = NULL;
   m_gbContext = NULL;
   m_dwOffset = 0;
   m_ProcessiveStatus = FXCODEC_STATUS_FRAME_READY;
   m_pSymbolDictCache = pSymbolDictCache;
 }
 CJBig2_Context::~CJBig2_Context() {
   delete m_pArithDecoder;
   m_pArithDecoder = NULL;
   delete m_pGRD;
   m_pGRD = NULL;
-  if (m_gbContext) {
-    m_pModule->JBig2_Free(m_gbContext);
-  }
+  FX_Free(m_gbContext);
   m_gbContext = NULL;
   delete m_pGlobalContext;
   m_pGlobalContext = NULL;
   if (m_bBufSpecified) {
     delete m_pPage;
   }
   m_pPage = NULL;
   delete m_pStream;
   m_pStream = NULL;
 }
@@ skipping 130 matching lines @@
   if (m_pGlobalContext) {
     nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
     if (nRet != JBIG2_SUCCESS) {
       m_ProcessiveStatus = FXCODEC_STATUS_ERROR;
       return nRet;
     }
   }
   m_bFirstPage = TRUE;
   m_PauseStep = 0;
   delete m_pPage;
-  JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf));
+  m_pPage = new CJBig2_Image(width, height, stride, pBuf);
   m_bBufSpecified = TRUE;
   if (m_pPage && pPause && pPause->NeedToPauseNow()) {
     m_PauseStep = 1;
     m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     return nRet;
   }
   int ret = Continue(pPause);
   return ret;
 }
 int32_t CJBig2_Context::Continue(IFX_Pause* pPause) {
@@ skipping 119 matching lines @@
     if (m_pStream->read1Byte(&cTemp) != 0) {
       goto failed;
     }
     pSegment->m_nReferred_to_segment_count = cTemp >> 5;
     dwTemp = 5 + 1;
   }
   cSSize =
       pSegment->m_dwNumber > 65536 ? 4 : pSegment->m_dwNumber > 256 ? 2 : 1;
   cPSize = pSegment->m_cFlags.s.page_association_size ? 4 : 1;
   if (pSegment->m_nReferred_to_segment_count) {
-    pSegment->m_pReferred_to_segment_numbers =
-        (FX_DWORD*)m_pModule->JBig2_Malloc2(
-            sizeof(FX_DWORD), pSegment->m_nReferred_to_segment_count);
+    pSegment->m_pReferred_to_segment_numbers = (FX_DWORD*)FX_Alloc2D(

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

Hmm.  I think we can use a lower "D" allocator and avoid the cast entirely since
the FX_Alloc() families multiplies by size of type. Wouldn't this just be 
  ... = FX_Alloc(FX_DWORD, pSegment->m_nReferred_to_segment_count);

[Lei Zhang, 2015/09/04 21:34:59]

Sure. This was all straight up JBig2_Malloc2 -> FX_Alloc2D via search and
replace.

+        uint8_t, sizeof(FX_DWORD), pSegment->m_nReferred_to_segment_count);
     for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
       switch (cSSize) {
         case 1:
           if (m_pStream->read1Byte(&cTemp) != 0) {
             goto failed;
           }
           pSegment->m_pReferred_to_segment_numbers[i] = cTemp;
           break;
         case 2:
           if (m_pStream->readShortInteger(&wTemp) != 0) {
@@ skipping 93 matching lines @@
       }
       pPageInfo->m_bIsStriped = ((wTemp >> 15) & 1) ? 1 : 0;
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
       if ((pPageInfo->m_dwHeight == 0xffffffff) &&
           (pPageInfo->m_bIsStriped != TRUE)) {
         pPageInfo->m_bIsStriped = TRUE;
       }
       if (!m_bBufSpecified) {
         delete m_pPage;
         if (pPageInfo->m_dwHeight == 0xffffffff) {
-          JBIG2_ALLOC(m_pPage, CJBig2_Image(pPageInfo->m_dwWidth,
-                                            pPageInfo->m_wMaxStripeSize));
+          m_pPage = new CJBig2_Image(pPageInfo->m_dwWidth,
+                                     pPageInfo->m_wMaxStripeSize);
         } else {
-          JBIG2_ALLOC(m_pPage, CJBig2_Image(pPageInfo->m_dwWidth,
-                                            pPageInfo->m_dwHeight));
+          m_pPage =
+              new CJBig2_Image(pPageInfo->m_dwWidth, pPageInfo->m_dwHeight);
         }
       }
       m_pPage->fill((pPageInfo->m_cFlags & 4) ? 1 : 0);
       m_PageInfoList.push_back(pPageInfo.release());
       m_nState = JBIG2_IN_PAGE;
     } break;
     case 49:
       m_nState = JBIG2_OUT_OF_PAGE;
       return JBIG2_END_OF_PAGE;
       break;
@@ skipping 23 matching lines @@
                                         IFX_Pause* pPause) {
   FX_DWORD dwTemp;
   FX_WORD wFlags;
   uint8_t cSDHUFFDH, cSDHUFFDW, cSDHUFFBMSIZE, cSDHUFFAGGINST;
   CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B2 = NULL, *Table_B3 = NULL,
                       *Table_B4 = NULL, *Table_B5 = NULL;
   int32_t i, nIndex, nRet;
   CJBig2_Segment *pSeg = NULL, *pLRSeg = NULL;
   FX_BOOL bUsed;
   CJBig2_Image** SDINSYMS = NULL;
-  CJBig2_SDDProc* pSymbolDictDecoder;
   JBig2ArithCtx *gbContext = NULL, *grContext = NULL;
   CJBig2_ArithDecoder* pArithDecoder;
-  JBIG2_ALLOC(pSymbolDictDecoder, CJBig2_SDDProc());
+  CJBig2_SDDProc* pSymbolDictDecoder = new CJBig2_SDDProc();
   uint8_t* key = pSegment->m_pData;
   FX_BOOL cache_hit = false;
   if (m_pStream->readShortInteger(&wFlags) != 0) {
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   pSymbolDictDecoder->SDHUFF = wFlags & 0x0001;
   pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001;
   pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003;
   pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003;
@@ skipping 43 matching lines @@
   for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
     pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
     if (pSeg->m_cFlags.s.type == 0) {
       pSymbolDictDecoder->SDNUMINSYMS += pSeg->m_Result.sd->SDNUMEXSYMS;
       pLRSeg = pSeg;
     }
   }
   if (pSymbolDictDecoder->SDNUMINSYMS == 0) {
     SDINSYMS = NULL;
   } else {
-    SDINSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
-        sizeof(CJBig2_Image*), pSymbolDictDecoder->SDNUMINSYMS);
+    SDINSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*),
+                                          pSymbolDictDecoder->SDNUMINSYMS);
     dwTemp = 0;
     for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
       pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
       if (pSeg->m_cFlags.s.type == 0) {
         JBIG2_memcpy(SDINSYMS + dwTemp, pSeg->m_Result.sd->SDEXSYMS,
                      pSeg->m_Result.sd->SDNUMEXSYMS * sizeof(CJBig2_Image*));
         dwTemp += pSeg->m_Result.sd->SDNUMEXSYMS;
       }
     }
   }
@@ skipping 69 matching lines @@
         }
         pSymbolDictDecoder->SDHUFFAGGINST = pSeg->m_Result.ht;
       }
     }
   }
   if ((wFlags & 0x0100) && pLRSeg && pLRSeg->m_Result.sd->m_bContextRetained) {
     if (pSymbolDictDecoder->SDHUFF == 0) {
       dwTemp = pSymbolDictDecoder->SDTEMPLATE == 0
                    ? 65536
                    : pSymbolDictDecoder->SDTEMPLATE == 1 ? 8192 : 1024;
-      gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(
-          sizeof(JBig2ArithCtx), dwTemp);
+      gbContext =
+          (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
       JBIG2_memcpy(gbContext, pLRSeg->m_Result.sd->m_gbContext,
                    sizeof(JBig2ArithCtx) * dwTemp);
     }
     if (pSymbolDictDecoder->SDREFAGG == 1) {
       dwTemp = pSymbolDictDecoder->SDRTEMPLATE ? 1 << 10 : 1 << 13;
-      grContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(
-          sizeof(JBig2ArithCtx), dwTemp);
+      grContext =
+          (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
       JBIG2_memcpy(grContext, pLRSeg->m_Result.sd->m_grContext,
                    sizeof(JBig2ArithCtx) * dwTemp);
     }
   } else {
     if (pSymbolDictDecoder->SDHUFF == 0) {
       dwTemp = pSymbolDictDecoder->SDTEMPLATE == 0
                    ? 65536
                    : pSymbolDictDecoder->SDTEMPLATE == 1 ? 8192 : 1024;
-      gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(
-          sizeof(JBig2ArithCtx), dwTemp);
+      gbContext =
+          (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
       JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     }
     if (pSymbolDictDecoder->SDREFAGG == 1) {
       dwTemp = pSymbolDictDecoder->SDRTEMPLATE ? 1 << 10 : 1 << 13;
-      grContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(
-          sizeof(JBig2ArithCtx), dwTemp);
+      grContext =
+          (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
       JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     }
   }
   pSegment->m_nResultType = JBIG2_SYMBOL_DICT_POINTER;
   for (std::list<CJBig2_CachePair>::iterator it = m_pSymbolDictCache->begin();
        it != m_pSymbolDictCache->end(); ++it) {
     if (it->first == key) {
       pSegment->m_Result.sd = it->second->DeepCopy();
       m_pSymbolDictCache->push_front(*it);
       m_pSymbolDictCache->erase(it);
@@ skipping 37 matching lines @@
       pSegment->m_Result.sd->m_gbContext = gbContext;
     }
     if (pSymbolDictDecoder->SDREFAGG == 1) {
       pSegment->m_Result.sd->m_grContext = grContext;
     }
     bUsed = TRUE;
   } else {
     bUsed = FALSE;
   }
   delete pSymbolDictDecoder;
-  if (SDINSYMS) {
-    m_pModule->JBig2_Free(SDINSYMS);
-  }
+  FX_Free(SDINSYMS);
   delete Table_B1;
   delete Table_B2;
   delete Table_B3;
   delete Table_B4;
   delete Table_B5;
   if (bUsed == FALSE) {
-    if (gbContext) {
-      m_pModule->JBig2_Free(gbContext);
-    }
-    if (grContext) {
-      m_pModule->JBig2_Free(grContext);
-    }
+    FX_Free(gbContext);
+    FX_Free(grContext);
   }
   return JBIG2_SUCCESS;
 failed:
   delete pSymbolDictDecoder;
-  if (SDINSYMS) {
-    m_pModule->JBig2_Free(SDINSYMS);
-  }
+  FX_Free(SDINSYMS);
   delete Table_B1;
   delete Table_B2;
   delete Table_B3;
   delete Table_B4;
   delete Table_B5;
-  if (gbContext) {
-    m_pModule->JBig2_Free(gbContext);
-  }
-  if (grContext) {
-    m_pModule->JBig2_Free(grContext);
-  }
+  FX_Free(gbContext);
+  FX_Free(grContext);
   return nRet;
 }
 
 int32_t CJBig2_Context::parseTextRegion(CJBig2_Segment* pSegment) {
   FX_DWORD dwTemp;
   FX_WORD wFlags;
   int32_t i, nIndex, nRet;
   JBig2RegionInfo ri;
   CJBig2_Segment* pSeg;
   CJBig2_Image** SBSYMS = NULL;
   JBig2HuffmanCode* SBSYMCODES = NULL;
   uint8_t cSBHUFFFS, cSBHUFFDS, cSBHUFFDT, cSBHUFFRDW, cSBHUFFRDH, cSBHUFFRDX,
       cSBHUFFRDY, cSBHUFFRSIZE;
   CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B6 = NULL, *Table_B7 = NULL,
                       *Table_B8 = NULL, *Table_B9 = NULL, *Table_B10 = NULL,
                       *Table_B11 = NULL, *Table_B12 = NULL, *Table_B13 = NULL,
                       *Table_B14 = NULL, *Table_B15 = NULL;
   JBig2ArithCtx* grContext = NULL;
   CJBig2_ArithDecoder* pArithDecoder;
-  CJBig2_TRDProc* pTRD;
-  JBIG2_ALLOC(pTRD, CJBig2_TRDProc());
+  CJBig2_TRDProc* pTRD = new CJBig2_TRDProc();
   if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) ||
       (m_pStream->readShortInteger(&wFlags) != 0)) {
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   pTRD->SBW = ri.width;
   pTRD->SBH = ri.height;
   pTRD->SBHUFF = wFlags & 0x0001;
   pTRD->SBREFINE = (wFlags >> 1) & 0x0001;
   dwTemp = (wFlags >> 2) & 0x0003;
@@ skipping 40 matching lines @@
     }
   }
   pTRD->SBNUMSYMS = 0;
   for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
     pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
     if (pSeg->m_cFlags.s.type == 0) {
       pTRD->SBNUMSYMS += pSeg->m_Result.sd->SDNUMEXSYMS;
     }
   }
   if (pTRD->SBNUMSYMS > 0) {
-    SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*),
-                                                      pTRD->SBNUMSYMS);
+    SBSYMS = (CJBig2_Image**)FX_Alloc2D(uint8_t, sizeof(CJBig2_Image*),
+                                        pTRD->SBNUMSYMS);
     dwTemp = 0;
     for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
       pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
       if (pSeg->m_cFlags.s.type == 0) {
         JBIG2_memcpy(SBSYMS + dwTemp, pSeg->m_Result.sd->SDEXSYMS,
                      pSeg->m_Result.sd->SDNUMEXSYMS * sizeof(CJBig2_Image*));
         dwTemp += pSeg->m_Result.sd->SDNUMEXSYMS;
       }
     }
     pTRD->SBSYMS = SBSYMS;
@@ skipping 180 matching lines @@
       if (!pSeg) {
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFRSIZE = pSeg->m_Result.ht;
     }
   }
   if (pTRD->SBREFINE == 1) {
     dwTemp = pTRD->SBRTEMPLATE ? 1 << 10 : 1 << 13;
     grContext =
-        (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp);
+        (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
     JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
   }
   if (pTRD->SBHUFF == 0) {
     pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
     pSegment->m_Result.im = pTRD->decode_Arith(pArithDecoder, grContext);
     delete pArithDecoder;
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
@@ skipping 16 matching lines @@
           (ri.y + ri.height > m_pPage->m_nHeight)) {
         m_pPage->expand(ri.y + ri.height, (pPageInfo->m_cFlags & 4) ? 1 : 0);
       }
     }
     m_pPage->composeFrom(ri.x, ri.y, pSegment->m_Result.im,
                          (JBig2ComposeOp)(ri.flags & 0x03));
     delete pSegment->m_Result.im;
     pSegment->m_Result.im = NULL;
   }
   delete pTRD;
-  if (SBSYMS) {
-    m_pModule->JBig2_Free(SBSYMS);
-  }
-  if (SBSYMCODES) {
-    m_pModule->JBig2_Free(SBSYMCODES);
-  }
-  if (grContext) {
-    m_pModule->JBig2_Free(grContext);
-  }
+  FX_Free(SBSYMS);
+  FX_Free(SBSYMCODES);
+  FX_Free(grContext);
   delete Table_B1;
   delete Table_B6;
   delete Table_B7;
   delete Table_B8;
   delete Table_B9;
   delete Table_B10;
   delete Table_B11;
   delete Table_B12;
   delete Table_B13;
   delete Table_B14;
   delete Table_B15;
   return JBIG2_SUCCESS;
 failed:
   delete pTRD;
-  if (SBSYMS) {
-    m_pModule->JBig2_Free(SBSYMS);
-  }
-  if (SBSYMCODES) {
-    m_pModule->JBig2_Free(SBSYMCODES);
-  }
-  if (grContext) {
-    m_pModule->JBig2_Free(grContext);
-  }
+  FX_Free(SBSYMS);
+  FX_Free(SBSYMCODES);
+  FX_Free(grContext);
   delete Table_B1;
   delete Table_B6;
   delete Table_B7;
   delete Table_B8;
   delete Table_B9;
   delete Table_B10;
   delete Table_B11;
   delete Table_B12;
   delete Table_B13;
   delete Table_B14;
   delete Table_B15;
   return nRet;
 }
 
 int32_t CJBig2_Context::parsePatternDict(CJBig2_Segment* pSegment,
                                          IFX_Pause* pPause) {
   FX_DWORD dwTemp;
   uint8_t cFlags;
   JBig2ArithCtx* gbContext;
   CJBig2_ArithDecoder* pArithDecoder;
-  CJBig2_PDDProc* pPDD;
   int32_t nRet;
-  JBIG2_ALLOC(pPDD, CJBig2_PDDProc());
+  CJBig2_PDDProc* pPDD = new CJBig2_PDDProc();
   if ((m_pStream->read1Byte(&cFlags) != 0) ||
       (m_pStream->read1Byte(&pPDD->HDPW) != 0) ||
       (m_pStream->read1Byte(&pPDD->HDPH) != 0) ||
       (m_pStream->readInteger(&pPDD->GRAYMAX) != 0)) {
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   if (pPDD->GRAYMAX > JBIG2_MAX_PATTERN_INDEX) {
     nRet = JBIG2_ERROR_LIMIT;
     goto failed;
   }
   pPDD->HDMMR = cFlags & 0x01;
   pPDD->HDTEMPLATE = (cFlags >> 1) & 0x03;
   pSegment->m_nResultType = JBIG2_PATTERN_DICT_POINTER;
   if (pPDD->HDMMR == 0) {
     dwTemp =
         pPDD->HDTEMPLATE == 0 ? 65536 : pPDD->HDTEMPLATE == 1 ? 8192 : 1024;
     gbContext =
-        (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp);
+        (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
     pSegment->m_Result.pd =
         pPDD->decode_Arith(pArithDecoder, gbContext, pPause);
     delete pArithDecoder;
     if (pSegment->m_Result.pd == NULL) {
-      m_pModule->JBig2_Free(gbContext);
+      FX_Free(gbContext);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
-    m_pModule->JBig2_Free(gbContext);
+    FX_Free(gbContext);
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream, pPause);
     if (pSegment->m_Result.pd == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   delete pPDD;
   return JBIG2_SUCCESS;
 failed:
   delete pPDD;
   return nRet;
 }
 int32_t CJBig2_Context::parseHalftoneRegion(CJBig2_Segment* pSegment,
                                             IFX_Pause* pPause) {
   FX_DWORD dwTemp;
   uint8_t cFlags;
   JBig2RegionInfo ri;
   CJBig2_Segment* pSeg;
   CJBig2_PatternDict* pPatternDict;
   JBig2ArithCtx* gbContext;
   CJBig2_ArithDecoder* pArithDecoder;
-  CJBig2_HTRDProc* pHRD;
   int32_t nRet;
-  JBIG2_ALLOC(pHRD, CJBig2_HTRDProc());
+  CJBig2_HTRDProc* pHRD = new CJBig2_HTRDProc();
   if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) ||
       (m_pStream->read1Byte(&cFlags) != 0) ||
       (m_pStream->readInteger(&pHRD->HGW) != 0) ||
       (m_pStream->readInteger(&pHRD->HGH) != 0) ||
       (m_pStream->readInteger((FX_DWORD*)&pHRD->HGX) != 0) ||
       (m_pStream->readInteger((FX_DWORD*)&pHRD->HGY) != 0) ||
       (m_pStream->readShortInteger(&pHRD->HRX) != 0) ||
       (m_pStream->readShortInteger(&pHRD->HRY) != 0)) {
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
@@ skipping 20 matching lines @@
     goto failed;
   }
   pHRD->HNUMPATS = pPatternDict->NUMPATS;
   pHRD->HPATS = pPatternDict->HDPATS;
   pHRD->HPW = pPatternDict->HDPATS[0]->m_nWidth;
   pHRD->HPH = pPatternDict->HDPATS[0]->m_nHeight;
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   if (pHRD->HMMR == 0) {
     dwTemp = pHRD->HTEMPLATE == 0 ? 65536 : pHRD->HTEMPLATE == 1 ? 8192 : 1024;
     gbContext =
-        (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp);
+        (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
     pSegment->m_Result.im =
         pHRD->decode_Arith(pArithDecoder, gbContext, pPause);
     delete pArithDecoder;
     if (pSegment->m_Result.im == NULL) {
-      m_pModule->JBig2_Free(gbContext);
+      FX_Free(gbContext);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
-    m_pModule->JBig2_Free(gbContext);
+    FX_Free(gbContext);
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_Result.im = pHRD->decode_MMR(m_pStream, pPause);
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
@@ skipping 16 matching lines @@
   delete pHRD;
   return nRet;
 }
 
 int32_t CJBig2_Context::parseGenericRegion(CJBig2_Segment* pSegment,
                                            IFX_Pause* pPause) {
   FX_DWORD dwTemp;
   uint8_t cFlags;
   int32_t i, nRet;
   if (m_pGRD == NULL) {
-    JBIG2_ALLOC(m_pGRD, CJBig2_GRDProc());
+    m_pGRD = new CJBig2_GRDProc();
     if ((parseRegionInfo(&m_ri) != JBIG2_SUCCESS) ||
         (m_pStream->read1Byte(&cFlags) != 0)) {
       nRet = JBIG2_ERROR_TOO_SHORT;
       goto failed;
     }
     if (m_ri.height < 0 || m_ri.width < 0) {
       nRet = JBIG2_FAILED;
       goto failed;
     }
     m_pGRD->GBW = m_ri.width;
@@ skipping 18 matching lines @@
         }
       }
     }
     m_pGRD->USESKIP = 0;
   }
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   if (m_pGRD->MMR == 0) {
     dwTemp =
         m_pGRD->GBTEMPLATE == 0 ? 65536 : m_pGRD->GBTEMPLATE == 1 ? 8192 : 1024;
     if (m_gbContext == NULL) {
-      m_gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc(
-          sizeof(JBig2ArithCtx) * dwTemp);
+      m_gbContext =
+          (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
       JBIG2_memset(m_gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     }
     if (m_pArithDecoder == NULL) {
       m_pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
       m_ProcessiveStatus = m_pGRD->Start_decode_Arith(
           &pSegment->m_Result.im, m_pArithDecoder, m_gbContext, pPause);
     } else {
       m_ProcessiveStatus = m_pGRD->Continue_decode(pPause);
     }
     if (m_ProcessiveStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       if (pSegment->m_cFlags.s.type != 36) {
         if (!m_bBufSpecified) {
           JBig2PageInfo* pPageInfo = m_PageInfoList.back();
           if ((pPageInfo->m_bIsStriped == 1) &&
               (m_ri.y + m_ri.height > m_pPage->m_nHeight)) {
             m_pPage->expand(m_ri.y + m_ri.height,
                             (pPageInfo->m_cFlags & 4) ? 1 : 0);
           }
         }
         FX_RECT Rect = m_pGRD->GetReplaceRect();
         m_pPage->composeFrom(m_ri.x + Rect.left, m_ri.y + Rect.top,
                              pSegment->m_Result.im,
                              (JBig2ComposeOp)(m_ri.flags & 0x03), &Rect);
       }
       return JBIG2_SUCCESS;
     } else {
       delete m_pArithDecoder;
       m_pArithDecoder = NULL;
       if (pSegment->m_Result.im == NULL) {
-        m_pModule->JBig2_Free(m_gbContext);
+        FX_Free(m_gbContext);
         nRet = JBIG2_ERROR_FATAL;
         m_gbContext = NULL;
         m_ProcessiveStatus = FXCODEC_STATUS_ERROR;
         goto failed;
       }
-      m_pModule->JBig2_Free(m_gbContext);
+      FX_Free(m_gbContext);
       m_gbContext = NULL;
       m_pStream->alignByte();
       m_pStream->offset(2);
     }
   } else {
     FXCODEC_STATUS status =
         m_pGRD->Start_decode_MMR(&pSegment->m_Result.im, m_pStream, pPause);
     while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       m_pGRD->Continue_decode(pPause);
     }
@@ skipping 28 matching lines @@
   return nRet;
 }
 
 int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) {
   FX_DWORD dwTemp;
   JBig2RegionInfo ri;
   CJBig2_Segment* pSeg;
   int32_t i, nRet;
   uint8_t cFlags;
   JBig2ArithCtx* grContext;
-  CJBig2_GRRDProc* pGRRD;
   CJBig2_ArithDecoder* pArithDecoder;
-  JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
+  CJBig2_GRRDProc* pGRRD = new CJBig2_GRRDProc();
   if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) ||
       (m_pStream->read1Byte(&cFlags) != 0)) {
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   pGRRD->GRW = ri.width;
   pGRRD->GRH = ri.height;
   pGRRD->GRTEMPLATE = cFlags & 0x01;
   pGRRD->TPGRON = (cFlags >> 1) & 0x01;
   if (pGRRD->GRTEMPLATE == 0) {
@@ skipping 22 matching lines @@
       goto failed;
     }
     pGRRD->GRREFERENCE = pSeg->m_Result.im;
   } else {
     pGRRD->GRREFERENCE = m_pPage;
   }
   pGRRD->GRREFERENCEDX = 0;
   pGRRD->GRREFERENCEDY = 0;
   dwTemp = pGRRD->GRTEMPLATE ? 1 << 10 : 1 << 13;
   grContext =
-      (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp);
+      (JBig2ArithCtx*)FX_Alloc2D(uint8_t, sizeof(JBig2ArithCtx), dwTemp);
   JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
   pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   pSegment->m_Result.im = pGRRD->decode(pArithDecoder, grContext);
   delete pArithDecoder;
   if (pSegment->m_Result.im == NULL) {
-    m_pModule->JBig2_Free(grContext);
+    FX_Free(grContext);
     nRet = JBIG2_ERROR_FATAL;
     goto failed;
   }
-  m_pModule->JBig2_Free(grContext);
+  FX_Free(grContext);
   m_pStream->alignByte();
   m_pStream->offset(2);
   if (pSegment->m_cFlags.s.type != 40) {
     if (!m_bBufSpecified) {
       JBig2PageInfo* pPageInfo = m_PageInfoList.back();
       if ((pPageInfo->m_bIsStriped == 1) &&
           (ri.y + ri.height > m_pPage->m_nHeight)) {
         m_pPage->expand(ri.y + ri.height, (pPageInfo->m_cFlags & 4) ? 1 : 0);
       }
     }
@@ skipping 35 matching lines @@
   JBig2HuffmanCode* SBSYMCODES;
   int32_t runcodes[35];
   int32_t runcodes_len[35];
   int32_t runcode;
   int32_t i;
   int32_t j;
   int32_t nVal;
   int32_t nBits;
   int32_t run;
   FX_DWORD nTemp;
-  SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(
-      sizeof(JBig2HuffmanCode), SBNUMSYMS);
+  SBSYMCODES = (JBig2HuffmanCode*)FX_Alloc2D(uint8_t, sizeof(JBig2HuffmanCode),
+                                             SBNUMSYMS);
   for (i = 0; i < 35; i++) {
     if (pStream->readNBits(4, &runcodes_len[i]) != 0) {
       goto failed;
     }
   }
   huffman_assign_code(runcodes, runcodes_len, 35);
   i = 0;
   while (i < (int)SBNUMSYMS) {
     nVal = 0;
     nBits = 0;
@@ skipping 44 matching lines @@
         }
       }
       i += run;
     } else {
       i++;
     }
   }
   huffman_assign_code(SBSYMCODES, SBNUMSYMS);
   return SBSYMCODES;
 failed:
-  m_pModule->JBig2_Free(SBSYMCODES);
+  FX_Free(SBSYMCODES);
   return NULL;
 }
 void CJBig2_Context::huffman_assign_code(int* CODES, int* PREFLEN, int NTEMP) {
   int CURLEN, LENMAX, CURCODE, CURTEMP, i;
   int* LENCOUNT;
   int* FIRSTCODE;
   LENMAX = 0;
   for (i = 0; i < NTEMP; i++) {
     if (PREFLEN[i] > LENMAX) {
       LENMAX = PREFLEN[i];
     }
   }
-  LENCOUNT = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1));
+  LENCOUNT = (int*)FX_Alloc2D(uint8_t, sizeof(int), (LENMAX + 1));
   JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1));
-  FIRSTCODE = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1));
+  FIRSTCODE = (int*)FX_Alloc2D(uint8_t, sizeof(int), (LENMAX + 1));
   for (i = 0; i < NTEMP; i++) {
     LENCOUNT[PREFLEN[i]]++;
   }
   CURLEN = 1;
   FIRSTCODE[0] = 0;
   LENCOUNT[0] = 0;
   while (CURLEN <= LENMAX) {
     FIRSTCODE[CURLEN] = (FIRSTCODE[CURLEN - 1] + LENCOUNT[CURLEN - 1]) << 1;
     CURCODE = FIRSTCODE[CURLEN];
     CURTEMP = 0;
     while (CURTEMP < NTEMP) {
       if (PREFLEN[CURTEMP] == CURLEN) {
         CODES[CURTEMP] = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
-  m_pModule->JBig2_Free(LENCOUNT);
-  m_pModule->JBig2_Free(FIRSTCODE);
+  FX_Free(LENCOUNT);
+  FX_Free(FIRSTCODE);
 }
 void CJBig2_Context::huffman_assign_code(JBig2HuffmanCode* SBSYMCODES,
                                          int NTEMP) {
   int CURLEN, LENMAX, CURCODE, CURTEMP, i;
   int* LENCOUNT;
   int* FIRSTCODE;
   LENMAX = 0;
   for (i = 0; i < NTEMP; i++) {
     if (SBSYMCODES[i].codelen > LENMAX) {
       LENMAX = SBSYMCODES[i].codelen;
     }
   }
-  LENCOUNT = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1));
+  LENCOUNT = (int*)FX_Alloc2D(uint8_t, sizeof(int), (LENMAX + 1));
   JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1));
-  FIRSTCODE = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1));
+  FIRSTCODE = (int*)FX_Alloc2D(uint8_t, sizeof(int), (LENMAX + 1));
   for (i = 0; i < NTEMP; i++) {
     LENCOUNT[SBSYMCODES[i].codelen]++;
   }
   CURLEN = 1;
   FIRSTCODE[0] = 0;
   LENCOUNT[0] = 0;
   while (CURLEN <= LENMAX) {
     FIRSTCODE[CURLEN] = (FIRSTCODE[CURLEN - 1] + LENCOUNT[CURLEN - 1]) << 1;
     CURCODE = FIRSTCODE[CURLEN];
     CURTEMP = 0;
     while (CURTEMP < NTEMP) {
       if (SBSYMCODES[CURTEMP].codelen == CURLEN) {
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
-  m_pModule->JBig2_Free(LENCOUNT);
-  m_pModule->JBig2_Free(FIRSTCODE);
+  FX_Free(LENCOUNT);
+  FX_Free(FIRSTCODE);
 }