// 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 "core/fxcodec/jbig2/JBig2_Context.h" #include <algorithm> #include <list> #include <utility> #include <vector> #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h" #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h" #include "core/fxcodec/jbig2/JBig2_ArithDecoder.h" #include "core/fxcodec/jbig2/JBig2_BitStream.h" #include "core/fxcodec/jbig2/JBig2_GrdProc.h" #include "core/fxcodec/jbig2/JBig2_GrrdProc.h" #include "core/fxcodec/jbig2/JBig2_HtrdProc.h" #include "core/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h" #include "core/fxcodec/jbig2/JBig2_PddProc.h" #include "core/fxcodec/jbig2/JBig2_SddProc.h" #include "core/fxcodec/jbig2/JBig2_TrdProc.h" #include "third_party/base/stl_util.h" namespace { size_t GetHuffContextSize(uint8_t val) { return val == 0 ? 65536 : val == 1 ? 8192 : 1024; } size_t GetRefAggContextSize(FX_BOOL val) { return val ? 1024 : 8192; } } // namespace // 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. static const int kSymbolDictCacheMaxSize = 2; CJBig2_Context* CJBig2_Context::CreateContext( CPDF_StreamAcc* pGlobalStream, CPDF_StreamAcc* pSrcStream, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause) { return new CJBig2_Context(pGlobalStream, pSrcStream, pSymbolDictCache, pPause, false); } void CJBig2_Context::DestroyContext(CJBig2_Context* pContext) { delete pContext; } CJBig2_Context::CJBig2_Context(CPDF_StreamAcc* pGlobalStream, CPDF_StreamAcc* pSrcStream, std::list<CJBig2_CachePair>* pSymbolDictCache, IFX_Pause* pPause, bool bIsGlobal) : m_nSegmentDecoded(0), m_bInPage(false), m_bBufSpecified(false), m_PauseStep(10), m_pPause(pPause), m_ProcessingStatus(FXCODEC_STATUS_FRAME_READY), m_gbContext(NULL), m_dwOffset(0), m_pSymbolDictCache(pSymbolDictCache), m_bIsGlobal(bIsGlobal) { if (pGlobalStream && (pGlobalStream->GetSize() > 0)) { m_pGlobalContext = new CJBig2_Context(nullptr, pGlobalStream, pSymbolDictCache, pPause, true); } else { m_pGlobalContext = nullptr; } m_pStream.reset(new CJBig2_BitStream(pSrcStream)); } CJBig2_Context::~CJBig2_Context() { FX_Free(m_gbContext); m_gbContext = NULL; delete m_pGlobalContext; m_pGlobalContext = NULL; } int32_t CJBig2_Context::decode_SquentialOrgnazation(IFX_Pause* pPause) { int32_t nRet; 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_dwOffset = m_pStream->getOffset(); } nRet = parseSegmentData(m_pSegment.get(), pPause); if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) { m_ProcessingStatus = 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_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_ProcessingStatus = 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) { int32_t nRet; while (m_pStream->getByteLeft() > JBIG2_MIN_SEGMENT_SIZE) { std::unique_ptr<CJBig2_Segment> pSegment(new CJBig2_Segment); nRet = parseSegmentHeader(pSegment.get()); if (nRet != JBIG2_SUCCESS) { return nRet; } else if (pSegment->m_cFlags.s.type == 51) { break; } m_SegmentList.push_back(pSegment.release()); if (pPause && m_pPause && pPause->NeedToPauseNow()) { m_PauseStep = 3; m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; return JBIG2_SUCCESS; } } m_nSegmentDecoded = 0; return decode_RandomOrgnazation(pPause); } int32_t CJBig2_Context::decode_RandomOrgnazation(IFX_Pause* pPause) { 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_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; return JBIG2_SUCCESS; } } return JBIG2_SUCCESS; } int32_t CJBig2_Context::getFirstPage(uint8_t* pBuf, int32_t width, int32_t height, int32_t stride, IFX_Pause* pPause) { int32_t nRet = 0; if (m_pGlobalContext) { nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause); if (nRet != JBIG2_SUCCESS) { m_ProcessingStatus = FXCODEC_STATUS_ERROR; return nRet; } } m_PauseStep = 0; m_pPage.reset(new CJBig2_Image(width, height, stride, pBuf)); m_bBufSpecified = true; if (pPause && pPause->NeedToPauseNow()) { m_PauseStep = 1; m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; return nRet; } return Continue(pPause); } int32_t CJBig2_Context::Continue(IFX_Pause* pPause) { m_ProcessingStatus = FXCODEC_STATUS_DECODE_READY; int32_t nRet = 0; if (m_PauseStep <= 1) { nRet = decode_EmbedOrgnazation(pPause); } else if (m_PauseStep == 2) { nRet = decode_SquentialOrgnazation(pPause); } else if (m_PauseStep == 3) { nRet = decode_RandomOrgnazation_FirstPage(pPause); } else if (m_PauseStep == 4) { nRet = decode_RandomOrgnazation(pPause); } else if (m_PauseStep == 5) { m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH; return JBIG2_SUCCESS; } if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) { return nRet; } m_PauseStep = 5; if (!m_bBufSpecified && nRet == JBIG2_SUCCESS) { m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH; return JBIG2_SUCCESS; } if (nRet == JBIG2_SUCCESS) { m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH; } else { m_ProcessingStatus = FXCODEC_STATUS_ERROR; } return nRet; } CJBig2_Segment* CJBig2_Context::findSegmentByNumber(uint32_t dwNumber) { if (m_pGlobalContext) { CJBig2_Segment* pSeg = m_pGlobalContext->findSegmentByNumber(dwNumber); if (pSeg) { return pSeg; } } for (size_t i = 0; i < m_SegmentList.size(); ++i) { CJBig2_Segment* pSeg = m_SegmentList.get(i); if (pSeg->m_dwNumber == dwNumber) { return pSeg; } } return nullptr; } CJBig2_Segment* CJBig2_Context::findReferredSegmentByTypeAndIndex( CJBig2_Segment* pSegment, uint8_t cType, int32_t nIndex) { int32_t count = 0; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); if (pSeg && pSeg->m_cFlags.s.type == cType) { if (count == nIndex) return pSeg; ++count; } } return NULL; } int32_t CJBig2_Context::parseSegmentHeader(CJBig2_Segment* pSegment) { if (m_pStream->readInteger(&pSegment->m_dwNumber) != 0 || m_pStream->read1Byte(&pSegment->m_cFlags.c) != 0) { return JBIG2_ERROR_TOO_SHORT; } uint32_t dwTemp; uint8_t cTemp = m_pStream->getCurByte(); if ((cTemp >> 5) == 7) { if (m_pStream->readInteger( (uint32_t*)&pSegment->m_nReferred_to_segment_count) != 0) { return JBIG2_ERROR_TOO_SHORT; } pSegment->m_nReferred_to_segment_count &= 0x1fffffff; if (pSegment->m_nReferred_to_segment_count > JBIG2_MAX_REFERRED_SEGMENT_COUNT) { return JBIG2_ERROR_LIMIT; } dwTemp = 5 + 4 + (pSegment->m_nReferred_to_segment_count + 1) / 8; } else { if (m_pStream->read1Byte(&cTemp) != 0) return JBIG2_ERROR_TOO_SHORT; pSegment->m_nReferred_to_segment_count = cTemp >> 5; dwTemp = 5 + 1; } uint8_t cSSize = pSegment->m_dwNumber > 65536 ? 4 : pSegment->m_dwNumber > 256 ? 2 : 1; uint8_t cPSize = pSegment->m_cFlags.s.page_association_size ? 4 : 1; if (pSegment->m_nReferred_to_segment_count) { pSegment->m_pReferred_to_segment_numbers = FX_Alloc(uint32_t, 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) return JBIG2_ERROR_TOO_SHORT; pSegment->m_pReferred_to_segment_numbers[i] = cTemp; break; case 2: uint16_t wTemp; if (m_pStream->readShortInteger(&wTemp) != 0) return JBIG2_ERROR_TOO_SHORT; pSegment->m_pReferred_to_segment_numbers[i] = wTemp; break; case 4: if (m_pStream->readInteger(&dwTemp) != 0) return JBIG2_ERROR_TOO_SHORT; pSegment->m_pReferred_to_segment_numbers[i] = dwTemp; break; } if (pSegment->m_pReferred_to_segment_numbers[i] >= pSegment->m_dwNumber) return JBIG2_ERROR_TOO_SHORT; } } if (cPSize == 1) { if (m_pStream->read1Byte(&cTemp) != 0) return JBIG2_ERROR_TOO_SHORT; pSegment->m_dwPage_association = cTemp; } else { if (m_pStream->readInteger(&pSegment->m_dwPage_association) != 0) { return JBIG2_ERROR_TOO_SHORT; } } if (m_pStream->readInteger(&pSegment->m_dwData_length) != 0) return JBIG2_ERROR_TOO_SHORT; pSegment->m_dwObjNum = m_pStream->getObjNum(); pSegment->m_dwDataOffset = m_pStream->getOffset(); pSegment->m_State = JBIG2_SEGMENT_DATA_UNPARSED; return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseSegmentData(CJBig2_Segment* pSegment, IFX_Pause* pPause) { int32_t ret = ProcessingParseSegmentData(pSegment, pPause); while (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE && m_pStream->getByteLeft() > 0) { ret = ProcessingParseSegmentData(pSegment, pPause); } return ret; } int32_t CJBig2_Context::ProcessingParseSegmentData(CJBig2_Segment* pSegment, IFX_Pause* pPause) { switch (pSegment->m_cFlags.s.type) { case 0: return parseSymbolDict(pSegment, pPause); case 4: case 6: case 7: if (!m_bInPage) return JBIG2_ERROR_FATAL; return parseTextRegion(pSegment); case 16: return parsePatternDict(pSegment, pPause); case 20: case 22: case 23: if (!m_bInPage) return JBIG2_ERROR_FATAL; return parseHalftoneRegion(pSegment, pPause); case 36: case 38: case 39: if (!m_bInPage) return JBIG2_ERROR_FATAL; return parseGenericRegion(pSegment, pPause); case 40: case 42: case 43: if (!m_bInPage) return JBIG2_ERROR_FATAL; return parseGenericRefinementRegion(pSegment); case 48: { uint16_t wTemp; std::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) { return JBIG2_ERROR_TOO_SHORT; } pPageInfo->m_bIsStriped = !!(wTemp & 0x8000); pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff; bool bMaxHeight = (pPageInfo->m_dwHeight == 0xffffffff); if (bMaxHeight && pPageInfo->m_bIsStriped != TRUE) pPageInfo->m_bIsStriped = TRUE; if (!m_bBufSpecified) { uint32_t height = bMaxHeight ? pPageInfo->m_wMaxStripeSize : pPageInfo->m_dwHeight; m_pPage.reset(new CJBig2_Image(pPageInfo->m_dwWidth, height)); } if (!m_pPage->m_pData) { m_ProcessingStatus = FXCODEC_STATUS_ERROR; return JBIG2_ERROR_TOO_SHORT; } m_pPage->fill((pPageInfo->m_cFlags & 4) ? 1 : 0); m_PageInfoList.push_back(pPageInfo.release()); m_bInPage = true; } break; case 49: m_bInPage = false; return JBIG2_END_OF_PAGE; break; case 50: m_pStream->offset(pSegment->m_dwData_length); break; case 51: return JBIG2_END_OF_FILE; case 52: m_pStream->offset(pSegment->m_dwData_length); break; case 53: return parseTable(pSegment); case 62: m_pStream->offset(pSegment->m_dwData_length); break; default: break; } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment* pSegment, IFX_Pause* pPause) { uint16_t wFlags; if (m_pStream->readShortInteger(&wFlags) != 0) return JBIG2_ERROR_TOO_SHORT; std::unique_ptr<CJBig2_SDDProc> pSymbolDictDecoder(new CJBig2_SDDProc); pSymbolDictDecoder->SDHUFF = wFlags & 0x0001; pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001; pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003; pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003; uint8_t cSDHUFFDH = (wFlags >> 2) & 0x0003; uint8_t cSDHUFFDW = (wFlags >> 4) & 0x0003; uint8_t cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001; uint8_t cSDHUFFAGGINST = (wFlags >> 7) & 0x0001; if (pSymbolDictDecoder->SDHUFF == 0) { const uint32_t dwTemp = (pSymbolDictDecoder->SDTEMPLATE == 0) ? 8 : 2; for (uint32_t i = 0; i < dwTemp; ++i) { if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDAT[i]) != 0) return JBIG2_ERROR_TOO_SHORT; } } if (pSymbolDictDecoder->SDREFAGG == 1 && pSymbolDictDecoder->SDRTEMPLATE == 0) { for (int32_t i = 0; i < 4; ++i) { if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDRAT[i]) != 0) return JBIG2_ERROR_TOO_SHORT; } } if (m_pStream->readInteger(&pSymbolDictDecoder->SDNUMEXSYMS) != 0 || m_pStream->readInteger(&pSymbolDictDecoder->SDNUMNEWSYMS) != 0) { return JBIG2_ERROR_TOO_SHORT; } if (pSymbolDictDecoder->SDNUMEXSYMS > JBIG2_MAX_EXPORT_SYSMBOLS || pSymbolDictDecoder->SDNUMNEWSYMS > JBIG2_MAX_NEW_SYSMBOLS) { return JBIG2_ERROR_LIMIT; } for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { if (!findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i])) return JBIG2_ERROR_FATAL; } CJBig2_Segment* pLRSeg = nullptr; pSymbolDictDecoder->SDNUMINSYMS = 0; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); if (pSeg->m_cFlags.s.type == 0) { pSymbolDictDecoder->SDNUMINSYMS += pSeg->m_Result.sd->NumImages(); pLRSeg = pSeg; } } std::unique_ptr<CJBig2_Image*, FxFreeDeleter> SDINSYMS; if (pSymbolDictDecoder->SDNUMINSYMS != 0) { SDINSYMS.reset(FX_Alloc(CJBig2_Image*, pSymbolDictDecoder->SDNUMINSYMS)); uint32_t dwTemp = 0; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); if (pSeg->m_cFlags.s.type == 0) { const CJBig2_SymbolDict& dict = *pSeg->m_Result.sd; for (size_t j = 0; j < dict.NumImages(); ++j) SDINSYMS.get()[dwTemp + j] = dict.GetImage(j); dwTemp += dict.NumImages(); } } } pSymbolDictDecoder->SDINSYMS = SDINSYMS.get(); std::unique_ptr<CJBig2_HuffmanTable> Table_B1; std::unique_ptr<CJBig2_HuffmanTable> Table_B2; std::unique_ptr<CJBig2_HuffmanTable> Table_B3; std::unique_ptr<CJBig2_HuffmanTable> Table_B4; std::unique_ptr<CJBig2_HuffmanTable> Table_B5; if (pSymbolDictDecoder->SDHUFF == 1) { if (cSDHUFFDH == 2 || cSDHUFFDW == 2) return JBIG2_ERROR_FATAL; int32_t nIndex = 0; if (cSDHUFFDH == 0) { Table_B4.reset(new CJBig2_HuffmanTable( HuffmanTable_B4, HuffmanTable_B4_Size, HuffmanTable_HTOOB_B4)); pSymbolDictDecoder->SDHUFFDH = Table_B4.get(); } else if (cSDHUFFDH == 1) { Table_B5.reset(new CJBig2_HuffmanTable( HuffmanTable_B5, HuffmanTable_B5_Size, HuffmanTable_HTOOB_B5)); pSymbolDictDecoder->SDHUFFDH = Table_B5.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pSymbolDictDecoder->SDHUFFDH = pSeg->m_Result.ht; } if (cSDHUFFDW == 0) { Table_B2.reset(new CJBig2_HuffmanTable( HuffmanTable_B2, HuffmanTable_B2_Size, HuffmanTable_HTOOB_B2)); pSymbolDictDecoder->SDHUFFDW = Table_B2.get(); } else if (cSDHUFFDW == 1) { Table_B3.reset(new CJBig2_HuffmanTable( HuffmanTable_B3, HuffmanTable_B3_Size, HuffmanTable_HTOOB_B3)); pSymbolDictDecoder->SDHUFFDW = Table_B3.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pSymbolDictDecoder->SDHUFFDW = pSeg->m_Result.ht; } if (cSDHUFFBMSIZE == 0) { Table_B1.reset(new CJBig2_HuffmanTable( HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1)); pSymbolDictDecoder->SDHUFFBMSIZE = Table_B1.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pSymbolDictDecoder->SDHUFFBMSIZE = pSeg->m_Result.ht; } if (pSymbolDictDecoder->SDREFAGG == 1) { if (cSDHUFFAGGINST == 0) { if (!Table_B1) { Table_B1.reset(new CJBig2_HuffmanTable( HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1)); } pSymbolDictDecoder->SDHUFFAGGINST = Table_B1.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pSymbolDictDecoder->SDHUFFAGGINST = pSeg->m_Result.ht; } } } const bool bUseGbContext = (pSymbolDictDecoder->SDHUFF == 0); const bool bUseGrContext = (pSymbolDictDecoder->SDREFAGG == 1); const size_t gbContextSize = GetHuffContextSize(pSymbolDictDecoder->SDTEMPLATE); const size_t grContextSize = GetRefAggContextSize(pSymbolDictDecoder->SDRTEMPLATE); std::vector<JBig2ArithCtx> gbContext; std::vector<JBig2ArithCtx> grContext; if ((wFlags & 0x0100) && pLRSeg) { if (bUseGbContext) { gbContext = pLRSeg->m_Result.sd->GbContext(); if (gbContext.size() != gbContextSize) return JBIG2_ERROR_FATAL; } if (bUseGrContext) { grContext = pLRSeg->m_Result.sd->GrContext(); if (grContext.size() != grContextSize) return JBIG2_ERROR_FATAL; } } else { if (bUseGbContext) gbContext.resize(gbContextSize); if (bUseGrContext) grContext.resize(grContextSize); } CJBig2_CacheKey key = CJBig2_CacheKey(pSegment->m_dwObjNum, pSegment->m_dwDataOffset); FX_BOOL cache_hit = false; pSegment->m_nResultType = JBIG2_SYMBOL_DICT_POINTER; if (m_bIsGlobal && key.first != 0) { for (auto it = m_pSymbolDictCache->begin(); it != m_pSymbolDictCache->end(); ++it) { if (it->first == key) { std::unique_ptr<CJBig2_SymbolDict> copy(it->second->DeepCopy()); pSegment->m_Result.sd = copy.release(); m_pSymbolDictCache->push_front(*it); m_pSymbolDictCache->erase(it); cache_hit = true; break; } } } if (!cache_hit) { if (bUseGbContext) { std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder( new CJBig2_ArithDecoder(m_pStream.get())); pSegment->m_Result.sd = pSymbolDictDecoder->decode_Arith( pArithDecoder.get(), &gbContext, &grContext); if (!pSegment->m_Result.sd) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); m_pStream->offset(2); } else { pSegment->m_Result.sd = pSymbolDictDecoder->decode_Huffman( m_pStream.get(), &gbContext, &grContext, pPause); if (!pSegment->m_Result.sd) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); } if (m_bIsGlobal && kSymbolDictCacheMaxSize > 0) { std::unique_ptr<CJBig2_SymbolDict> value = pSegment->m_Result.sd->DeepCopy(); int size = pdfium::CollectionSize<int>(*m_pSymbolDictCache); while (size >= kSymbolDictCacheMaxSize) { delete m_pSymbolDictCache->back().second; m_pSymbolDictCache->pop_back(); --size; } m_pSymbolDictCache->push_front(CJBig2_CachePair(key, value.release())); } } if (wFlags & 0x0200) { if (bUseGbContext) pSegment->m_Result.sd->SetGbContext(gbContext); if (bUseGrContext) pSegment->m_Result.sd->SetGrContext(grContext); } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseTextRegion(CJBig2_Segment* pSegment) { uint16_t wFlags; JBig2RegionInfo ri; if (parseRegionInfo(&ri) != JBIG2_SUCCESS || m_pStream->readShortInteger(&wFlags) != 0) { return JBIG2_ERROR_TOO_SHORT; } std::unique_ptr<CJBig2_TRDProc> pTRD(new CJBig2_TRDProc); pTRD->SBW = ri.width; pTRD->SBH = ri.height; pTRD->SBHUFF = wFlags & 0x0001; pTRD->SBREFINE = (wFlags >> 1) & 0x0001; uint32_t dwTemp = (wFlags >> 2) & 0x0003; pTRD->SBSTRIPS = 1 << dwTemp; pTRD->REFCORNER = (JBig2Corner)((wFlags >> 4) & 0x0003); pTRD->TRANSPOSED = (wFlags >> 6) & 0x0001; pTRD->SBCOMBOP = (JBig2ComposeOp)((wFlags >> 7) & 0x0003); pTRD->SBDEFPIXEL = (wFlags >> 9) & 0x0001; pTRD->SBDSOFFSET = (wFlags >> 10) & 0x001f; if (pTRD->SBDSOFFSET >= 0x0010) { pTRD->SBDSOFFSET = pTRD->SBDSOFFSET - 0x0020; } pTRD->SBRTEMPLATE = (wFlags >> 15) & 0x0001; uint8_t cSBHUFFFS = 0; uint8_t cSBHUFFDS = 0; uint8_t cSBHUFFDT = 0; uint8_t cSBHUFFRDW = 0; uint8_t cSBHUFFRDH = 0; uint8_t cSBHUFFRDX = 0; uint8_t cSBHUFFRDY = 0; uint8_t cSBHUFFRSIZE = 0; if (pTRD->SBHUFF == 1) { if (m_pStream->readShortInteger(&wFlags) != 0) return JBIG2_ERROR_TOO_SHORT; cSBHUFFFS = wFlags & 0x0003; cSBHUFFDS = (wFlags >> 2) & 0x0003; cSBHUFFDT = (wFlags >> 4) & 0x0003; cSBHUFFRDW = (wFlags >> 6) & 0x0003; cSBHUFFRDH = (wFlags >> 8) & 0x0003; cSBHUFFRDX = (wFlags >> 10) & 0x0003; cSBHUFFRDY = (wFlags >> 12) & 0x0003; cSBHUFFRSIZE = (wFlags >> 14) & 0x0001; } if (pTRD->SBREFINE == 1 && pTRD->SBRTEMPLATE == 0) { for (int32_t i = 0; i < 4; ++i) { if (m_pStream->read1Byte((uint8_t*)&pTRD->SBRAT[i]) != 0) return JBIG2_ERROR_TOO_SHORT; } } if (m_pStream->readInteger(&pTRD->SBNUMINSTANCES) != 0) return JBIG2_ERROR_TOO_SHORT; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { if (!findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i])) return JBIG2_ERROR_FATAL; } pTRD->SBNUMSYMS = 0; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); if (pSeg->m_cFlags.s.type == 0) { pTRD->SBNUMSYMS += pSeg->m_Result.sd->NumImages(); } } std::unique_ptr<CJBig2_Image*, FxFreeDeleter> SBSYMS; if (pTRD->SBNUMSYMS > 0) { SBSYMS.reset(FX_Alloc(CJBig2_Image*, pTRD->SBNUMSYMS)); dwTemp = 0; for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); if (pSeg->m_cFlags.s.type == 0) { const CJBig2_SymbolDict& dict = *pSeg->m_Result.sd; for (size_t j = 0; j < dict.NumImages(); ++j) SBSYMS.get()[dwTemp + j] = dict.GetImage(j); dwTemp += dict.NumImages(); } } pTRD->SBSYMS = SBSYMS.get(); } else { pTRD->SBSYMS = NULL; } std::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES; if (pTRD->SBHUFF == 1) { SBSYMCODES.reset( decodeSymbolIDHuffmanTable(m_pStream.get(), pTRD->SBNUMSYMS)); if (!SBSYMCODES) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); pTRD->SBSYMCODES = SBSYMCODES.get(); } else { dwTemp = 0; while ((uint32_t)(1 << dwTemp) < pTRD->SBNUMSYMS) { ++dwTemp; } pTRD->SBSYMCODELEN = (uint8_t)dwTemp; } std::unique_ptr<CJBig2_HuffmanTable> Table_B1; std::unique_ptr<CJBig2_HuffmanTable> Table_B6; std::unique_ptr<CJBig2_HuffmanTable> Table_B7; std::unique_ptr<CJBig2_HuffmanTable> Table_B8; std::unique_ptr<CJBig2_HuffmanTable> Table_B9; std::unique_ptr<CJBig2_HuffmanTable> Table_B10; std::unique_ptr<CJBig2_HuffmanTable> Table_B11; std::unique_ptr<CJBig2_HuffmanTable> Table_B12; std::unique_ptr<CJBig2_HuffmanTable> Table_B13; std::unique_ptr<CJBig2_HuffmanTable> Table_B14; std::unique_ptr<CJBig2_HuffmanTable> Table_B15; if (pTRD->SBHUFF == 1) { if (cSBHUFFFS == 2 || cSBHUFFRDW == 2 || cSBHUFFRDH == 2 || cSBHUFFRDX == 2 || cSBHUFFRDY == 2) { return JBIG2_ERROR_FATAL; } int32_t nIndex = 0; if (cSBHUFFFS == 0) { Table_B6.reset(new CJBig2_HuffmanTable( HuffmanTable_B6, HuffmanTable_B6_Size, HuffmanTable_HTOOB_B6)); pTRD->SBHUFFFS = Table_B6.get(); } else if (cSBHUFFFS == 1) { Table_B7.reset(new CJBig2_HuffmanTable( HuffmanTable_B7, HuffmanTable_B7_Size, HuffmanTable_HTOOB_B7)); pTRD->SBHUFFFS = Table_B7.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFFS = pSeg->m_Result.ht; } if (cSBHUFFDS == 0) { Table_B8.reset(new CJBig2_HuffmanTable( HuffmanTable_B8, HuffmanTable_B8_Size, HuffmanTable_HTOOB_B8)); pTRD->SBHUFFDS = Table_B8.get(); } else if (cSBHUFFDS == 1) { Table_B9.reset(new CJBig2_HuffmanTable( HuffmanTable_B9, HuffmanTable_B9_Size, HuffmanTable_HTOOB_B9)); pTRD->SBHUFFDS = Table_B9.get(); } else if (cSBHUFFDS == 2) { Table_B10.reset(new CJBig2_HuffmanTable( HuffmanTable_B10, HuffmanTable_B10_Size, HuffmanTable_HTOOB_B10)); pTRD->SBHUFFDS = Table_B10.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFDS = pSeg->m_Result.ht; } if (cSBHUFFDT == 0) { Table_B11.reset(new CJBig2_HuffmanTable( HuffmanTable_B11, HuffmanTable_B11_Size, HuffmanTable_HTOOB_B11)); pTRD->SBHUFFDT = Table_B11.get(); } else if (cSBHUFFDT == 1) { Table_B12.reset(new CJBig2_HuffmanTable( HuffmanTable_B12, HuffmanTable_B12_Size, HuffmanTable_HTOOB_B12)); pTRD->SBHUFFDT = Table_B12.get(); } else if (cSBHUFFDT == 2) { Table_B13.reset(new CJBig2_HuffmanTable( HuffmanTable_B13, HuffmanTable_B13_Size, HuffmanTable_HTOOB_B13)); pTRD->SBHUFFDT = Table_B13.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFDT = pSeg->m_Result.ht; } if (cSBHUFFRDW == 0) { Table_B14.reset(new CJBig2_HuffmanTable( HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14)); pTRD->SBHUFFRDW = Table_B14.get(); } else if (cSBHUFFRDW == 1) { Table_B15.reset(new CJBig2_HuffmanTable( HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15)); pTRD->SBHUFFRDW = Table_B15.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFRDW = pSeg->m_Result.ht; } if (cSBHUFFRDH == 0) { if (!Table_B14) { Table_B14.reset(new CJBig2_HuffmanTable( HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14)); } pTRD->SBHUFFRDH = Table_B14.get(); } else if (cSBHUFFRDH == 1) { if (!Table_B15) { Table_B15.reset(new CJBig2_HuffmanTable( HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15)); } pTRD->SBHUFFRDH = Table_B15.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFRDH = pSeg->m_Result.ht; } if (cSBHUFFRDX == 0) { if (!Table_B14) { Table_B14.reset(new CJBig2_HuffmanTable( HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14)); } pTRD->SBHUFFRDX = Table_B14.get(); } else if (cSBHUFFRDX == 1) { if (!Table_B15) { Table_B15.reset(new CJBig2_HuffmanTable( HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15)); } pTRD->SBHUFFRDX = Table_B15.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFRDX = pSeg->m_Result.ht; } if (cSBHUFFRDY == 0) { if (!Table_B14) { Table_B14.reset(new CJBig2_HuffmanTable( HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14)); } pTRD->SBHUFFRDY = Table_B14.get(); } else if (cSBHUFFRDY == 1) { if (!Table_B15) { Table_B15.reset(new CJBig2_HuffmanTable( HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15)); } pTRD->SBHUFFRDY = Table_B15.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFRDY = pSeg->m_Result.ht; } if (cSBHUFFRSIZE == 0) { Table_B1.reset(new CJBig2_HuffmanTable( HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1)); pTRD->SBHUFFRSIZE = Table_B1.get(); } else { CJBig2_Segment* pSeg = findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++); if (!pSeg) return JBIG2_ERROR_FATAL; pTRD->SBHUFFRSIZE = pSeg->m_Result.ht; } } std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext; if (pTRD->SBREFINE == 1) { const size_t size = GetRefAggContextSize(pTRD->SBRTEMPLATE); grContext.reset(FX_Alloc(JBig2ArithCtx, size)); JBIG2_memset(grContext.get(), 0, sizeof(JBig2ArithCtx) * size); } if (pTRD->SBHUFF == 0) { std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder( new CJBig2_ArithDecoder(m_pStream.get())); pSegment->m_nResultType = JBIG2_IMAGE_POINTER; pSegment->m_Result.im = pTRD->decode_Arith(pArithDecoder.get(), grContext.get(), nullptr); if (!pSegment->m_Result.im) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); m_pStream->offset(2); } else { pSegment->m_nResultType = JBIG2_IMAGE_POINTER; pSegment->m_Result.im = pTRD->decode_Huffman(m_pStream.get(), grContext.get()); if (!pSegment->m_Result.im) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); } if (pSegment->m_cFlags.s.type != 4) { 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); } } 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; } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parsePatternDict(CJBig2_Segment* pSegment, IFX_Pause* pPause) { uint8_t cFlags; std::unique_ptr<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) { return JBIG2_ERROR_TOO_SHORT; } if (pPDD->GRAYMAX > JBIG2_MAX_PATTERN_INDEX) return JBIG2_ERROR_LIMIT; pPDD->HDMMR = cFlags & 0x01; pPDD->HDTEMPLATE = (cFlags >> 1) & 0x03; pSegment->m_nResultType = JBIG2_PATTERN_DICT_POINTER; if (pPDD->HDMMR == 0) { const size_t size = GetHuffContextSize(pPDD->HDTEMPLATE); std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext( FX_Alloc(JBig2ArithCtx, size)); JBIG2_memset(gbContext.get(), 0, sizeof(JBig2ArithCtx) * size); std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder( new CJBig2_ArithDecoder(m_pStream.get())); pSegment->m_Result.pd = pPDD->decode_Arith(pArithDecoder.get(), gbContext.get(), pPause); if (!pSegment->m_Result.pd) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); m_pStream->offset(2); } else { pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream.get(), pPause); if (!pSegment->m_Result.pd) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseHalftoneRegion(CJBig2_Segment* pSegment, IFX_Pause* pPause) { uint8_t cFlags; JBig2RegionInfo ri; std::unique_ptr<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((uint32_t*)&pHRD->HGX) != 0 || m_pStream->readInteger((uint32_t*)&pHRD->HGY) != 0 || m_pStream->readShortInteger(&pHRD->HRX) != 0 || m_pStream->readShortInteger(&pHRD->HRY) != 0) { return JBIG2_ERROR_TOO_SHORT; } if (pHRD->HGW == 0 || pHRD->HGH == 0) return JBIG2_ERROR_FATAL; pHRD->HBW = ri.width; pHRD->HBH = ri.height; pHRD->HMMR = cFlags & 0x01; pHRD->HTEMPLATE = (cFlags >> 1) & 0x03; pHRD->HENABLESKIP = (cFlags >> 3) & 0x01; pHRD->HCOMBOP = (JBig2ComposeOp)((cFlags >> 4) & 0x07); pHRD->HDEFPIXEL = (cFlags >> 7) & 0x01; if (pSegment->m_nReferred_to_segment_count != 1) return JBIG2_ERROR_FATAL; CJBig2_Segment* pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]); if (!pSeg || (pSeg->m_cFlags.s.type != 16)) return JBIG2_ERROR_FATAL; CJBig2_PatternDict* pPatternDict = pSeg->m_Result.pd; if (!pPatternDict || (pPatternDict->NUMPATS == 0)) return JBIG2_ERROR_FATAL; 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) { const size_t size = GetHuffContextSize(pHRD->HTEMPLATE); std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext( FX_Alloc(JBig2ArithCtx, size)); JBIG2_memset(gbContext.get(), 0, sizeof(JBig2ArithCtx) * size); std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder( new CJBig2_ArithDecoder(m_pStream.get())); pSegment->m_Result.im = pHRD->decode_Arith(pArithDecoder.get(), gbContext.get(), pPause); if (!pSegment->m_Result.im) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); m_pStream->offset(2); } else { pSegment->m_Result.im = pHRD->decode_MMR(m_pStream.get(), pPause); if (!pSegment->m_Result.im) return JBIG2_ERROR_FATAL; m_pStream->alignByte(); } if (pSegment->m_cFlags.s.type != 20) { 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); } } 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; } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseGenericRegion(CJBig2_Segment* pSegment, IFX_Pause* pPause) { if (!m_pGRD) { std::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc); uint8_t cFlags; if (parseRegionInfo(&m_ri) != JBIG2_SUCCESS || m_pStream->read1Byte(&cFlags) != 0) { return JBIG2_ERROR_TOO_SHORT; } if (m_ri.height < 0 || m_ri.width < 0) return JBIG2_FAILED; pGRD->GBW = m_ri.width; pGRD->GBH = m_ri.height; pGRD->MMR = cFlags & 0x01; pGRD->GBTEMPLATE = (cFlags >> 1) & 0x03; pGRD->TPGDON = (cFlags >> 3) & 0x01; if (pGRD->MMR == 0) { if (pGRD->GBTEMPLATE == 0) { for (int32_t i = 0; i < 8; ++i) { if (m_pStream->read1Byte((uint8_t*)&pGRD->GBAT[i]) != 0) { return JBIG2_ERROR_TOO_SHORT; } } } else { for (int32_t i = 0; i < 2; ++i) { if (m_pStream->read1Byte((uint8_t*)&pGRD->GBAT[i]) != 0) { return JBIG2_ERROR_TOO_SHORT; } } } } pGRD->USESKIP = 0; m_pGRD = std::move(pGRD); } pSegment->m_nResultType = JBIG2_IMAGE_POINTER; if (m_pGRD->MMR == 0) { if (!m_gbContext) { const size_t size = GetHuffContextSize(m_pGRD->GBTEMPLATE); m_gbContext = FX_Alloc(JBig2ArithCtx, size); JBIG2_memset(m_gbContext, 0, sizeof(JBig2ArithCtx) * size); } if (!m_pArithDecoder) { m_pArithDecoder.reset(new CJBig2_ArithDecoder(m_pStream.get())); m_ProcessingStatus = m_pGRD->Start_decode_Arith( &pSegment->m_Result.im, m_pArithDecoder.get(), m_gbContext, pPause); } else { m_ProcessingStatus = m_pGRD->Continue_decode(pPause); } if (m_ProcessingStatus == 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 { m_pArithDecoder.reset(); FX_Free(m_gbContext); m_gbContext = NULL; if (!pSegment->m_Result.im) { m_ProcessingStatus = FXCODEC_STATUS_ERROR; m_pGRD.reset(); return JBIG2_ERROR_FATAL; } m_pStream->alignByte(); m_pStream->offset(2); } } else { FXCODEC_STATUS status = m_pGRD->Start_decode_MMR(&pSegment->m_Result.im, m_pStream.get(), pPause); while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { m_pGRD->Continue_decode(pPause); } if (!pSegment->m_Result.im) { m_pGRD.reset(); return JBIG2_ERROR_FATAL; } m_pStream->alignByte(); } 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); delete pSegment->m_Result.im; pSegment->m_Result.im = NULL; } m_pGRD.reset(); return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) { JBig2RegionInfo ri; uint8_t cFlags; if (parseRegionInfo(&ri) != JBIG2_SUCCESS || m_pStream->read1Byte(&cFlags) != 0) { return JBIG2_ERROR_TOO_SHORT; } std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc); pGRRD->GRW = ri.width; pGRRD->GRH = ri.height; pGRRD->GRTEMPLATE = cFlags & 0x01; pGRRD->TPGRON = (cFlags >> 1) & 0x01; if (pGRRD->GRTEMPLATE == 0) { for (int32_t i = 0; i < 4; ++i) { if (m_pStream->read1Byte((uint8_t*)&pGRRD->GRAT[i]) != 0) return JBIG2_ERROR_TOO_SHORT; } } CJBig2_Segment* pSeg = nullptr; if (pSegment->m_nReferred_to_segment_count > 0) { int32_t i; for (i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) { pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]); if (!pSeg) return JBIG2_ERROR_FATAL; if (pSeg->m_cFlags.s.type == 4 || pSeg->m_cFlags.s.type == 20 || pSeg->m_cFlags.s.type == 36 || pSeg->m_cFlags.s.type == 40) { break; } } if (i >= pSegment->m_nReferred_to_segment_count) return JBIG2_ERROR_FATAL; pGRRD->GRREFERENCE = pSeg->m_Result.im; } else { pGRRD->GRREFERENCE = m_pPage.get(); } pGRRD->GRREFERENCEDX = 0; pGRRD->GRREFERENCEDY = 0; const size_t size = GetRefAggContextSize(pGRRD->GRTEMPLATE); std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext( FX_Alloc(JBig2ArithCtx, size)); JBIG2_memset(grContext.get(), 0, sizeof(JBig2ArithCtx) * size); std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder( new CJBig2_ArithDecoder(m_pStream.get())); pSegment->m_nResultType = JBIG2_IMAGE_POINTER; pSegment->m_Result.im = pGRRD->decode(pArithDecoder.get(), grContext.get()); if (!pSegment->m_Result.im) return JBIG2_ERROR_FATAL; 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); } } 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; } return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseTable(CJBig2_Segment* pSegment) { pSegment->m_nResultType = JBIG2_HUFFMAN_TABLE_POINTER; pSegment->m_Result.ht = nullptr; std::unique_ptr<CJBig2_HuffmanTable> pHuff( new CJBig2_HuffmanTable(m_pStream.get())); if (!pHuff->IsOK()) return JBIG2_ERROR_FATAL; pSegment->m_Result.ht = pHuff.release(); m_pStream->alignByte(); return JBIG2_SUCCESS; } int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo* pRI) { if (m_pStream->readInteger((uint32_t*)&pRI->width) != 0 || m_pStream->readInteger((uint32_t*)&pRI->height) != 0 || m_pStream->readInteger((uint32_t*)&pRI->x) != 0 || m_pStream->readInteger((uint32_t*)&pRI->y) != 0 || m_pStream->read1Byte(&pRI->flags) != 0) { return JBIG2_ERROR_TOO_SHORT; } return JBIG2_SUCCESS; } JBig2HuffmanCode* CJBig2_Context::decodeSymbolIDHuffmanTable( CJBig2_BitStream* pStream, uint32_t SBNUMSYMS) { const size_t kRunCodesSize = 35; int32_t runcodes[kRunCodesSize]; int32_t runcodes_len[kRunCodesSize]; for (size_t i = 0; i < kRunCodesSize; ++i) { if (pStream->readNBits(4, &runcodes_len[i]) != 0) return nullptr; } huffman_assign_code(runcodes, runcodes_len, kRunCodesSize); std::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES( FX_Alloc(JBig2HuffmanCode, SBNUMSYMS)); int32_t run = 0; int32_t i = 0; while (i < (int)SBNUMSYMS) { size_t j; int32_t nVal = 0; int32_t nBits = 0; uint32_t nTemp; while (true) { if (pStream->read1Bit(&nTemp) != 0) return nullptr; nVal = (nVal << 1) | nTemp; ++nBits; for (j = 0; j < kRunCodesSize; ++j) { if (nBits == runcodes_len[j] && nVal == runcodes[j]) break; } if (j < kRunCodesSize) break; } int32_t runcode = static_cast<int32_t>(j); if (runcode < 32) { SBSYMCODES.get()[i].codelen = runcode; run = 0; } else if (runcode == 32) { if (pStream->readNBits(2, &nTemp) != 0) return nullptr; run = nTemp + 3; } else if (runcode == 33) { if (pStream->readNBits(3, &nTemp) != 0) return nullptr; run = nTemp + 3; } else if (runcode == 34) { if (pStream->readNBits(7, &nTemp) != 0) return nullptr; run = nTemp + 11; } if (run > 0) { if (i + run > (int)SBNUMSYMS) return nullptr; for (int32_t k = 0; k < run; ++k) { if (runcode == 32 && i > 0) { SBSYMCODES.get()[i + k].codelen = SBSYMCODES.get()[i - 1].codelen; } else { SBSYMCODES.get()[i + k].codelen = 0; } } i += run; } else { ++i; } } huffman_assign_code(SBSYMCODES.get(), SBNUMSYMS); return SBSYMCODES.release(); } void CJBig2_Context::huffman_assign_code(int* CODES, int* PREFLEN, int NTEMP) { // TODO(thestig) CJBig2_HuffmanTable::parseFromCodedBuffer() has similar code. 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 = FX_Alloc(int, LENMAX + 1); JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1)); FIRSTCODE = FX_Alloc(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; } 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 = FX_Alloc(int, (LENMAX + 1)); JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1)); FIRSTCODE = FX_Alloc(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; } FX_Free(LENCOUNT); FX_Free(FIRSTCODE); }