Remove CJBig2_Module::JBig2_Error and friends.

core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "JBig2_GeneralDecoder.h"
 #include "JBig2_ArithDecoder.h"
 #include "JBig2_ArithIntDecoder.h"
 #include "JBig2_HuffmanDecoder.h"
@@ skipping 62 matching lines @@
   FX_DWORD CONTEXT;
   CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
   if (GBREG->m_pData == NULL) {
     delete GBREG;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     return NULL;
   }
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   FX_DWORD height = GBH & 0x7fffffff;
   for (FX_DWORD h = 0; h < height; h++) {
     if (TPGDON) {
@@ skipping 119 matching lines @@
   FX_DWORD CONTEXT;
   CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
   if (GBREG->m_pData == NULL) {
     delete GBREG;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     return NULL;
   }
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
@@ skipping 116 matching lines @@
   FX_DWORD CONTEXT;
   CJBig2_Image* GBREG;
   FX_DWORD line1, line2;
   uint8_t *pLine, *pLine1, *pLine2, cVal;
   int32_t nStride, nStride2, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
   if (GBREG->m_pData == NULL) {
     delete GBREG;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     return NULL;
   }
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nStride2 = nStride << 1;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
@@ skipping 114 matching lines @@
   FX_DWORD CONTEXT;
   CJBig2_Image* GBREG;
   FX_DWORD line1;
   uint8_t *pLine, *pLine1, cVal;
   int32_t nStride, k;
   int32_t nLineBytes, nBitsLeft, cc;
   LTP = 0;
   JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
   if (GBREG->m_pData == NULL) {
     delete GBREG;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     return NULL;
   }
   pLine = GBREG->m_pData;
   nStride = GBREG->m_nStride;
   nLineBytes = ((GBW + 7) >> 3) - 1;
   nBitsLeft = GBW - (nLineBytes << 3);
   for (FX_DWORD h = 0; h < GBH; h++) {
     if (TPGDON) {
       SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
       LTP = LTP ^ SLTP;
@@ skipping 238 matching lines @@
   intptr_t nStride, nStrideR, nOffset;
   int32_t k, nBits;
   int32_t GRWR, GRHR;
   int32_t GRW, GRH;
   GRW = (int32_t)CJBig2_GRRDProc::GRW;
   GRH = (int32_t)CJBig2_GRRDProc::GRH;
   LTP = 0;
   JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
   if (GRREG->m_pData == NULL) {
     delete GRREG;
-    m_pModule->JBig2_Error(
-        "Generic refinement region decoding procedure: Create Image Failed "
-        "with width = %d, height = %d\n",
-        GRW, GRH);
     return NULL;
   }
   pLine = GRREG->m_pData;
   pLineR = GRREFERENCE->m_pData;
   nStride = GRREG->m_nStride;
   nStrideR = GRREFERENCE->m_nStride;
   GRWR = (int32_t)GRREFERENCE->m_nWidth;
   GRHR = (int32_t)GRREFERENCE->m_nHeight;
   if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
     GRREFERENCEDY = 0;
@@ skipping 216 matching lines @@
   intptr_t nStride, nStrideR, nOffset;
   int32_t k, nBits;
   int32_t GRWR, GRHR;
   int32_t GRW, GRH;
   GRW = (int32_t)CJBig2_GRRDProc::GRW;
   GRH = (int32_t)CJBig2_GRRDProc::GRH;
   LTP = 0;
   JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
   if (GRREG->m_pData == NULL) {
     delete GRREG;
-    m_pModule->JBig2_Error(
-        "Generic refinement region decoding procedure: Create Image Failed "
-        "with width = %d, height = %d\n",
-        GRW, GRH);
     return NULL;
   }
   pLine = GRREG->m_pData;
   pLineR = GRREFERENCE->m_pData;
   nStride = GRREG->m_nStride;
   nStrideR = GRREFERENCE->m_nStride;
   GRWR = (int32_t)GRREFERENCE->m_nWidth;
   GRHR = (int32_t)GRREFERENCE->m_nHeight;
   if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
     GRREFERENCEDY = 0;
@@ skipping 117 matching lines @@
   CJBig2_Image* SBREG;
   FX_BOOL bFirst;
   FX_DWORD nTmp;
   int32_t nVal, nBits;
   CJBig2_GRRDProc* pGRRD;
   CJBig2_ArithDecoder* pArithDecoder;
   CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream);
   JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
   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;
   NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {
-      m_pModule->JBig2_Error(
-          "text region decoding procedure (huffman): too short.");
       goto failed;
     }
     DT *= SBSTRIPS;
     STRIPT = STRIPT + DT;
     bFirst = TRUE;
     for (;;) {
       if (bFirst) {
         if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         }
         FIRSTS = FIRSTS + DFS;
         CURS = FIRSTS;
         bFirst = FALSE;
       } else {
         nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
         if (nVal == JBIG2_OOB) {
           break;
         } else if (nVal != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         } else {
           CURS = CURS + IDS + SBDSOFFSET;
         }
       }
       if (SBSTRIPS == 1) {
         CURT = 0;
       } else {
         nTmp = 1;
         while ((FX_DWORD)(1 << nTmp) < SBSTRIPS) {
           nTmp++;
         }
         if (pStream->readNBits(nTmp, &nVal) != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         }
         CURT = nVal;
       }
       TI = STRIPT + CURT;
       nVal = 0;
       nBits = 0;
       for (;;) {
         if (pStream->read1Bit(&nTmp) != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         }
         nVal = (nVal << 1) | nTmp;
         nBits++;
         for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
           if ((nBits == SBSYMCODES[IDI].codelen) &&
               (nVal == SBSYMCODES[IDI].code)) {
             break;
           }
         }
         if (IDI < SBNUMSYMS) {
           break;
         }
       }
       if (SBREFINE == 0) {
         RI = 0;
       } else {
         if (pStream->read1Bit(&RI) != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         }
       }
       if (RI == 0) {
         IBI = SBSYMS[IDI];
       } else {
         if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): too short.");
           goto failed;
         }
         pStream->alignByte();
         nTmp = pStream->getOffset();
         IBOI = SBSYMS[IDI];
         if (!IBOI) {
           goto failed;
         }
         WOI = IBOI->m_nWidth;
         HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman): Invalid RDWI or RDHI "
