| // 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. |
| const int kSymbolDictCacheMaxSize = 2; |
| |
| CJBig2_Context* CJBig2_Context::CreateContext( |
| CJBig2_Module* pModule, |
| uint8_t* pGlobalData, |
| FX_DWORD dwGlobalLength, |
| uint8_t* pData, |
| FX_DWORD dwLength, |
| int32_t nStreamType, |
| std::list<CJBig2_CachePair>* pSymbolDictCache, |
| IFX_Pause* pPause) { |
| return new (pModule) |
| CJBig2_Context(pGlobalData, dwGlobalLength, pData, dwLength, nStreamType, |
| pSymbolDictCache, pPause); |
| } |
| void CJBig2_Context::DestroyContext(CJBig2_Context* pContext) { |
| delete pContext; |
| } |
| CJBig2_Context::CJBig2_Context(uint8_t* pGlobalData, |
| FX_DWORD dwGlobalLength, |
| uint8_t* pData, |
| FX_DWORD dwLength, |
| int32_t nStreamType, |
| std::list<CJBig2_CachePair>* pSymbolDictCache, |
| IFX_Pause* pPause) { |
| if (pGlobalData && (dwGlobalLength > 0)) { |
| JBIG2_ALLOC(m_pGlobalContext, |
| CJBig2_Context(NULL, 0, pGlobalData, dwGlobalLength, |
| JBIG2_EMBED_STREAM, pSymbolDictCache, pPause)); |
| } else { |
| m_pGlobalContext = NULL; |
| } |
| JBIG2_ALLOC(m_pStream, 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)); |
| } |
| } |
| 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; |
| 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; |
| } |
| } |
| } else { |
| return JBIG2_END_OF_FILE; |
| } |
| 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); |
| if (nRet != JBIG2_SUCCESS) { |
| delete pSegment; |
| return nRet; |
| } else if (pSegment->m_cFlags.s.type == 51) { |
| delete pSegment; |
| break; |
| } |
| m_pSegmentList->addItem(pSegment); |
| 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) { |
| 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, |
| 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_ProcessiveStatus = FXCODEC_STATUS_ERROR; |
| return nRet; |
| } |
| } |
| m_bFirstPage = TRUE; |
| m_PauseStep = 0; |
| delete m_pPage; |
| JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf)); |
| m_bBufSpecified = TRUE; |
| if (m_pPage && pPause && pPause->NeedToPauseNow()) { |
| m_PauseStep = 1; |
| m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; |
| return nRet; |
| } |
| int ret = Continue(pPause); |
| return ret; |
| } |
| int32_t CJBig2_Context::Continue(IFX_Pause* pPause) { |
| m_ProcessiveStatus = FXCODEC_STATUS_DECODE_READY; |
| int32_t nRet; |
| if (m_PauseStep <= 1) { |
| switch (m_nStreamType) { |
| case JBIG2_FILE_STREAM: |
| nRet = decodeFile(pPause); |
| break; |
| case JBIG2_SQUENTIAL_STREAM: |
| nRet = decode_SquentialOrgnazation(pPause); |
| break; |
| case JBIG2_RANDOM_STREAM: |
| if (m_bFirstPage) { |
| nRet = decode_RandomOrgnazation_FirstPage(pPause); |
| } else { |
| nRet = decode_RandomOrgnazation(pPause); |
| } |
| break; |
| case JBIG2_EMBED_STREAM: |
| nRet = decode_EmbedOrgnazation(pPause); |
| break; |
| default: |
| m_ProcessiveStatus = FXCODEC_STATUS_ERROR; |
| return JBIG2_ERROR_STREAM_TYPE; |
| } |
| } 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_ProcessiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
| return JBIG2_SUCCESS; |
| } |
| if (m_ProcessiveStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) { |
| return nRet; |
| } |
| m_PauseStep = 5; |
| if (!m_bBufSpecified && nRet == JBIG2_SUCCESS) { |
| m_ProcessiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
| return JBIG2_SUCCESS; |
| } |
| if (nRet == JBIG2_SUCCESS) { |
| m_ProcessiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
| } else { |
| m_ProcessiveStatus = FXCODEC_STATUS_ERROR; |
| } |
| return nRet; |
| } |
| int32_t CJBig2_Context::getFirstPage(CJBig2_Image** image, IFX_Pause* pPause) { |
| int32_t nRet; |
| m_bFirstPage = TRUE; |
| m_PauseStep = 0; |
| if (m_pGlobalContext) { |
| 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); |
| if (pSeg->m_dwNumber == dwNumber) { |
| return pSeg; |
| } |
| } |
| return NULL; |
| } |
| 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]); |
| if (pSeg && pSeg->m_cFlags.s.type == cType) { |
| if (count == nIndex) { |
| return pSeg; |
| } else { |
| count++; |
| } |
| } |
| } |
| return NULL; |
| } |
| int32_t CJBig2_Context::parseSegmentHeader(CJBig2_Segment* pSegment) { |
| uint8_t cSSize, cPSize; |
| uint8_t cTemp; |
| FX_WORD wTemp; |
| FX_DWORD dwTemp; |
| if ((m_pStream->readInteger(&pSegment->m_dwNumber) != 0) || |
| (m_pStream->read1Byte(&pSegment->m_cFlags.c) != 0)) { |
| goto failed; |
| } |
| cTemp = m_pStream->getCurByte(); |
| if ((cTemp >> 5) == 7) { |
| if (m_pStream->readInteger( |
| (FX_DWORD*)&pSegment->m_nReferred_to_segment_count) != 0) { |
| goto failed; |
| } |
| pSegment->m_nReferred_to_segment_count &= 0x1fffffff; |
| if (pSegment->m_nReferred_to_segment_count > |
| JBIG2_MAX_REFERRED_SEGMENT_COUNT) { |
| m_pModule->JBig2_Error("Too many referred segments."); |
| return JBIG2_ERROR_LIMIT; |
| } |
| dwTemp = 5 + 4 + (pSegment->m_nReferred_to_segment_count + 1) / 8; |
| } else { |
| if (m_pStream->read1Byte(&cTemp) != 0) { |
| goto failed; |
| } |
| pSegment->m_nReferred_to_segment_count = cTemp >> 5; |
| dwTemp = 5 + 1; |
| } |
| cSSize = |
| pSegment->m_dwNumber > 65536 ? 4 : pSegment->m_dwNumber > 256 ? 2 : 1; |
| cPSize = pSegment->m_cFlags.s.page_association_size ? 4 : 1; |
| if (pSegment->m_nReferred_to_segment_count) { |
| pSegment->m_pReferred_to_segment_numbers = |
| (FX_DWORD*)m_pModule->JBig2_Malloc2( |
| sizeof(FX_DWORD), pSegment->m_nReferred_to_segment_count); |
| for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| switch (cSSize) { |
| case 1: |
| if (m_pStream->read1Byte(&cTemp) != 0) { |
| goto failed; |
| } |
| pSegment->m_pReferred_to_segment_numbers[i] = cTemp; |
| break; |
| case 2: |
| if (m_pStream->readShortInteger(&wTemp) != 0) { |
| goto failed; |
| } |
| pSegment->m_pReferred_to_segment_numbers[i] = wTemp; |
| break; |
| case 4: |
| if (m_pStream->readInteger(&dwTemp) != 0) { |
| goto failed; |
| } |
| pSegment->m_pReferred_to_segment_numbers[i] = dwTemp; |
| break; |
| } |
| if (pSegment->m_pReferred_to_segment_numbers[i] >= pSegment->m_dwNumber) { |
| m_pModule->JBig2_Error( |
| "The referred segment number is greater than this segment number."); |
| goto failed; |
| } |
| } |
| } |
| if (cPSize == 1) { |
| if (m_pStream->read1Byte(&cTemp) != 0) { |
| goto failed; |
| } |
| pSegment->m_dwPage_association = cTemp; |
| } else { |
| if (m_pStream->readInteger(&pSegment->m_dwPage_association) != 0) { |
| goto failed; |
| } |
| } |
| if (m_pStream->readInteger(&pSegment->m_dwData_length) != 0) { |
| goto failed; |
| } |
| pSegment->m_pData = m_pStream->getPointer(); |
| pSegment->m_State = JBIG2_SEGMENT_DATA_UNPARSED; |
| return JBIG2_SUCCESS; |
| failed: |
| m_pModule->JBig2_Error("header too short."); |
| return JBIG2_ERROR_TOO_SHORT; |
| } |
| int32_t CJBig2_Context::parseSegmentData(CJBig2_Segment* pSegment, |
| IFX_Pause* pPause) { |
| int32_t ret = ProcessiveParseSegmentData(pSegment, pPause); |
| while (m_ProcessiveStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE && |
| m_pStream->getByteLeft() > 0) { |
| ret = ProcessiveParseSegmentData(pSegment, pPause); |
| } |
| return ret; |
| } |
| int32_t CJBig2_Context::ProcessiveParseSegmentData(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_nState == JBIG2_OUT_OF_PAGE) { |
| goto failed2; |
| } else { |
| return parseTextRegion(pSegment); |
| } |
| case 16: |
| return parsePatternDict(pSegment, pPause); |
| case 20: |
| case 22: |
| case 23: |
| if (m_nState == JBIG2_OUT_OF_PAGE) { |
| goto failed2; |
| } else { |
| return parseHalftoneRegion(pSegment, pPause); |
| } |
| case 36: |
| case 38: |
| case 39: |
| if (m_nState == JBIG2_OUT_OF_PAGE) { |
| goto failed2; |
| } else { |
| return parseGenericRegion(pSegment, pPause); |
| } |
| 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); |
| 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)) { |
| m_pModule->JBig2_Warn("page height = 0xffffffff buf stripe field is 0"); |
| pPageInfo->m_bIsStriped = 1; |
| } |
| 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_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: |
| 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; |
| failed1: |
| m_pModule->JBig2_Error("segment data too short."); |
| return JBIG2_ERROR_TOO_SHORT; |
| failed2: |
| m_pModule->JBig2_Error("segment syntax error."); |
| return JBIG2_ERROR_FATAL; |
| } |
| int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment* pSegment, |
| IFX_Pause* pPause) { |
| FX_DWORD dwTemp; |
| FX_WORD wFlags; |
| uint8_t cSDHUFFDH, cSDHUFFDW, cSDHUFFBMSIZE, cSDHUFFAGGINST; |
| CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B2 = NULL, *Table_B3 = NULL, |
| *Table_B4 = NULL, *Table_B5 = NULL; |
| int32_t i, nIndex, nRet; |
| CJBig2_Segment *pSeg = NULL, *pLRSeg = NULL; |
| FX_BOOL bUsed; |
| CJBig2_Image** SDINSYMS = NULL; |
| CJBig2_SDDProc* pSymbolDictDecoder; |
| JBig2ArithCtx *gbContext = NULL, *grContext = NULL; |
| CJBig2_ArithDecoder* pArithDecoder; |
| JBIG2_ALLOC(pSymbolDictDecoder, CJBig2_SDDProc()); |
| uint8_t* key = pSegment->m_pData; |
| FX_BOOL cache_hit = false; |
| if (m_pStream->readShortInteger(&wFlags) != 0) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| pSymbolDictDecoder->SDHUFF = wFlags & 0x0001; |
| pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001; |
| pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003; |
| pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003; |
| cSDHUFFDH = (wFlags >> 2) & 0x0003; |
| cSDHUFFDW = (wFlags >> 4) & 0x0003; |
| cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001; |
| cSDHUFFAGGINST = (wFlags >> 7) & 0x0001; |
| if (pSymbolDictDecoder->SDHUFF == 0) { |
| if (pSymbolDictDecoder->SDTEMPLATE == 0) { |
| dwTemp = 8; |
| } else { |
| dwTemp = 2; |
| } |
| for (i = 0; i < (int32_t)dwTemp; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDAT[i]) != 0) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } |
| if ((pSymbolDictDecoder->SDREFAGG == 1) && |
| (pSymbolDictDecoder->SDRTEMPLATE == 0)) { |
| for (i = 0; i < 4; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDRAT[i]) != 0) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } |
| if ((m_pStream->readInteger(&pSymbolDictDecoder->SDNUMEXSYMS) != 0) || |
| (m_pStream->readInteger(&pSymbolDictDecoder->SDNUMNEWSYMS) != 0)) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| if (pSymbolDictDecoder->SDNUMEXSYMS > JBIG2_MAX_EXPORT_SYSMBOLS || |
| pSymbolDictDecoder->SDNUMNEWSYMS > JBIG2_MAX_NEW_SYSMBOLS) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : too many export/new symbols."); |
| nRet = JBIG2_ERROR_LIMIT; |
| goto failed; |
| } |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| if (!findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i])) { |
| m_pModule->JBig2_Error( |
| "symbol dictionary segment : can't find refered to segments"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| } |
| pSymbolDictDecoder->SDNUMINSYMS = 0; |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); |
| if (pSeg->m_cFlags.s.type == 0) { |
| pSymbolDictDecoder->SDNUMINSYMS += pSeg->m_Result.sd->SDNUMEXSYMS; |
| pLRSeg = pSeg; |
| } |
| } |
| if (pSymbolDictDecoder->SDNUMINSYMS == 0) { |
| SDINSYMS = NULL; |
| } else { |
| SDINSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( |
| sizeof(CJBig2_Image*), pSymbolDictDecoder->SDNUMINSYMS); |
| dwTemp = 0; |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); |
| if (pSeg->m_cFlags.s.type == 0) { |
| JBIG2_memcpy(SDINSYMS + dwTemp, pSeg->m_Result.sd->SDEXSYMS, |
| pSeg->m_Result.sd->SDNUMEXSYMS * sizeof(CJBig2_Image*)); |
| dwTemp += pSeg->m_Result.sd->SDNUMEXSYMS; |
| } |
| } |
| } |
| pSymbolDictDecoder->SDINSYMS = SDINSYMS; |
| 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)); |
| pSymbolDictDecoder->SDHUFFDH = Table_B4; |
| } else if (cSDHUFFDH == 1) { |
| JBIG2_ALLOC(Table_B5, CJBig2_HuffmanTable(HuffmanTable_B5, |
| sizeof(HuffmanTable_B5) / |
| sizeof(JBig2TableLine), |
| 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)); |
| pSymbolDictDecoder->SDHUFFDW = Table_B2; |
| } else if (cSDHUFFDW == 1) { |
| JBIG2_ALLOC(Table_B3, CJBig2_HuffmanTable(HuffmanTable_B3, |
| sizeof(HuffmanTable_B3) / |
| sizeof(JBig2TableLine), |
| 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)); |
| 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)); |
| } |
| 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; |
| } |
| pSymbolDictDecoder->SDHUFFAGGINST = pSeg->m_Result.ht; |
| } |
| } |
| } |
| if ((wFlags & 0x0100) && pLRSeg && pLRSeg->m_Result.sd->m_bContextRetained) { |
| if (pSymbolDictDecoder->SDHUFF == 0) { |
| dwTemp = pSymbolDictDecoder->SDTEMPLATE == 0 |
| ? 65536 |
| : pSymbolDictDecoder->SDTEMPLATE == 1 ? 8192 : 1024; |
| gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2( |
| sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memcpy(gbContext, pLRSeg->m_Result.sd->m_gbContext, |
| sizeof(JBig2ArithCtx) * dwTemp); |
| } |
| if (pSymbolDictDecoder->SDREFAGG == 1) { |
| dwTemp = pSymbolDictDecoder->SDRTEMPLATE ? 1 << 10 : 1 << 13; |
| grContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2( |
| sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memcpy(grContext, pLRSeg->m_Result.sd->m_grContext, |
| sizeof(JBig2ArithCtx) * dwTemp); |
| } |
| } else { |
| if (pSymbolDictDecoder->SDHUFF == 0) { |
| dwTemp = pSymbolDictDecoder->SDTEMPLATE == 0 |
| ? 65536 |
| : pSymbolDictDecoder->SDTEMPLATE == 1 ? 8192 : 1024; |
| gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2( |
| sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| } |
| if (pSymbolDictDecoder->SDREFAGG == 1) { |
| dwTemp = pSymbolDictDecoder->SDRTEMPLATE ? 1 << 10 : 1 << 13; |
| grContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc2( |
| sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| } |
| } |
| pSegment->m_nResultType = JBIG2_SYMBOL_DICT_POINTER; |
| for (std::list<CJBig2_CachePair>::iterator it = m_pSymbolDictCache->begin(); |
| it != m_pSymbolDictCache->end(); ++it) { |
| if (it->first == key) { |
| pSegment->m_Result.sd = it->second->DeepCopy(); |
| m_pSymbolDictCache->push_front(*it); |
| m_pSymbolDictCache->erase(it); |
| cache_hit = true; |
| break; |
| } |
| } |
| if (!cache_hit) { |
| if (pSymbolDictDecoder->SDHUFF == 0) { |
| JBIG2_ALLOC(pArithDecoder, 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 { |
| pSegment->m_Result.sd = pSymbolDictDecoder->decode_Huffman( |
| m_pStream, gbContext, grContext, pPause); |
| if (pSegment->m_Result.sd == NULL) { |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| m_pStream->alignByte(); |
| } |
| CJBig2_SymbolDict* value = pSegment->m_Result.sd->DeepCopy(); |
| if (value && kSymbolDictCacheMaxSize > 0) { |
| while (m_pSymbolDictCache->size() >= kSymbolDictCacheMaxSize) { |
| delete m_pSymbolDictCache->back().second; |
| m_pSymbolDictCache->pop_back(); |
| } |
| m_pSymbolDictCache->push_front(CJBig2_CachePair(key, value)); |
| } |
| } |
| if (wFlags & 0x0200) { |
| pSegment->m_Result.sd->m_bContextRetained = TRUE; |
| if (pSymbolDictDecoder->SDHUFF == 0) { |
| pSegment->m_Result.sd->m_gbContext = gbContext; |
| } |
| if (pSymbolDictDecoder->SDREFAGG == 1) { |
| pSegment->m_Result.sd->m_grContext = grContext; |
| } |
| bUsed = TRUE; |
| } else { |
| bUsed = FALSE; |
| } |
| delete pSymbolDictDecoder; |
| if (SDINSYMS) { |
| m_pModule->JBig2_Free(SDINSYMS); |
| } |
| delete Table_B1; |
| delete Table_B2; |
| delete Table_B3; |
| delete Table_B4; |
| delete Table_B5; |
| if (bUsed == FALSE) { |
| if (gbContext) { |
| m_pModule->JBig2_Free(gbContext); |
| } |
| if (grContext) { |
| m_pModule->JBig2_Free(grContext); |
| } |
| } |
| return JBIG2_SUCCESS; |
| failed: |
| delete pSymbolDictDecoder; |
| if (SDINSYMS) { |
| m_pModule->JBig2_Free(SDINSYMS); |
| } |
| delete Table_B1; |
| delete Table_B2; |
| delete Table_B3; |
| delete Table_B4; |
| delete Table_B5; |
| if (gbContext) { |
| m_pModule->JBig2_Free(gbContext); |
| } |
| if (grContext) { |
| m_pModule->JBig2_Free(grContext); |
| } |
| return nRet; |
| } |
| |
| int32_t CJBig2_Context::parseTextRegion(CJBig2_Segment* pSegment) { |
| FX_DWORD dwTemp; |
| FX_WORD wFlags; |
| int32_t i, nIndex, nRet; |
| JBig2RegionInfo ri; |
| CJBig2_Segment* pSeg; |
| CJBig2_Image** SBSYMS = NULL; |
| JBig2HuffmanCode* SBSYMCODES = NULL; |
| uint8_t cSBHUFFFS, cSBHUFFDS, cSBHUFFDT, cSBHUFFRDW, cSBHUFFRDH, cSBHUFFRDX, |
| cSBHUFFRDY, cSBHUFFRSIZE; |
| CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B6 = NULL, *Table_B7 = NULL, |
| *Table_B8 = NULL, *Table_B9 = NULL, *Table_B10 = NULL, |
| *Table_B11 = NULL, *Table_B12 = NULL, *Table_B13 = NULL, |
| *Table_B14 = NULL, *Table_B15 = NULL; |
| JBig2ArithCtx* grContext = NULL; |
| CJBig2_ArithDecoder* pArithDecoder; |
| CJBig2_TRDProc* pTRD; |
| JBIG2_ALLOC(pTRD, CJBig2_TRDProc()); |
| if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) || |
| (m_pStream->readShortInteger(&wFlags) != 0)) { |
| m_pModule->JBig2_Error("text region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| pTRD->SBW = ri.width; |
| pTRD->SBH = ri.height; |
| pTRD->SBHUFF = wFlags & 0x0001; |
| pTRD->SBREFINE = (wFlags >> 1) & 0x0001; |
| dwTemp = (wFlags >> 2) & 0x0003; |
| 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; |
| if (pTRD->SBHUFF == 1) { |
| if (m_pStream->readShortInteger(&wFlags) != 0) { |
| m_pModule->JBig2_Error("text region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| 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 (i = 0; i < 4; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&pTRD->SBRAT[i]) != 0) { |
| m_pModule->JBig2_Error("text region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } |
| if (m_pStream->readInteger(&pTRD->SBNUMINSTANCES) != 0) { |
| m_pModule->JBig2_Error("text region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| if (!findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i])) { |
| m_pModule->JBig2_Error( |
| "text region segment : can't find refered to segments"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| } |
| pTRD->SBNUMSYMS = 0; |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); |
| if (pSeg->m_cFlags.s.type == 0) { |
| pTRD->SBNUMSYMS += pSeg->m_Result.sd->SDNUMEXSYMS; |
| } |
| } |
| if (pTRD->SBNUMSYMS > 0) { |
| SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), |
| pTRD->SBNUMSYMS); |
| dwTemp = 0; |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]); |
| if (pSeg->m_cFlags.s.type == 0) { |
| JBIG2_memcpy(SBSYMS + dwTemp, pSeg->m_Result.sd->SDEXSYMS, |
| pSeg->m_Result.sd->SDNUMEXSYMS * sizeof(CJBig2_Image*)); |
| dwTemp += pSeg->m_Result.sd->SDNUMEXSYMS; |
| } |
| } |
| pTRD->SBSYMS = SBSYMS; |
| } else { |
| pTRD->SBSYMS = NULL; |
| } |
| if (pTRD->SBHUFF == 1) { |
| SBSYMCODES = decodeSymbolIDHuffmanTable(m_pStream, pTRD->SBNUMSYMS); |
| if (SBSYMCODES == NULL) { |
| m_pModule->JBig2_Error( |
| "text region segment: symbol ID huffman table decode failure!"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| m_pStream->alignByte(); |
| pTRD->SBSYMCODES = SBSYMCODES; |
| } else { |
| dwTemp = 0; |
| while ((FX_DWORD)(1 << dwTemp) < pTRD->SBNUMSYMS) { |
| dwTemp++; |
| } |
| pTRD->SBSYMCODELEN = (uint8_t)dwTemp; |
| } |
| if (pTRD->SBHUFF == 1) { |
| 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)); |
| pTRD->SBHUFFFS = Table_B6; |
| } else if (cSBHUFFFS == 1) { |
| JBIG2_ALLOC(Table_B7, CJBig2_HuffmanTable(HuffmanTable_B7, |
| sizeof(HuffmanTable_B7) / |
| sizeof(JBig2TableLine), |
| 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)); |
| pTRD->SBHUFFDS = Table_B8; |
| } else if (cSBHUFFDS == 1) { |
| JBIG2_ALLOC(Table_B9, CJBig2_HuffmanTable(HuffmanTable_B9, |
| sizeof(HuffmanTable_B9) / |
| sizeof(JBig2TableLine), |
| 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)); |
| 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)); |
| pTRD->SBHUFFDT = Table_B11; |
| } else if (cSBHUFFDT == 1) { |
| JBIG2_ALLOC(Table_B12, CJBig2_HuffmanTable(HuffmanTable_B12, |
| sizeof(HuffmanTable_B12) / |
| sizeof(JBig2TableLine), |
| 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)); |
| 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)); |
| pTRD->SBHUFFRDW = Table_B14; |
| } else if (cSBHUFFRDW == 1) { |
| JBIG2_ALLOC(Table_B15, CJBig2_HuffmanTable(HuffmanTable_B15, |
| sizeof(HuffmanTable_B15) / |
| sizeof(JBig2TableLine), |
| 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)); |
| } |
| 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)); |
| } |
| 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)); |
| } |
| 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)); |
| } |
| 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)); |
| } |
| 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)); |
| } |
| 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)); |
| 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)); |
| 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(); |
| 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 pTRD; |
| if (SBSYMS) { |
| m_pModule->JBig2_Free(SBSYMS); |
| } |
| if (SBSYMCODES) { |
| m_pModule->JBig2_Free(SBSYMCODES); |
| } |
| if (grContext) { |
| m_pModule->JBig2_Free(grContext); |
| } |
| delete Table_B1; |
| delete Table_B6; |
| delete Table_B7; |
| delete Table_B8; |
| delete Table_B9; |
| delete Table_B10; |
| delete Table_B11; |
| delete Table_B12; |
| delete Table_B13; |
| delete Table_B14; |
| delete Table_B15; |
| return JBIG2_SUCCESS; |
| failed: |
| delete pTRD; |
| if (SBSYMS) { |
| m_pModule->JBig2_Free(SBSYMS); |
| } |
| if (SBSYMCODES) { |
| m_pModule->JBig2_Free(SBSYMCODES); |
| } |
| if (grContext) { |
| m_pModule->JBig2_Free(grContext); |
| } |
| delete Table_B1; |
| delete Table_B6; |
| delete Table_B7; |
| delete Table_B8; |
| delete Table_B9; |
| delete Table_B10; |
| delete Table_B11; |
| delete Table_B12; |
| delete Table_B13; |
| delete Table_B14; |
| delete Table_B15; |
| return nRet; |
| } |
| |
| int32_t CJBig2_Context::parsePatternDict(CJBig2_Segment* pSegment, |
| IFX_Pause* pPause) { |
| FX_DWORD dwTemp; |
| uint8_t cFlags; |
| JBig2ArithCtx* gbContext; |
| CJBig2_ArithDecoder* pArithDecoder; |
| CJBig2_PDDProc* pPDD; |
| int32_t nRet; |
| JBIG2_ALLOC(pPDD, CJBig2_PDDProc()); |
| if ((m_pStream->read1Byte(&cFlags) != 0) || |
| (m_pStream->read1Byte(&pPDD->HDPW) != 0) || |
| (m_pStream->read1Byte(&pPDD->HDPH) != 0) || |
| (m_pStream->readInteger(&pPDD->GRAYMAX) != 0)) { |
| m_pModule->JBig2_Error( |
| "pattern dictionary segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| if (pPDD->GRAYMAX > JBIG2_MAX_PATTERN_INDEX) { |
| m_pModule->JBig2_Error("pattern dictionary segment : too max gray max."); |
| nRet = JBIG2_ERROR_LIMIT; |
| goto failed; |
| } |
| pPDD->HDMMR = cFlags & 0x01; |
| pPDD->HDTEMPLATE = (cFlags >> 1) & 0x03; |
| pSegment->m_nResultType = JBIG2_PATTERN_DICT_POINTER; |
| if (pPDD->HDMMR == 0) { |
| dwTemp = |
| pPDD->HDTEMPLATE == 0 ? 65536 : pPDD->HDTEMPLATE == 1 ? 8192 : 1024; |
| gbContext = |
| (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| JBIG2_ALLOC(pArithDecoder, 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(); |
| m_pStream->offset(2); |
| } else { |
| pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream, pPause); |
| if (pSegment->m_Result.pd == NULL) { |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| m_pStream->alignByte(); |
| } |
| delete pPDD; |
| return JBIG2_SUCCESS; |
| failed: |
| delete pPDD; |
| return nRet; |
| } |
| int32_t CJBig2_Context::parseHalftoneRegion(CJBig2_Segment* pSegment, |
| IFX_Pause* pPause) { |
| FX_DWORD dwTemp; |
| uint8_t cFlags; |
| JBig2RegionInfo ri; |
| CJBig2_Segment* pSeg; |
| CJBig2_PatternDict* pPatternDict; |
| JBig2ArithCtx* gbContext; |
| CJBig2_ArithDecoder* pArithDecoder; |
| CJBig2_HTRDProc* pHRD; |
| int32_t nRet; |
| JBIG2_ALLOC(pHRD, CJBig2_HTRDProc()); |
| if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) || |
| (m_pStream->read1Byte(&cFlags) != 0) || |
| (m_pStream->readInteger(&pHRD->HGW) != 0) || |
| (m_pStream->readInteger(&pHRD->HGH) != 0) || |
| (m_pStream->readInteger((FX_DWORD*)&pHRD->HGX) != 0) || |
| (m_pStream->readInteger((FX_DWORD*)&pHRD->HGY) != 0) || |
| (m_pStream->readShortInteger(&pHRD->HRX) != 0) || |
| (m_pStream->readShortInteger(&pHRD->HRY) != 0)) { |
| m_pModule->JBig2_Error("halftone region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| 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) { |
| m_pModule->JBig2_Error( |
| "halftone region segment : refered to segment count not equals 1"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]); |
| if ((pSeg == NULL) || (pSeg->m_cFlags.s.type != 16)) { |
| m_pModule->JBig2_Error( |
| "halftone region segment : refered to segment is not pattern dict"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| pPatternDict = pSeg->m_Result.pd; |
| if ((pPatternDict == NULL) || (pPatternDict->NUMPATS == 0)) { |
| m_pModule->JBig2_Error("halftone region segment : has no patterns input"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| pHRD->HNUMPATS = pPatternDict->NUMPATS; |
| pHRD->HPATS = pPatternDict->HDPATS; |
| pHRD->HPW = pPatternDict->HDPATS[0]->m_nWidth; |
| pHRD->HPH = pPatternDict->HDPATS[0]->m_nHeight; |
| pSegment->m_nResultType = JBIG2_IMAGE_POINTER; |
| if (pHRD->HMMR == 0) { |
| dwTemp = pHRD->HTEMPLATE == 0 ? 65536 : pHRD->HTEMPLATE == 1 ? 8192 : 1024; |
| gbContext = |
| (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| JBIG2_ALLOC(pArithDecoder, 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(); |
| 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 pHRD; |
| return JBIG2_SUCCESS; |
| failed: |
| delete pHRD; |
| return nRet; |
| } |
| |
| int32_t CJBig2_Context::parseGenericRegion(CJBig2_Segment* pSegment, |
| IFX_Pause* pPause) { |
| FX_DWORD dwTemp; |
| uint8_t cFlags; |
| int32_t i, nRet; |
| if (m_pGRD == NULL) { |
| JBIG2_ALLOC(m_pGRD, CJBig2_GRDProc()); |
| if ((parseRegionInfo(&m_ri) != JBIG2_SUCCESS) || |
| (m_pStream->read1Byte(&cFlags) != 0)) { |
| m_pModule->JBig2_Error("generic region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| if (m_ri.height < 0 || m_ri.width < 0) { |
| m_pModule->JBig2_Error("generic region segment : wrong data."); |
| nRet = JBIG2_FAILED; |
| goto failed; |
| } |
| m_pGRD->GBW = m_ri.width; |
| m_pGRD->GBH = m_ri.height; |
| m_pGRD->MMR = cFlags & 0x01; |
| m_pGRD->GBTEMPLATE = (cFlags >> 1) & 0x03; |
| m_pGRD->TPGDON = (cFlags >> 3) & 0x01; |
| if (m_pGRD->MMR == 0) { |
| if (m_pGRD->GBTEMPLATE == 0) { |
| for (i = 0; i < 8; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&m_pGRD->GBAT[i]) != 0) { |
| m_pModule->JBig2_Error( |
| "generic region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } else { |
| for (i = 0; i < 2; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&m_pGRD->GBAT[i]) != 0) { |
| m_pModule->JBig2_Error( |
| "generic region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } |
| } |
| m_pGRD->USESKIP = 0; |
| } |
| pSegment->m_nResultType = JBIG2_IMAGE_POINTER; |
| if (m_pGRD->MMR == 0) { |
| dwTemp = |
| m_pGRD->GBTEMPLATE == 0 ? 65536 : m_pGRD->GBTEMPLATE == 1 ? 8192 : 1024; |
| if (m_gbContext == NULL) { |
| m_gbContext = (JBig2ArithCtx*)m_pModule->JBig2_Malloc( |
| sizeof(JBig2ArithCtx) * dwTemp); |
| JBIG2_memset(m_gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| } |
| if (m_pArithDecoder == NULL) { |
| JBIG2_ALLOC(m_pArithDecoder, 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(); |
| if ((pPageInfo->m_bIsStriped == 1) && |
| (m_ri.y + m_ri.height > m_pPage->m_nHeight)) { |
| m_pPage->expand(m_ri.y + m_ri.height, |
| (pPageInfo->m_cFlags & 4) ? 1 : 0); |
| } |
| } |
| FX_RECT Rect = m_pGRD->GetReplaceRect(); |
| m_pPage->composeFrom(m_ri.x + Rect.left, m_ri.y + Rect.top, |
| pSegment->m_Result.im, |
| (JBig2ComposeOp)(m_ri.flags & 0x03), &Rect); |
| } |
| return JBIG2_SUCCESS; |
| } else { |
| delete m_pArithDecoder; |
| m_pArithDecoder = NULL; |
| if (pSegment->m_Result.im == NULL) { |
| m_pModule->JBig2_Free(m_gbContext); |
| nRet = JBIG2_ERROR_FATAL; |
| m_gbContext = NULL; |
| m_ProcessiveStatus = FXCODEC_STATUS_ERROR; |
| goto failed; |
| } |
| m_pModule->JBig2_Free(m_gbContext); |
| m_gbContext = NULL; |
| m_pStream->alignByte(); |
| m_pStream->offset(2); |
| } |
| } else { |
| FXCODEC_STATUS status = |
| m_pGRD->Start_decode_MMR(&pSegment->m_Result.im, m_pStream, pPause); |
| while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { |
| m_pGRD->Continue_decode(pPause); |
| } |
| 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(); |
| 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; |
| } |
| delete m_pGRD; |
| m_pGRD = NULL; |
| return JBIG2_SUCCESS; |
| failed: |
| delete m_pGRD; |
| m_pGRD = NULL; |
| return nRet; |
| } |
| |
| int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) { |
| FX_DWORD dwTemp; |
| JBig2RegionInfo ri; |
| CJBig2_Segment* pSeg; |
| int32_t i, nRet; |
| uint8_t cFlags; |
| JBig2ArithCtx* grContext; |
| CJBig2_GRRDProc* pGRRD; |
| CJBig2_ArithDecoder* pArithDecoder; |
| JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc()); |
| if ((parseRegionInfo(&ri) != JBIG2_SUCCESS) || |
| (m_pStream->read1Byte(&cFlags) != 0)) { |
| m_pModule->JBig2_Error( |
| "generic refinement region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| pGRRD->GRW = ri.width; |
| pGRRD->GRH = ri.height; |
| pGRRD->GRTEMPLATE = cFlags & 0x01; |
| pGRRD->TPGRON = (cFlags >> 1) & 0x01; |
| if (pGRRD->GRTEMPLATE == 0) { |
| for (i = 0; i < 4; i++) { |
| if (m_pStream->read1Byte((uint8_t*)&pGRRD->GRAT[i]) != 0) { |
| m_pModule->JBig2_Error( |
| "generic refinement region segment : data header too short."); |
| nRet = JBIG2_ERROR_TOO_SHORT; |
| goto failed; |
| } |
| } |
| } |
| pSeg = NULL; |
| if (pSegment->m_nReferred_to_segment_count > 0) { |
| for (i = 0; i < pSegment->m_nReferred_to_segment_count; i++) { |
| pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]); |
| if (pSeg == NULL) { |
| m_pModule->JBig2_Error( |
| "generic refinement region segment : can't find refered to " |
| "segments"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| 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) { |
| m_pModule->JBig2_Error( |
| "generic refinement region segment : can't find refered to " |
| "intermediate region"); |
| nRet = JBIG2_ERROR_FATAL; |
| goto failed; |
| } |
| pGRRD->GRREFERENCE = pSeg->m_Result.im; |
| } else { |
| pGRRD->GRREFERENCE = m_pPage; |
| } |
| pGRRD->GRREFERENCEDX = 0; |
| pGRRD->GRREFERENCEDY = 0; |
| dwTemp = pGRRD->GRTEMPLATE ? 1 << 10 : 1 << 13; |
| grContext = |
| (JBig2ArithCtx*)m_pModule->JBig2_Malloc2(sizeof(JBig2ArithCtx), dwTemp); |
| JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp); |
| JBIG2_ALLOC(pArithDecoder, 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(); |
| 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)); |
| 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) || |
| (m_pStream->readInteger((FX_DWORD*)&pRI->height) != 0) || |
| (m_pStream->readInteger((FX_DWORD*)&pRI->x) != 0) || |
| (m_pStream->readInteger((FX_DWORD*)&pRI->y) != 0) || |
| (m_pStream->read1Byte(&pRI->flags) != 0)) { |
| return JBIG2_ERROR_TOO_SHORT; |
| } |
| return JBIG2_SUCCESS; |
| } |
| JBig2HuffmanCode* CJBig2_Context::decodeSymbolIDHuffmanTable( |
| CJBig2_BitStream* pStream, |
| FX_DWORD SBNUMSYMS) { |
| JBig2HuffmanCode* SBSYMCODES; |
| int32_t runcodes[35]; |
| int32_t runcodes_len[35]; |
| int32_t runcode; |
| int32_t i; |
| int32_t j; |
| int32_t nVal; |
| int32_t nBits; |
| int32_t run; |
| FX_DWORD nTemp; |
| SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2( |
| sizeof(JBig2HuffmanCode), SBNUMSYMS); |
| for (i = 0; i < 35; i++) { |
| if (pStream->readNBits(4, &runcodes_len[i]) != 0) { |
| goto failed; |
| } |
| } |
| huffman_assign_code(runcodes, runcodes_len, 35); |
| i = 0; |
| while (i < (int)SBNUMSYMS) { |
| nVal = 0; |
| nBits = 0; |
| for (;;) { |
| if (pStream->read1Bit(&nTemp) != 0) { |
| goto failed; |
| } |
| nVal = (nVal << 1) | nTemp; |
| nBits++; |
| for (j = 0; j < 35; j++) { |
| if ((nBits == runcodes_len[j]) && (nVal == runcodes[j])) { |
| break; |
| } |
| } |
| if (j < 35) { |
| break; |
| } |
| } |
| runcode = j; |
| if (runcode < 32) { |
| SBSYMCODES[i].codelen = runcode; |
| run = 0; |
| } else if (runcode == 32) { |
| if (pStream->readNBits(2, &nTemp) != 0) { |
| goto failed; |
| } |
| run = nTemp + 3; |
| } else if (runcode == 33) { |
| if (pStream->readNBits(3, &nTemp) != 0) { |
| goto failed; |
| } |
| run = nTemp + 3; |
| } else if (runcode == 34) { |
| if (pStream->readNBits(7, &nTemp) != 0) { |
| goto failed; |
| } |
| run = nTemp + 11; |
| } |
| if (run > 0) { |
| if (i + run > (int)SBNUMSYMS) { |
| goto failed; |
| } |
| for (j = 0; j < run; j++) { |
| if (runcode == 32 && i > 0) { |
| SBSYMCODES[i + j].codelen = SBSYMCODES[i - 1].codelen; |
| } else { |
| SBSYMCODES[i + j].codelen = 0; |
| } |
| } |
| i += run; |
| } else { |
| i++; |
| } |
| } |
| huffman_assign_code(SBSYMCODES, SBNUMSYMS); |
| return SBSYMCODES; |
| failed: |
| m_pModule->JBig2_Free(SBSYMCODES); |
| return NULL; |
| } |
| void CJBig2_Context::huffman_assign_code(int* CODES, int* PREFLEN, int NTEMP) { |
| int CURLEN, LENMAX, CURCODE, CURTEMP, i; |
| int* LENCOUNT; |
| int* FIRSTCODE; |
| LENMAX = 0; |
| for (i = 0; i < NTEMP; i++) { |
| if (PREFLEN[i] > LENMAX) { |
| LENMAX = PREFLEN[i]; |
| } |
| } |
| LENCOUNT = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1)); |
| JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1)); |
| FIRSTCODE = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1)); |
| for (i = 0; i < NTEMP; i++) { |
| LENCOUNT[PREFLEN[i]]++; |
| } |
| CURLEN = 1; |
| FIRSTCODE[0] = 0; |
| LENCOUNT[0] = 0; |
| while (CURLEN <= LENMAX) { |
| FIRSTCODE[CURLEN] = (FIRSTCODE[CURLEN - 1] + LENCOUNT[CURLEN - 1]) << 1; |
| CURCODE = FIRSTCODE[CURLEN]; |
| CURTEMP = 0; |
| while (CURTEMP < NTEMP) { |
| if (PREFLEN[CURTEMP] == CURLEN) { |
| CODES[CURTEMP] = CURCODE; |
| CURCODE = CURCODE + 1; |
| } |
| CURTEMP = CURTEMP + 1; |
| } |
| CURLEN = CURLEN + 1; |
| } |
| m_pModule->JBig2_Free(LENCOUNT); |
| m_pModule->JBig2_Free(FIRSTCODE); |
| } |
| void CJBig2_Context::huffman_assign_code(JBig2HuffmanCode* SBSYMCODES, |
| int NTEMP) { |
| int CURLEN, LENMAX, CURCODE, CURTEMP, i; |
| int* LENCOUNT; |
| int* FIRSTCODE; |
| LENMAX = 0; |
| for (i = 0; i < NTEMP; i++) { |
| if (SBSYMCODES[i].codelen > LENMAX) { |
| LENMAX = SBSYMCODES[i].codelen; |
| } |
| } |
| LENCOUNT = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1)); |
| JBIG2_memset(LENCOUNT, 0, sizeof(int) * (LENMAX + 1)); |
| FIRSTCODE = (int*)m_pModule->JBig2_Malloc2(sizeof(int), (LENMAX + 1)); |
| for (i = 0; i < NTEMP; i++) { |
| LENCOUNT[SBSYMCODES[i].codelen]++; |
| } |
| CURLEN = 1; |
| FIRSTCODE[0] = 0; |
| LENCOUNT[0] = 0; |
| while (CURLEN <= LENMAX) { |
| FIRSTCODE[CURLEN] = (FIRSTCODE[CURLEN - 1] + LENCOUNT[CURLEN - 1]) << 1; |
| CURCODE = FIRSTCODE[CURLEN]; |
| CURTEMP = 0; |
| while (CURTEMP < NTEMP) { |
| if (SBSYMCODES[CURTEMP].codelen == CURLEN) { |
| SBSYMCODES[CURTEMP].code = CURCODE; |
| CURCODE = CURCODE + 1; |
| } |
| CURTEMP = CURTEMP + 1; |
| } |
| CURLEN = CURLEN + 1; |
| } |
| m_pModule->JBig2_Free(LENCOUNT); |
| m_pModule->JBig2_Free(FIRSTCODE); |
| } |
