Merge to XFA: Make a bunch of JBig2 classes independent of CJBig2_Object.

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 <map>
 #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.
@@ skipping 22 matching lines @@
                                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));
   } else {
     m_pGlobalContext = NULL;
   }
-  JBIG2_ALLOC(m_pStream, CJBig2_BitStream(pData, dwLength));
+  m_pStream = new CJBig2_BitStream(pData, dwLength);
   m_nStreamType = nStreamType;
   m_nState = JBIG2_OUT_OF_PAGE;
-  JBIG2_ALLOC(m_pSegmentList, CJBig2_List<CJBig2_Segment>);
-  JBIG2_ALLOC(m_pPageInfoList, CJBig2_List<JBig2PageInfo>(1));
   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_pSegment = 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);
   }
   m_gbContext = NULL;
   delete m_pGlobalContext;
   m_pGlobalContext = NULL;
-  delete m_pPageInfoList;
-  m_pPageInfoList = NULL;
   if (m_bBufSpecified) {
     delete m_pPage;
   }
   m_pPage = NULL;
   delete m_pStream;
   m_pStream = NULL;
-  delete m_pSegmentList;
-  m_pSegmentList = NULL;
 }
 int32_t CJBig2_Context::decodeFile(IFX_Pause* pPause) {
   uint8_t cFlags;
   FX_DWORD dwTemp;
   const uint8_t fileID[] = {0x97, 0x4A, 0x42, 0x32, 0x0D, 0x0A, 0x1A, 0x0A};
   int32_t nRet;
   if (m_pStream->getByteLeft() < 8) {
     m_pModule->JBig2_Error("file header too short.");
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   if (JBIG2_memcmp(m_pStream->getPointer(), fileID, 8) != 0) {
     m_pModule->JBig2_Error("not jbig2 file");
     nRet = JBIG2_ERROR_FILE_FORMAT;
     goto failed;
   }
   m_pStream->offset(8);
   if (m_pStream->read1Byte(&cFlags) != 0) {
     m_pModule->JBig2_Error("file header too short.");
     nRet = JBIG2_ERROR_TOO_SHORT;
     goto failed;
   }
   if (!(cFlags & 0x02)) {
     if (m_pStream->readInteger(&dwTemp) != 0) {
       m_pModule->JBig2_Error("file header too short.");
       nRet = JBIG2_ERROR_TOO_SHORT;
       goto failed;
     }
     if (dwTemp > 0) {
-      delete m_pPageInfoList;
-      JBIG2_ALLOC(m_pPageInfoList, CJBig2_List<JBig2PageInfo>(dwTemp));
+      m_PageInfoList.clear();
+      m_PageInfoList.resize(dwTemp);
     }
   }
   if (cFlags & 0x01) {
     m_nStreamType = JBIG2_SQUENTIAL_STREAM;
     return decode_SquentialOrgnazation(pPause);
   } else {
     m_nStreamType = JBIG2_RANDOM_STREAM;
     return decode_RandomOrgnazation_FirstPage(pPause);
   }
 failed:
   return nRet;
 }
 int32_t CJBig2_Context::decode_SquentialOrgnazation(IFX_Pause* pPause) {
   int32_t nRet;
-  if (m_pStream->getByteLeft() > 0) {
-    while (m_pStream->getByteLeft() >= JBIG2_MIN_SEGMENT_SIZE) {
-      if (m_pSegment == NULL) {
-        JBIG2_ALLOC(m_pSegment, CJBig2_Segment());
-        nRet = parseSegmentHeader(m_pSegment);
-        if (nRet != JBIG2_SUCCESS) {
-          delete m_pSegment;
-          m_pSegment = NULL;
-          return nRet;
-        }
-        m_dwOffset = m_pStream->getOffset();
-      }
-      nRet = parseSegmentData(m_pSegment, pPause);
-      if (m_ProcessiveStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
-        m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-        m_PauseStep = 2;
-        return JBIG2_SUCCESS;
-      }
-      if ((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE)) {
-        delete m_pSegment;
-        m_pSegment = NULL;
-        break;
-      } else if (nRet != JBIG2_SUCCESS) {
-        delete m_pSegment;
-        m_pSegment = NULL;
+  if (m_pStream->getByteLeft() <= 0)
+    return JBIG2_END_OF_FILE;
+
+  while (m_pStream->getByteLeft() >= JBIG2_MIN_SEGMENT_SIZE) {
+    if (!m_pSegment) {
+      m_pSegment.reset(new CJBig2_Segment);
+      nRet = parseSegmentHeader(m_pSegment.get());
+      if (nRet != JBIG2_SUCCESS) {
+        m_pSegment.reset();
         return nRet;
       }
-      m_pSegmentList->addItem(m_pSegment);
-      if (m_pSegment->m_dwData_length != 0xffffffff) {
-        m_dwOffset = m_dwOffset + m_pSegment->m_dwData_length;
-        m_pStream->setOffset(m_dwOffset);
-      } else {
-        m_pStream->offset(4);
-      }
-      m_pSegment = NULL;
-      if (m_pStream->getByteLeft() > 0 && m_pPage && pPause &&
-          pPause->NeedToPauseNow()) {
-        m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-        m_PauseStep = 2;
-        return JBIG2_SUCCESS;
-      }
+      m_dwOffset = m_pStream->getOffset();
     }
-  } else {
-    return JBIG2_END_OF_FILE;
+    nRet = parseSegmentData(m_pSegment.get(), pPause);
+    if (m_ProcessiveStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
+      m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_PauseStep = 2;
+      return JBIG2_SUCCESS;
+    }
+    if ((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE)) {
+      m_pSegment.reset();
+      return JBIG2_SUCCESS;
+    }
+    if (nRet != JBIG2_SUCCESS) {
+      m_pSegment.reset();
+      return nRet;
+    }
+    if (m_pSegment->m_dwData_length != 0xffffffff) {
+      m_dwOffset = m_dwOffset + m_pSegment->m_dwData_length;
+      m_pStream->setOffset(m_dwOffset);
+    } else {
+      m_pStream->offset(4);
+    }
+    m_SegmentList.push_back(m_pSegment.release());
+    if (m_pStream->getByteLeft() > 0 && m_pPage && pPause &&
+        pPause->NeedToPauseNow()) {
+      m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_PauseStep = 2;
+      return JBIG2_SUCCESS;
+    }
   }
   return JBIG2_SUCCESS;
 }
 int32_t CJBig2_Context::decode_EmbedOrgnazation(IFX_Pause* pPause) {
   return decode_SquentialOrgnazation(pPause);
 }
 int32_t CJBig2_Context::decode_RandomOrgnazation_FirstPage(IFX_Pause* pPause) {
-  CJBig2_Segment* pSegment;
   int32_t nRet;
   while (m_pStream->getByteLeft() > JBIG2_MIN_SEGMENT_SIZE) {
-    JBIG2_ALLOC(pSegment, CJBig2_Segment());
-    nRet = parseSegmentHeader(pSegment);
+    nonstd::unique_ptr<CJBig2_Segment> pSegment(new CJBig2_Segment);
+    nRet = parseSegmentHeader(pSegment.get());
     if (nRet != JBIG2_SUCCESS) {
-      delete pSegment;
       return nRet;
     } else if (pSegment->m_cFlags.s.type == 51) {
-      delete pSegment;
       break;
     }
-    m_pSegmentList->addItem(pSegment);
+    m_SegmentList.push_back(pSegment.release());
     if (pPause && m_pPause && pPause->NeedToPauseNow()) {
       m_PauseStep = 3;
       m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return JBIG2_SUCCESS;
     }
   }
   m_nSegmentDecoded = 0;
   return decode_RandomOrgnazation(pPause);
 }
 int32_t CJBig2_Context::decode_RandomOrgnazation(IFX_Pause* pPause) {
-  int32_t nRet;
-  for (; m_nSegmentDecoded < m_pSegmentList->getLength(); m_nSegmentDecoded++) {
-    nRet = parseSegmentData(m_pSegmentList->getAt(m_nSegmentDecoded), pPause);
-    if ((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE)) {
-      break;
-    } else if (nRet != JBIG2_SUCCESS) {
+  for (; m_nSegmentDecoded < m_SegmentList.size(); ++m_nSegmentDecoded) {
+    int32_t nRet =
+        parseSegmentData(m_SegmentList.get(m_nSegmentDecoded), pPause);
+    if ((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE))
+      return JBIG2_SUCCESS;
+
+    if (nRet != JBIG2_SUCCESS)
       return nRet;
-    }
+
     if (m_pPage && pPause && pPause->NeedToPauseNow()) {
       m_PauseStep = 4;
       m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       return JBIG2_SUCCESS;
     }
   }
   return JBIG2_SUCCESS;
 }
 int32_t CJBig2_Context::getFirstPage(uint8_t* pBuf,
                                      int32_t width,
@@ skipping 79 matching lines @@
     nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
     if (nRet != JBIG2_SUCCESS) {
       return nRet;
     }
   }
   m_bBufSpecified = FALSE;
   return Continue(pPause);
 }
 CJBig2_Segment* CJBig2_Context::findSegmentByNumber(FX_DWORD dwNumber) {
   CJBig2_Segment* pSeg;
-  int32_t i;
   if (m_pGlobalContext) {
     pSeg = m_pGlobalContext->findSegmentByNumber(dwNumber);
     if (pSeg) {
       return pSeg;
     }
   }
-  for (i = 0; i < m_pSegmentList->getLength(); i++) {
-    pSeg = m_pSegmentList->getAt(i);
+  for (size_t i = 0; i < m_SegmentList.size(); ++i) {
+    pSeg = m_SegmentList.get(i);
     if (pSeg->m_dwNumber == dwNumber) {
       return pSeg;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CJBig2_Segment* CJBig2_Context::findReferredSegmentByTypeAndIndex(
     CJBig2_Segment* pSegment,
     uint8_t cType,
     int32_t nIndex) {
   CJBig2_Segment* pSeg;
   int32_t i, count;
   count = 0;
   for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) {
     pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
@@ skipping 134 matching lines @@
     case 40:
     case 42:
     case 43:
       if (m_nState == JBIG2_OUT_OF_PAGE) {
         goto failed2;
       } else {
         return parseGenericRefinementRegion(pSegment);
       }
     case 48: {
       FX_WORD wTemp;
-      JBig2PageInfo* pPageInfo;
-      JBIG2_ALLOC(pPageInfo, JBig2PageInfo);
+      nonstd::unique_ptr<JBig2PageInfo> pPageInfo(new JBig2PageInfo);
       if ((m_pStream->readInteger(&pPageInfo->m_dwWidth) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwHeight) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwResolutionX) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwResolutionY) != 0) ||
           (m_pStream->read1Byte(&pPageInfo->m_cFlags) != 0) ||
           (m_pStream->readShortInteger(&wTemp) != 0)) {
-        delete pPageInfo;
         goto failed1;
       }
       pPageInfo->m_bIsStriped = ((wTemp >> 15) & 1) ? 1 : 0;
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
       if ((pPageInfo->m_dwHeight == 0xffffffff) &&
-          (pPageInfo->m_bIsStriped != 1)) {
+          (pPageInfo->m_bIsStriped != TRUE)) {
         m_pModule->JBig2_Warn("page height = 0xffffffff buf stripe field is 0");
-        pPageInfo->m_bIsStriped = 1;
+        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));
         } else {
           JBIG2_ALLOC(m_pPage, CJBig2_Image(pPageInfo->m_dwWidth,
                                             pPageInfo->m_dwHeight));
         }
       }
       m_pPage->fill((pPageInfo->m_cFlags & 4) ? 1 : 0);
-      m_pPageInfoList->addItem(pPageInfo);
+      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;
     case 50:
       m_pStream->offset(pSegment->m_dwData_length);
       break;
     case 51:
@@ skipping 123 matching lines @@
   if (pSymbolDictDecoder->SDHUFF == 1) {
     if ((cSDHUFFDH == 2) || (cSDHUFFDW == 2)) {
       m_pModule->JBig2_Error(
           "symbol dictionary segment : SDHUFFDH=2 or SDHUFFDW=2 is not "
           "permitted.");
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     nIndex = 0;
     if (cSDHUFFDH == 0) {
-      JBIG2_ALLOC(Table_B4, CJBig2_HuffmanTable(HuffmanTable_B4,
-                                                sizeof(HuffmanTable_B4) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B4));
+      Table_B4 = new CJBig2_HuffmanTable(HuffmanTable_B4,
+                                         FX_ArraySize(HuffmanTable_B4),
+                                         HuffmanTable_HTOOB_B4);
       pSymbolDictDecoder->SDHUFFDH = Table_B4;
     } else if (cSDHUFFDH == 1) {
-      JBIG2_ALLOC(Table_B5, CJBig2_HuffmanTable(HuffmanTable_B5,
-                                                sizeof(HuffmanTable_B5) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B5));
+      Table_B5 = new CJBig2_HuffmanTable(HuffmanTable_B5,
+                                         FX_ArraySize(HuffmanTable_B5),
+                                         HuffmanTable_HTOOB_B5);
       pSymbolDictDecoder->SDHUFFDH = Table_B5;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "symbol dictionary segment : SDHUFFDH can't find user supplied "
             "table.");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pSymbolDictDecoder->SDHUFFDH = pSeg->m_Result.ht;
     }
     if (cSDHUFFDW == 0) {
-      JBIG2_ALLOC(Table_B2, CJBig2_HuffmanTable(HuffmanTable_B2,
-                                                sizeof(HuffmanTable_B2) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B2));
+      Table_B2 = new CJBig2_HuffmanTable(HuffmanTable_B2,
+                                         FX_ArraySize(HuffmanTable_B2),
+                                         HuffmanTable_HTOOB_B2);
       pSymbolDictDecoder->SDHUFFDW = Table_B2;
     } else if (cSDHUFFDW == 1) {
-      JBIG2_ALLOC(Table_B3, CJBig2_HuffmanTable(HuffmanTable_B3,
-                                                sizeof(HuffmanTable_B3) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B3));
+      Table_B3 = new CJBig2_HuffmanTable(HuffmanTable_B3,
+                                         FX_ArraySize(HuffmanTable_B3),
+                                         HuffmanTable_HTOOB_B3);
       pSymbolDictDecoder->SDHUFFDW = Table_B3;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "symbol dictionary segment : SDHUFFDW can't find user supplied "
             "table.");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pSymbolDictDecoder->SDHUFFDW = pSeg->m_Result.ht;
     }
     if (cSDHUFFBMSIZE == 0) {
-      JBIG2_ALLOC(Table_B1, CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                sizeof(HuffmanTable_B1) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B1));
+      Table_B1 = new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                         FX_ArraySize(HuffmanTable_B1),
+                                         HuffmanTable_HTOOB_B1);
       pSymbolDictDecoder->SDHUFFBMSIZE = Table_B1;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "symbol dictionary segment : SDHUFFBMSIZE can't find user supplied "
             "table.");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pSymbolDictDecoder->SDHUFFBMSIZE = pSeg->m_Result.ht;
     }
     if (pSymbolDictDecoder->SDREFAGG == 1) {
       if (cSDHUFFAGGINST == 0) {
         if (!Table_B1) {
-          JBIG2_ALLOC(Table_B1, CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                    sizeof(HuffmanTable_B1) /
-                                                        sizeof(JBig2TableLine),
-                                                    HuffmanTable_HTOOB_B1));
+          Table_B1 = new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                             FX_ArraySize(HuffmanTable_B1),
+                                             HuffmanTable_HTOOB_B1);
         }
         pSymbolDictDecoder->SDHUFFAGGINST = Table_B1;
       } else {
         pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
         if (!pSeg) {
           m_pModule->JBig2_Error(
               "symbol dictionary segment : SDHUFFAGGINST can't find user "
               "supplied table.");
           nRet = JBIG2_ERROR_FATAL;
           goto failed;
@@ skipping 41 matching lines @@
     if (it->first == key) {
       pSegment->m_Result.sd = it->second->DeepCopy();
       m_pSymbolDictCache->push_front(*it);
       m_pSymbolDictCache->erase(it);
       cache_hit = true;
       break;
     }
   }
   if (!cache_hit) {
     if (pSymbolDictDecoder->SDHUFF == 0) {
-      JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+      pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
       pSegment->m_Result.sd =
           pSymbolDictDecoder->decode_Arith(pArithDecoder, gbContext, grContext);
       delete pArithDecoder;
       if (pSegment->m_Result.sd == NULL) {
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       m_pStream->alignByte();
       m_pStream->offset(2);
     } else {
@@ skipping 183 matching lines @@
     if ((cSBHUFFFS == 2) || (cSBHUFFRDW == 2) || (cSBHUFFRDH == 2) ||
         (cSBHUFFRDX == 2) || (cSBHUFFRDY == 2)) {
       m_pModule->JBig2_Error(
           "text region segment : SBHUFFFS=2 or SBHUFFRDW=2 or "
           "SBHUFFRDH=2 or SBHUFFRDX=2 or SBHUFFRDY=2 is not permitted");
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     nIndex = 0;
     if (cSBHUFFFS == 0) {
-      JBIG2_ALLOC(Table_B6, CJBig2_HuffmanTable(HuffmanTable_B6,
-                                                sizeof(HuffmanTable_B6) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B6));
+      Table_B6 = new CJBig2_HuffmanTable(HuffmanTable_B6,
+                                         FX_ArraySize(HuffmanTable_B6),
+                                         HuffmanTable_HTOOB_B6);
       pTRD->SBHUFFFS = Table_B6;
     } else if (cSBHUFFFS == 1) {
-      JBIG2_ALLOC(Table_B7, CJBig2_HuffmanTable(HuffmanTable_B7,
-                                                sizeof(HuffmanTable_B7) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B7));
+      Table_B7 = new CJBig2_HuffmanTable(HuffmanTable_B7,
+                                         FX_ArraySize(HuffmanTable_B7),
+                                         HuffmanTable_HTOOB_B7);
       pTRD->SBHUFFFS = Table_B7;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFFS can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFFS = pSeg->m_Result.ht;
     }
     if (cSBHUFFDS == 0) {
-      JBIG2_ALLOC(Table_B8, CJBig2_HuffmanTable(HuffmanTable_B8,
-                                                sizeof(HuffmanTable_B8) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B8));
+      Table_B8 = new CJBig2_HuffmanTable(HuffmanTable_B8,
+                                         FX_ArraySize(HuffmanTable_B8),
+                                         HuffmanTable_HTOOB_B8);
       pTRD->SBHUFFDS = Table_B8;
     } else if (cSBHUFFDS == 1) {
-      JBIG2_ALLOC(Table_B9, CJBig2_HuffmanTable(HuffmanTable_B9,
-                                                sizeof(HuffmanTable_B9) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B9));
+      Table_B9 = new CJBig2_HuffmanTable(HuffmanTable_B9,
+                                         FX_ArraySize(HuffmanTable_B9),
+                                         HuffmanTable_HTOOB_B9);
       pTRD->SBHUFFDS = Table_B9;
     } else if (cSBHUFFDS == 2) {
-      JBIG2_ALLOC(Table_B10, CJBig2_HuffmanTable(HuffmanTable_B10,
-                                                 sizeof(HuffmanTable_B10) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B10));
+      Table_B10 = new CJBig2_HuffmanTable(HuffmanTable_B10,
+                                          FX_ArraySize(HuffmanTable_B10),
+                                          HuffmanTable_HTOOB_B10);
       pTRD->SBHUFFDS = Table_B10;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFDS can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFDS = pSeg->m_Result.ht;
     }
     if (cSBHUFFDT == 0) {
-      JBIG2_ALLOC(Table_B11, CJBig2_HuffmanTable(HuffmanTable_B11,
-                                                 sizeof(HuffmanTable_B11) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B11));
+      Table_B11 = new CJBig2_HuffmanTable(HuffmanTable_B11,
+                                          FX_ArraySize(HuffmanTable_B11),
+                                          HuffmanTable_HTOOB_B11);
       pTRD->SBHUFFDT = Table_B11;
     } else if (cSBHUFFDT == 1) {
-      JBIG2_ALLOC(Table_B12, CJBig2_HuffmanTable(HuffmanTable_B12,
-                                                 sizeof(HuffmanTable_B12) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B12));
+      Table_B12 = new CJBig2_HuffmanTable(HuffmanTable_B12,
+                                          FX_ArraySize(HuffmanTable_B12),
+                                          HuffmanTable_HTOOB_B12);
       pTRD->SBHUFFDT = Table_B12;
     } else if (cSBHUFFDT == 2) {
-      JBIG2_ALLOC(Table_B13, CJBig2_HuffmanTable(HuffmanTable_B13,
-                                                 sizeof(HuffmanTable_B13) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B13));
+      Table_B13 = new CJBig2_HuffmanTable(HuffmanTable_B13,
+                                          FX_ArraySize(HuffmanTable_B13),
+                                          HuffmanTable_HTOOB_B13);
       pTRD->SBHUFFDT = Table_B13;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFDT can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFDT = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDW == 0) {
-      JBIG2_ALLOC(Table_B14, CJBig2_HuffmanTable(HuffmanTable_B14,
-                                                 sizeof(HuffmanTable_B14) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B14));
+      Table_B14 = new CJBig2_HuffmanTable(HuffmanTable_B14,
+                                          FX_ArraySize(HuffmanTable_B14),
+                                          HuffmanTable_HTOOB_B14);
       pTRD->SBHUFFRDW = Table_B14;
     } else if (cSBHUFFRDW == 1) {
-      JBIG2_ALLOC(Table_B15, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                 sizeof(HuffmanTable_B15) /
-                                                     sizeof(JBig2TableLine),
-                                                 HuffmanTable_HTOOB_B15));
+      Table_B15 = new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                          FX_ArraySize(HuffmanTable_B15),
+                                          HuffmanTable_HTOOB_B15);
       pTRD->SBHUFFRDW = Table_B15;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFRDW can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFRDW = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDH == 0) {
       if (!Table_B14) {
-        JBIG2_ALLOC(Table_B14, CJBig2_HuffmanTable(HuffmanTable_B14,
-                                                   sizeof(HuffmanTable_B14) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B14));
+        Table_B14 = new CJBig2_HuffmanTable(HuffmanTable_B14,
+                                            FX_ArraySize(HuffmanTable_B14),
+                                            HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDH = Table_B14;
     } else if (cSBHUFFRDH == 1) {
       if (!Table_B15) {
-        JBIG2_ALLOC(Table_B15, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                   sizeof(HuffmanTable_B15) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B15));
+        Table_B15 = new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                            FX_ArraySize(HuffmanTable_B15),
+                                            HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDH = Table_B15;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFRDH can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFRDH = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDX == 0) {
       if (!Table_B14) {
-        JBIG2_ALLOC(Table_B14, CJBig2_HuffmanTable(HuffmanTable_B14,
-                                                   sizeof(HuffmanTable_B14) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B14));
+        Table_B14 = new CJBig2_HuffmanTable(HuffmanTable_B14,
+                                            FX_ArraySize(HuffmanTable_B14),
+                                            HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDX = Table_B14;
     } else if (cSBHUFFRDX == 1) {
       if (!Table_B15) {
-        JBIG2_ALLOC(Table_B15, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                   sizeof(HuffmanTable_B15) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B15));
+        Table_B15 = new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                            FX_ArraySize(HuffmanTable_B15),
+                                            HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDX = Table_B15;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFRDX can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFRDX = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDY == 0) {
       if (!Table_B14) {
-        JBIG2_ALLOC(Table_B14, CJBig2_HuffmanTable(HuffmanTable_B14,
-                                                   sizeof(HuffmanTable_B14) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B14));
+        Table_B14 = new CJBig2_HuffmanTable(HuffmanTable_B14,
+                                            FX_ArraySize(HuffmanTable_B14),
+                                            HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDY = Table_B14;
     } else if (cSBHUFFRDY == 1) {
       if (!Table_B15) {
-        JBIG2_ALLOC(Table_B15, CJBig2_HuffmanTable(HuffmanTable_B15,
-                                                   sizeof(HuffmanTable_B15) /
-                                                       sizeof(JBig2TableLine),
-                                                   HuffmanTable_HTOOB_B15));
+        Table_B15 = new CJBig2_HuffmanTable(HuffmanTable_B15,
+                                            FX_ArraySize(HuffmanTable_B15),
+                                            HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDY = Table_B15;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFRDY can't find user supplied table");
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       pTRD->SBHUFFRDY = pSeg->m_Result.ht;
     }
     if (cSBHUFFRSIZE == 0) {
-      JBIG2_ALLOC(Table_B1, CJBig2_HuffmanTable(HuffmanTable_B1,
-                                                sizeof(HuffmanTable_B1) /
-                                                    sizeof(JBig2TableLine),
-                                                HuffmanTable_HTOOB_B1));
+      Table_B1 = new CJBig2_HuffmanTable(HuffmanTable_B1,
+                                         FX_ArraySize(HuffmanTable_B1),
+                                         HuffmanTable_HTOOB_B1);
       pTRD->SBHUFFRSIZE = Table_B1;
     } else {
       pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg) {
         m_pModule->JBig2_Error(
             "text region segment : SBHUFFRSIZE can't find user supplied table");
         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);
     JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
   }
   if (pTRD->SBHUFF == 0) {
-    JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+    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;
     }
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
     pSegment->m_Result.im = pTRD->decode_Huffman(m_pStream, grContext);
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   if (pSegment->m_cFlags.s.type != 4) {
     if (!m_bBufSpecified) {
-      JBig2PageInfo* pPageInfo = m_pPageInfoList->getLast();
+      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);
       }
     }
     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;
   }
@@ skipping 69 matching lines @@
   }
   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);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-    JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+    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);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pModule->JBig2_Free(gbContext);
     m_pStream->alignByte();
@@ skipping 65 matching lines @@
   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);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-    JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+    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);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pModule->JBig2_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();
   }
   if (pSegment->m_cFlags.s.type != 20) {
     if (!m_bBufSpecified) {
-      JBig2PageInfo* pPageInfo = m_pPageInfoList->getLast();
+      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);
       }
     }
     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;
   }