-              "value.");
           goto failed;
         }
         JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
         pGRRD->TPGRON = 0;
         pGRRD->GRAT[0] = SBRAT[0];
         pGRRD->GRAT[1] = SBRAT[1];
         pGRRD->GRAT[2] = SBRAT[2];
         pGRRD->GRAT[3] = SBRAT[3];
         pArithDecoder = new CJBig2_ArithDecoder(pStream);
         IBI = pGRRD->decode(pArithDecoder, grContext);
         if (IBI == NULL) {
           delete pGRRD;
           delete pArithDecoder;
           goto failed;
         }
         delete pArithDecoder;
         pStream->alignByte();
         pStream->offset(2);
         if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
           delete IBI;
           delete pGRRD;
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (huffman):"
-              "bytes processed by generic refinement region decoding procedure "
-              "doesn't equal SBHUFFRSIZE.");
           goto failed;
         }
         delete pGRRD;
       }
       if (!IBI) {
         continue;
       }
       WI = IBI->m_nWidth;
       HI = IBI->m_nHeight;
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
@@ skipping 100 matching lines @@
     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;
   STRIPT = -STRIPT;
   FIRSTS = 0;
   NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     if (IADT->decode(pArithDecoder, &DT) == -1) {
-      m_pModule->JBig2_Error(
-          "text region decoding procedure (arith): too short.");
       goto failed;
     }
     DT *= SBSTRIPS;
     STRIPT = STRIPT + DT;
     bFirst = TRUE;
     for (;;) {
       if (bFirst) {
         if (IAFS->decode(pArithDecoder, &DFS) == -1) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): too short.");
           goto failed;
         }
         FIRSTS = FIRSTS + DFS;
         CURS = FIRSTS;
         bFirst = FALSE;
       } else {
         nRet = IADS->decode(pArithDecoder, &IDS);
         if (nRet == JBIG2_OOB) {
           break;
         } else if (nRet != 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): too short.");
           goto failed;
         } else {
           CURS = CURS + IDS + SBDSOFFSET;
         }
       }
       if (NINSTANCES >= SBNUMINSTANCES) {
         break;
       }
       if (SBSTRIPS == 1) {
         CURT = 0;
       } else {
         if (IAIT->decode(pArithDecoder, &nVal) == -1) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): too short.");
           goto failed;
         }
         CURT = nVal;
       }
       TI = STRIPT + CURT;
       if (IAID->decode(pArithDecoder, &nVal) == -1) {
-        m_pModule->JBig2_Error(
-            "text region decoding procedure (arith): too short.");
         goto failed;
       }
       IDI = nVal;
       if (IDI >= SBNUMSYMS) {
-        m_pModule->JBig2_Error(
-            "text region decoding procedure (arith): symbol id out of "
-            "range.(%d/%d)",
-            IDI, SBNUMSYMS);
         goto failed;
       }
       if (SBREFINE == 0) {
         RI = 0;
       } else {
         if (IARI->decode(pArithDecoder, &RI) == -1) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): too short.");
           goto failed;
         }
       }
       if (!SBSYMS[IDI]) {
         goto failed;
       }
       if (RI == 0) {
         IBI = SBSYMS[IDI];
       } else {
         if ((IARDW->decode(pArithDecoder, &RDWI) == -1) ||
             (IARDH->decode(pArithDecoder, &RDHI) == -1) ||
             (IARDX->decode(pArithDecoder, &RDXI) == -1) ||
             (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): too short.");
           goto failed;
         }
         IBOI = SBSYMS[IDI];
         WOI = IBOI->m_nWidth;
         HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
-          m_pModule->JBig2_Error(
-              "text region decoding procedure (arith): Invalid RDWI or RDHI "
-              "value.");
           goto failed;
         }
         JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
         pGRRD->TPGRON = 0;
