| // 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 "../../../include/fxcodec/fx_codec.h" | |
| #include "codec_int.h" | |
| CCodec_ModuleMgr::CCodec_ModuleMgr() | |
| { | |
| m_pBasicModule = FX_NEW CCodec_BasicModule; | |
| m_pFaxModule = FX_NEW CCodec_FaxModule; | |
| m_pJpegModule = FX_NEW CCodec_JpegModule; | |
| m_pJpxModule = FX_NEW CCodec_JpxModule; | |
| m_pJbig2Module = FX_NEW CCodec_Jbig2Module; | |
| m_pIccModule = FX_NEW CCodec_IccModule; | |
| m_pFlateModule = FX_NEW CCodec_FlateModule; | |
| } | |
| CCodec_ModuleMgr::~CCodec_ModuleMgr() | |
| { | |
| delete m_pBasicModule; | |
| delete m_pFaxModule; | |
| delete m_pJpegModule; | |
| delete m_pFlateModule; | |
| delete m_pJpxModule; | |
| delete m_pJbig2Module; | |
| delete m_pIccModule; | |
| } | |
| void CCodec_ModuleMgr::InitJbig2Decoder() | |
| { | |
| } | |
| void CCodec_ModuleMgr::InitJpxDecoder() | |
| { | |
| } | |
| void CCodec_ModuleMgr::InitIccDecoder() | |
| { | |
| } | |
| CCodec_ScanlineDecoder::CCodec_ScanlineDecoder() | |
| { | |
| m_NextLine = -1; | |
| m_pDataCache = NULL; | |
| m_pLastScanline = NULL; | |
| } | |
| CCodec_ScanlineDecoder::~CCodec_ScanlineDecoder() | |
| { | |
| if (m_pDataCache) { | |
| FX_Free(m_pDataCache); | |
| } | |
| } | |
| FX_LPBYTE CCodec_ScanlineDecoder::GetScanline(int line) | |
| { | |
| if (m_pDataCache && line < m_pDataCache->m_nCachedLines) { | |
| return &m_pDataCache->m_Data + line * m_Pitch; | |
| } | |
| if (m_NextLine == line + 1) { | |
| return m_pLastScanline; | |
| } | |
| if (m_NextLine < 0 || m_NextLine > line) { | |
| if (!v_Rewind()) { | |
| return NULL; | |
| } | |
| m_NextLine = 0; | |
| } | |
| while (m_NextLine < line) { | |
| ReadNextLine(); | |
| m_NextLine ++; | |
| } | |
| m_pLastScanline = ReadNextLine(); | |
| m_NextLine ++; | |
| return m_pLastScanline; | |
| } | |
| FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause) | |
| { | |
| if (m_pDataCache && line < m_pDataCache->m_nCachedLines) { | |
| return FALSE; | |
| } | |
| if (m_NextLine == line || m_NextLine == line + 1) { | |
| return FALSE; | |
| } | |
| if (m_NextLine < 0 || m_NextLine > line) { | |
| v_Rewind(); | |
| m_NextLine = 0; | |
| } | |
| m_pLastScanline = NULL; | |
| while (m_NextLine < line) { | |
| m_pLastScanline = ReadNextLine(); | |
| m_NextLine ++; | |
| if (pPause && pPause->NeedToPauseNow()) { | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| FX_LPBYTE CCodec_ScanlineDecoder::ReadNextLine() | |
| { | |
| FX_LPBYTE pLine = v_GetNextLine(); | |
| if (pLine == NULL) { | |
| return NULL; | |
| } | |
| if (m_pDataCache && m_NextLine == m_pDataCache->m_nCachedLines) { | |
| FXSYS_memcpy32(&m_pDataCache->m_Data + m_NextLine * m_Pitch, pLine, m_Pitch); | |
| m_pDataCache->m_nCachedLines ++; | |
| } | |
| return pLine; | |
| } | |
| void CCodec_ScanlineDecoder::DownScale(int dest_width, int dest_height) | |
| { | |
| if (dest_width < 0) { | |
| dest_width = -dest_width; | |
| } | |
| if (dest_height < 0) { | |
| dest_height = -dest_height; | |
| } | |
| v_DownScale(dest_width, dest_height); | |
| if (m_pDataCache) { | |
| if (m_pDataCache->m_Height == m_OutputHeight && m_pDataCache->m_Width == m_OutputWidth) { | |
| return; | |
| } | |
| FX_Free(m_pDataCache); | |
| m_pDataCache = NULL; | |
| } | |
| m_pDataCache = (CCodec_ImageDataCache*)FXMEM_DefaultAlloc( | |
| sizeof(CCodec_ImageDataCache) + m_Pitch * m_OutputHeight, FXMEM_NONLEAVE); | |
| if (m_pDataCache == NULL) { | |
| return; | |
| } | |
| m_pDataCache->m_Height = m_OutputHeight; | |
| m_pDataCache->m_Width = m_OutputWidth; | |
| m_pDataCache->m_nCachedLines = 0; | |
| } | |
| FX_BOOL CCodec_BasicModule::RunLengthEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, | |
| FX_DWORD& dest_size) | |
| { | |
| return FALSE; | |
| } | |
| extern "C" double FXstrtod(const char* nptr, char** endptr) | |
| { | |
| double ret = 0.0; | |
| const char* ptr = nptr; | |
| const char* exp_ptr = NULL; | |
| int e_number = 0, | |
| e_signal = 0, | |
| e_point = 0, | |
| is_negative = 0; | |
| int exp_ret = 0, exp_sig = 1, | |
| fra_ret = 0, fra_count = 0, fra_base = 1; | |
| if(nptr == NULL) { | |
| return 0.0; | |
| } | |
| for (;; ptr++) { | |
| if(!e_number && !e_point && (*ptr == '\t' || *ptr == ' ')) { | |
| continue; | |
| } | |
| if(*ptr >= '0' && *ptr <= '9') { | |
| if(!e_number) { | |
| e_number = 1; | |
| } | |
| if(!e_point) { | |
| ret *= 10; | |
| ret += (*ptr - '0'); | |
| } else { | |
| fra_count++; | |
| fra_ret *= 10; | |
| fra_ret += (*ptr - '0'); | |
| } | |
| continue; | |
| } | |
| if(!e_point && *ptr == '.') { | |
| e_point = 1; | |
| continue; | |
| } | |
| if(!e_number && !e_point && !e_signal) { | |
| switch(*ptr) { | |
| case '-': | |
| is_negative = 1; | |
| case '+': | |
| e_signal = 1; | |
| continue; | |
| } | |
| } | |
| if(e_number && (*ptr == 'e' || *ptr == 'E')) { | |
| #define EXPONENT_DETECT(ptr) \ | |
| for(;;ptr++){ \ | |
| if(*ptr < '0' || *ptr > '9'){ \ | |
| if(endptr) *endptr = (char*)ptr; \ | |
| break; \ | |
| }else{ \ | |
| exp_ret *= 10; \ | |
| exp_ret += (*ptr - '0'); \ | |
| continue; \ | |
| } \ | |
| } | |
| exp_ptr = ptr++; | |
| if(*ptr == '+' || *ptr == '-') { | |
| exp_sig = (*ptr++ == '+') ? 1 : -1; | |
| if(*ptr < '0' || *ptr > '9') { | |
| if(endptr) { | |
| *endptr = (char*)exp_ptr; | |
| } | |
| break; | |
| } | |
| EXPONENT_DETECT(ptr); | |
| } else if(*ptr >= '0' && *ptr <= '9') { | |
| EXPONENT_DETECT(ptr); | |
| } else { | |
| if(endptr) { | |
| *endptr = (char*)exp_ptr; | |
| } | |
| break; | |
| } | |
| #undef EXPONENT_DETECT | |
| break; | |
| } | |
| if(ptr != nptr && !e_number) { | |
| if(endptr) { | |
| *endptr = (char*)nptr; | |
| } | |
| break; | |
| } | |
| if(endptr) { | |
| *endptr = (char*)ptr; | |
| } | |
| break; | |
| } | |
| while(fra_count--) { | |
| fra_base *= 10; | |
| } | |
| ret += (double)fra_ret / (double)fra_base; | |
| if(exp_sig == 1) { | |
| while(exp_ret--) { | |
| ret *= 10.0; | |
| } | |
| } else { | |
| while(exp_ret--) { | |
| ret /= 10.0; | |
| } | |
| } | |
| return is_negative ? -ret : ret; | |
| } | |
| FX_BOOL CCodec_BasicModule::A85Encode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, | |
| FX_DWORD& dest_size) | |
| { | |
| return FALSE; | |
| } | |
| CCodec_ModuleMgr* CCodec_ModuleMgr::Create() | |
| { | |
| return FX_NEW CCodec_ModuleMgr; | |
| } | |
| void CCodec_ModuleMgr::Destroy() | |
| { | |
| delete this; | |
| } | |
| class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder | |
| { | |
| public: | |
| CCodec_RLScanlineDecoder(); | |
| virtual ~CCodec_RLScanlineDecoder(); | |
| FX_BOOL Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc); | |
| virtual void v_DownScale(int dest_width, int dest_height) {} | |
| virtual FX_BOOL v_Rewind(); | |
| virtual FX_LPBYTE v_GetNextLine(); | |
| virtual FX_DWORD GetSrcOffset() | |
| { | |
| return m_SrcOffset; | |
| } | |
| protected: | |
| FX_BOOL CheckDestSize(); | |
| void GetNextOperator(); | |
| void UpdateOperator(FX_BYTE used_bytes); | |
| FX_LPBYTE m_pScanline; | |
| FX_LPCBYTE m_pSrcBuf; | |
| FX_DWORD m_SrcSize; | |
| FX_DWORD m_dwLineBytes; | |
| FX_DWORD m_SrcOffset; | |
| FX_BOOL m_bEOD; | |
| FX_BYTE m_Operator; | |
| }; | |
| CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder() | |
| : m_pScanline(NULL) | |
| , m_pSrcBuf(NULL) | |
| , m_SrcSize(0) | |
| , m_dwLineBytes(0) | |
| , m_SrcOffset(0) | |
| , m_bEOD(FALSE) | |
| , m_Operator(0) | |
| { | |
| } | |
| CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() | |
| { | |
| if (m_pScanline) { | |
| FX_Free(m_pScanline); | |
| } | |
| } | |
| FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize() | |
| { | |
| FX_DWORD i = 0; | |
| FX_DWORD old_size = 0; | |
| FX_DWORD dest_size = 0; | |
| while (i < m_SrcSize) { | |
| if (m_pSrcBuf[i] < 128) { | |
| old_size = dest_size; | |
| dest_size += m_pSrcBuf[i] + 1; | |
| if (dest_size < old_size) { | |
| return FALSE; | |
| } | |
| i += m_pSrcBuf[i] + 2; | |
| } else if (m_pSrcBuf[i] > 128) { | |
| old_size = dest_size; | |
| dest_size += 257 - m_pSrcBuf[i]; | |
| if (dest_size < old_size) { | |
| return FALSE; | |
| } | |
| i += 2; | |
| } else { | |
| break; | |
| } | |
| } | |
| if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 > dest_size) { | |
| return FALSE; | |
| } | |
| return TRUE; | |
| } | |
| FX_BOOL CCodec_RLScanlineDecoder::Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc) | |
| { | |
| m_pSrcBuf = src_buf; | |
| m_SrcSize = src_size; | |
| m_OutputWidth = m_OrigWidth = width; | |
| m_OutputHeight = m_OrigHeight = height; | |
| m_nComps = nComps; | |
| m_bpc = bpc; | |
| m_bColorTransformed = FALSE; | |
| m_DownScale = 1; | |
| m_Pitch = (width * nComps * bpc + 31) / 32 * 4; | |
| m_dwLineBytes = (width * nComps * bpc + 7) / 8; | |
| m_pScanline = FX_Alloc(FX_BYTE, m_Pitch); | |
| if (m_pScanline == NULL) { | |
| return FALSE; | |
| } | |
| FXSYS_memset32(m_pScanline, 0, m_Pitch); | |
| return CheckDestSize(); | |
| } | |
| FX_BOOL CCodec_RLScanlineDecoder::v_Rewind() | |
| { | |
| FXSYS_memset32(m_pScanline, 0, m_Pitch); | |
| m_SrcOffset = 0; | |
| m_bEOD = FALSE; | |
| m_Operator = 0; | |
| return TRUE; | |
| } | |
| FX_LPBYTE CCodec_RLScanlineDecoder::v_GetNextLine() | |
| { | |
| if (m_SrcOffset == 0) { | |
| GetNextOperator(); | |
| } else { | |
| if (m_bEOD) { | |
| return NULL; | |
| } | |
| } | |
| FXSYS_memset32(m_pScanline, 0, m_Pitch); | |
| FX_DWORD col_pos = 0; | |
| FX_BOOL eol = FALSE; | |
| while (m_SrcOffset < m_SrcSize && !eol) { | |
| if (m_Operator < 128) { | |
| FX_DWORD copy_len = m_Operator + 1; | |
| if (col_pos + copy_len >= m_dwLineBytes) { | |
| copy_len = m_dwLineBytes - col_pos; | |
| eol = TRUE; | |
| } | |
| if (copy_len >= m_SrcSize - m_SrcOffset) { | |
| copy_len = m_SrcSize - m_SrcOffset; | |
| m_bEOD = TRUE; | |
| } | |
| FXSYS_memcpy32(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len); | |
| col_pos += copy_len; | |
| UpdateOperator((FX_BYTE)copy_len); | |
| } else if (m_Operator > 128) { | |
| int fill = 0; | |
| if (m_SrcOffset - 1 < m_SrcSize - 1) { | |
| fill = m_pSrcBuf[m_SrcOffset]; | |
| } | |
| FX_DWORD duplicate_len = 257 - m_Operator; | |
| if (col_pos + duplicate_len >= m_dwLineBytes) { | |
| duplicate_len = m_dwLineBytes - col_pos; | |
| eol = TRUE; | |
| } | |
| FXSYS_memset8(m_pScanline + col_pos, fill, duplicate_len); | |
| col_pos += duplicate_len; | |
| UpdateOperator((FX_BYTE)duplicate_len); | |
| } else { | |
| m_bEOD = TRUE; | |
| break; | |
| } | |
| } | |
| return m_pScanline; | |
| } | |
| void CCodec_RLScanlineDecoder::GetNextOperator() | |
| { | |
| if (m_SrcOffset >= m_SrcSize) { | |
| m_Operator = 128; | |
| return; | |
| } | |
| m_Operator = m_pSrcBuf[m_SrcOffset]; | |
| m_SrcOffset ++; | |
| } | |
| void CCodec_RLScanlineDecoder::UpdateOperator(FX_BYTE used_bytes) | |
| { | |
| if (used_bytes == 0) { | |
| return; | |
| } | |
| if (m_Operator < 128) { | |
| FXSYS_assert((FX_DWORD)m_Operator + 1 >= used_bytes); | |
| if (used_bytes == m_Operator + 1) { | |
| m_SrcOffset += used_bytes; | |
| GetNextOperator(); | |
| return; | |
| } | |
| m_Operator -= used_bytes; | |
| m_SrcOffset += used_bytes; | |
| if (m_SrcOffset >= m_SrcSize) { | |
| m_Operator = 128; | |
| } | |
| return; | |
| } | |
| FX_BYTE count = 257 - m_Operator; | |
| FXSYS_assert((FX_DWORD)count >= used_bytes); | |
| if (used_bytes == count) { | |
| m_SrcOffset ++; | |
| GetNextOperator(); | |
| return; | |
| } | |
| count -= used_bytes; | |
| m_Operator = 257 - count; | |
| } | |
| ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height, | |
| int nComps, int bpc) | |
| { | |
| CCodec_RLScanlineDecoder* pRLScanlineDecoder = FX_NEW CCodec_RLScanlineDecoder; | |
| if (pRLScanlineDecoder == NULL) { | |
| return NULL; | |
| } | |
| if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps, bpc)) { | |
| delete pRLScanlineDecoder; | |
| return NULL; | |
| } | |
| return pRLScanlineDecoder; | |
| } |