@@ skipping 53 matching lines @@
   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);
       JBIG2_memset(m_gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     }
     if (m_pArithDecoder == NULL) {
-      JBIG2_ALLOC(m_pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+      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_pPageInfoList->getLast();
+          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);
@@ skipping 21 matching lines @@
       m_pGRD->Continue_decode(pPause);
     }
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   if (pSegment->m_cFlags.s.type != 36) {
     if (!m_bBufSpecified) {
-      JBig2PageInfo* pPageInfo = m_pPageInfoList->getLast();
+      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);
@@ skipping 66 matching lines @@
     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);
   JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-  JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(m_pStream));
+  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);
     nRet = JBIG2_ERROR_FATAL;
     goto failed;
   }
   m_pModule->JBig2_Free(grContext);
   m_pStream->alignByte();
   m_pStream->offset(2);
   if (pSegment->m_cFlags.s.type != 40) {
     if (!m_bBufSpecified) {
-      JBig2PageInfo* pPageInfo = m_pPageInfoList->getLast();
+      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);
       }
     }
     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 pGRRD;
   return JBIG2_SUCCESS;
 failed:
   delete pGRRD;
   return nRet;
 }
 int32_t CJBig2_Context::parseTable(CJBig2_Segment* pSegment) {
   pSegment->m_nResultType = JBIG2_HUFFMAN_TABLE_POINTER;
-  JBIG2_ALLOC(pSegment->m_Result.ht, CJBig2_HuffmanTable(m_pStream));
+  pSegment->m_Result.ht = new CJBig2_HuffmanTable(m_pStream);
   if (!pSegment->m_Result.ht->isOK()) {
     delete pSegment->m_Result.ht;
     pSegment->m_Result.ht = NULL;
     return JBIG2_ERROR_FATAL;
   }
   m_pStream->alignByte();
   return JBIG2_SUCCESS;
 }
 int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo* pRI) {
   if ((m_pStream->readInteger((FX_DWORD*)&pRI->width) != 0) ||
@@ skipping 151 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   m_pModule->JBig2_Free(LENCOUNT);
   m_pModule->JBig2_Free(FIRSTCODE);
 }