@@ skipping 140 matching lines @@
   }
   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.");
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
     if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (arith): invalid HCHEIGHT "
-          "value.");
       goto failed;
     }
     SYMWIDTH = 0;
     TOTWIDTH = 0;
     for (;;) {
       nVal = IADW->decode(pArithDecoder, &DW);
       if (nVal == JBIG2_OOB) {
         break;
       } else if (nVal != 0) {
-        m_pModule->JBig2_Error(
-            "symbol dictionary decoding procedure (arith): too short.");
         goto failed;
       } else {
         if (NSYMSDECODED >= SDNUMNEWSYMS) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (arith): NSYMSDECODED >= "
-              "SDNUMNEWSYMS.");
           goto failed;
         }
         SYMWIDTH = SYMWIDTH + DW;
         if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (arith): invalid SYMWIDTH "
-              "value.");
           goto failed;
         } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
           TOTWIDTH = TOTWIDTH + SYMWIDTH;
           SDNEWSYMS[NSYMSDECODED] = NULL;
           NSYMSDECODED = NSYMSDECODED + 1;
           continue;
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 0) {
@@ skipping 13 matching lines @@
         pGRD->GBAT[6] = SDAT[6];
         pGRD->GBAT[7] = SDAT[7];
         BS = pGRD->decode_Arith(pArithDecoder, gbContext);
         if (BS == NULL) {
           delete pGRD;
           goto failed;
         }
         delete pGRD;
       } else {
         if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (arith): too short.");
           goto failed;
         }
         if (REFAGGNINST > 1) {
           CJBig2_TRDProc* pDecoder;
           JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
           pDecoder->SBNUMINSTANCES = REFAGGNINST;
@@ skipping 85 matching lines @@
           delete SBHUFFDT;
           delete SBHUFFRDW;
           delete SBHUFFRDH;
           delete SBHUFFRDX;
           delete SBHUFFRDY;
           delete SBHUFFRSIZE;
           delete pDecoder;
         } else if (REFAGGNINST == 1) {
           SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) {
-            m_pModule->JBig2_Error(
-                "symbol dictionary decoding procedure (arith): too short.");
             goto failed;
           }
           if ((IARDX->decode(pArithDecoder, &RDXI) == -1) ||
               (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
-            m_pModule->JBig2_Error(
-                "symbol dictionary decoding procedure (arith): too short.");
             goto failed;
           }
           if (IDI >= SBNUMSYMS) {
-            m_pModule->JBig2_Error(
-                "symbol dictionary decoding procedure (arith):"
-                " refinement references unknown symbol %d",
-                IDI);
             goto failed;
           }
           SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
               SBNUMSYMS, sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           if (!SBSYMS[IDI]) {
             m_pModule->JBig2_Free(SBSYMS);
             goto failed;
@@ skipping 25 matching lines @@
       NSYMSDECODED = NSYMSDECODED + 1;
     }
   }
   EXINDEX = 0;
   CUREXFLAG = 0;
   EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
                                                (SDNUMINSYMS + SDNUMNEWSYMS));
   while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
     if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
       m_pModule->JBig2_Free(EXFLAGS);
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (arith): too short.");
       goto failed;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
       m_pModule->JBig2_Free(EXFLAGS);
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "
-          "value.");
       goto failed;
     }
     if (EXRUNLENGTH != 0) {
       for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
         EXFLAGS[I] = CUREXFLAG;
       }
     }
     EXINDEX = EXINDEX + EXRUNLENGTH;
     CUREXFLAG = !CUREXFLAG;
   }
@@ skipping 100 matching lines @@
   if (SDREFAGG == 0) {
     SDNEWSYMWIDTHS =
         (FX_DWORD*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD));
     FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
   }
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   BS = NULL;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (huffman): too short.");
       goto failed;
     }
     HCHEIGHT = HCHEIGHT + HCDH;
     if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (huffman): invalid HCHEIGHT "
-          "value.");
       goto failed;
     }
     SYMWIDTH = 0;
     TOTWIDTH = 0;
     HCFIRSTSYM = NSYMSDECODED;
     for (;;) {
       nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW);
       if (nVal == JBIG2_OOB) {
         break;
       } else if (nVal != 0) {
-        m_pModule->JBig2_Error(
-            "symbol dictionary decoding procedure (huffman): too short.");
         goto failed;
       } else {
         if (NSYMSDECODED >= SDNUMNEWSYMS) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (huffman): NSYMSDECODED >= "
-              "SDNUMNEWSYMS.");
           goto failed;
         }
         SYMWIDTH = SYMWIDTH + DW;
         if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (huffman): invalid "
-              "SYMWIDTH value.");
           goto failed;
         } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
           TOTWIDTH = TOTWIDTH + SYMWIDTH;
           SDNEWSYMS[NSYMSDECODED] = NULL;
           NSYMSDECODED = NSYMSDECODED + 1;
           continue;
         }
         TOTWIDTH = TOTWIDTH + SYMWIDTH;
       }
       if (SDREFAGG == 1) {
         if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) !=
             0) {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (huffman): too short.");
           goto failed;
         }
         BS = NULL;
         if (REFAGGNINST > 1) {
           CJBig2_TRDProc* pDecoder;
           JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
@@ skipping 97 matching lines @@
               SBNUMSYMS, sizeof(JBig2HuffmanCode));
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = SBSYMCODELEN;
             SBSYMCODES[I].code = I;
           }
           nVal = 0;
           nBits = 0;
           for (;;) {
             if (pStream->read1Bit(&nTmp) != 0) {
               m_pModule->JBig2_Free(SBSYMCODES);
-              m_pModule->JBig2_Error(
-                  "symbol dictionary decoding procedure (huffman): too short.");
               goto failed;
             }
             nVal = (nVal << 1) | nTmp;
             for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
               if ((nVal == SBSYMCODES[IDI].code) &&
                   (nBits == SBSYMCODES[IDI].codelen)) {
                 break;
               }
             }
             if (IDI < SBNUMSYMS) {
               break;
             }
           }
           m_pModule->JBig2_Free(SBSYMCODES);
           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;
           delete SBHUFFRSIZE;
           pStream->alignByte();
           nTmp = pStream->getOffset();
           SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
               SBNUMSYMS, sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
@@ skipping 18 matching lines @@
             delete pArithDecoder;
             goto failed;
           }
           pStream->alignByte();
           pStream->offset(2);
           if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
             delete BS;
             m_pModule->JBig2_Free(SBSYMS);
             delete pGRRD;
             delete pArithDecoder;
-            m_pModule->JBig2_Error(
-                "symbol dictionary decoding procedure (huffman):"
-                "bytes processed by generic refinement region decoding "
-                "procedure doesn't equal SBHUFFRSIZE.");
             goto failed;
           }
           m_pModule->JBig2_Free(SBSYMS);
           delete pGRRD;
           delete pArithDecoder;
         }
         SDNEWSYMS[NSYMSDECODED] = BS;
       }
       if (SDREFAGG == 0) {
         SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;
       }
       NSYMSDECODED = NSYMSDECODED + 1;
     }
     if (SDREFAGG == 0) {
       if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) {
-        m_pModule->JBig2_Error(
-            "symbol dictionary decoding procedure (huffman): too short.");
         goto failed;
       }
       pStream->alignByte();
       if (BMSIZE == 0) {
         stride = (TOTWIDTH + 7) >> 3;
         if (pStream->getByteLeft() >= stride * HCHEIGHT) {
           JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT));
           for (I = 0; I < HCHEIGHT; I++) {
             JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride,
                          pStream->getPointer(), stride);
             pStream->offset(stride);
           }
         } else {
-          m_pModule->JBig2_Error(
-              "symbol dictionary decoding procedure (huffman): too short.");
           goto failed;
         }
       } else {
         JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
         pGRD->MMR = 1;
         pGRD->GBW = TOTWIDTH;
         pGRD->GBH = HCHEIGHT;
         FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);
         while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
           pGRD->Continue_decode(pPause);
@@ skipping 16 matching lines @@
   EXINDEX = 0;
   CUREXFLAG = 0;
   pTable = new CJBig2_HuffmanTable(
       HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1);
   EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
                                                (SDNUMINSYMS + SDNUMNEWSYMS));
   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;
     }
     if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
       delete pTable;
       m_pModule->JBig2_Free(EXFLAGS);
-      m_pModule->JBig2_Error(
-          "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "
-          "value.");
       goto failed;
     }
     if (EXRUNLENGTH != 0) {
       for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
         EXFLAGS[I] = CUREXFLAG;
       }
     }
     EXINDEX = EXINDEX + EXRUNLENGTH;
     CUREXFLAG = !CUREXFLAG;
   }
@@ skipping 395 matching lines @@
     return FXCODEC_STATUS_DECODE_FINISH;
   }
   m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
   m_pPause = pPause;
   if (*pImage == NULL) {
     JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
   }
   if ((*pImage)->m_pData == NULL) {
     delete *pImage;
     *pImage = NULL;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return FXCODEC_STATUS_ERROR;
   }
   m_DecodeType = 1;
   m_pImage = pImage;
   (*m_pImage)->fill(0);
   m_pArithDecoder = pArithDecoder;
   m_gbContext = gbContext;
   LTP = 0;
   m_pLine = NULL;
@@ skipping 48 matching lines @@
   return m_ProssiveStatus;
 }
 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage,
                                                 CJBig2_BitStream* pStream,
                                                 IFX_Pause* pPause) {
   int bitpos, i;
   JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
   if ((*pImage)->m_pData == NULL) {
     delete (*pImage);
     (*pImage) = NULL;
-    m_pModule->JBig2_Error(
-        "Generic region decoding procedure: Create Image Failed with width = "
-        "%d, height = %d\n",
-        GBW, GBH);
     m_ProssiveStatus = FXCODEC_STATUS_ERROR;
     return m_ProssiveStatus;
   }
   bitpos = (int)pStream->getBitPos();
   _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos,
                (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride);
   pStream->setBitPos(bitpos);
   for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) {
     (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i];
   }
@@ skipping 564 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;
 }