Index: core/src/fxcodec/codec/fx_codec_flate.cpp |
diff --git a/core/src/fxcodec/codec/fx_codec_flate.cpp b/core/src/fxcodec/codec/fx_codec_flate.cpp |
index d129e36392d0dae8e6614407c1b7448d37da2e84..91d28b055394ae5a9ae9fe504b09f2cc645ebe94 100644 |
--- a/core/src/fxcodec/codec/fx_codec_flate.cpp |
+++ b/core/src/fxcodec/codec/fx_codec_flate.cpp |
@@ -10,911 +10,968 @@ |
#include "../../../include/fxcodec/fx_codec_flate.h" |
#include "codec_int.h" |
-extern "C" |
-{ |
- static void* my_alloc_func(void* opaque, unsigned int items, unsigned int size) |
- { |
- return FX_Alloc2D(uint8_t, items, size); |
- } |
- static void my_free_func(void* opaque, void* address) |
- { |
- FX_Free(address); |
- } |
- static int FPDFAPI_FlateGetTotalOut(void* context) |
- { |
- return ((z_stream*)context)->total_out; |
- } |
- static int FPDFAPI_FlateGetTotalIn(void* context) |
- { |
- return ((z_stream*)context)->total_in; |
- } |
- static void FPDFAPI_FlateCompress(unsigned char* dest_buf, |
- unsigned long* dest_size, |
- const unsigned char* src_buf, |
- unsigned long src_size) |
- { |
- compress(dest_buf, dest_size, src_buf, src_size); |
- } |
- void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int), |
- void (*free_func)(void*, void*)) |
- { |
- z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream)); |
- if (p == NULL) { |
- return NULL; |
- } |
- FXSYS_memset(p, 0, sizeof(z_stream)); |
- p->zalloc = alloc_func; |
- p->zfree = free_func; |
- inflateInit(p); |
- return p; |
- } |
- void FPDFAPI_FlateInput(void* context, const unsigned char* src_buf, unsigned int src_size) |
- { |
- ((z_stream*)context)->next_in = (unsigned char*)src_buf; |
- ((z_stream*)context)->avail_in = src_size; |
- } |
- int FPDFAPI_FlateOutput(void* context, unsigned char* dest_buf, unsigned int dest_size) |
- { |
- ((z_stream*)context)->next_out = dest_buf; |
- ((z_stream*)context)->avail_out = dest_size; |
- unsigned int pre_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context); |
- int ret = inflate((z_stream*)context, Z_SYNC_FLUSH); |
- unsigned int post_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context); |
- unsigned int written = post_pos - pre_pos; |
- if (written < dest_size) { |
- FXSYS_memset(dest_buf + written, '\0', dest_size - written); |
- } |
- return ret; |
- } |
- int FPDFAPI_FlateGetAvailIn(void* context) |
- { |
- return ((z_stream*)context)->avail_in; |
- } |
- int FPDFAPI_FlateGetAvailOut(void* context) |
- { |
- return ((z_stream*)context)->avail_out; |
- } |
- void FPDFAPI_FlateEnd(void* context) |
- { |
- inflateEnd((z_stream*)context); |
- ((z_stream*)context)->zfree(0, context); |
- } |
+extern "C" { |
+static void* my_alloc_func(void* opaque, |
+ unsigned int items, |
+ unsigned int size) { |
+ return FX_Alloc2D(uint8_t, items, size); |
+} |
+static void my_free_func(void* opaque, void* address) { |
+ FX_Free(address); |
+} |
+static int FPDFAPI_FlateGetTotalOut(void* context) { |
+ return ((z_stream*)context)->total_out; |
+} |
+static int FPDFAPI_FlateGetTotalIn(void* context) { |
+ return ((z_stream*)context)->total_in; |
+} |
+static void FPDFAPI_FlateCompress(unsigned char* dest_buf, |
+ unsigned long* dest_size, |
+ const unsigned char* src_buf, |
+ unsigned long src_size) { |
+ compress(dest_buf, dest_size, src_buf, src_size); |
+} |
+void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int), |
+ void (*free_func)(void*, void*)) { |
+ z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream)); |
+ if (p == NULL) { |
+ return NULL; |
+ } |
+ FXSYS_memset(p, 0, sizeof(z_stream)); |
+ p->zalloc = alloc_func; |
+ p->zfree = free_func; |
+ inflateInit(p); |
+ return p; |
+} |
+void FPDFAPI_FlateInput(void* context, |
+ const unsigned char* src_buf, |
+ unsigned int src_size) { |
+ ((z_stream*)context)->next_in = (unsigned char*)src_buf; |
+ ((z_stream*)context)->avail_in = src_size; |
+} |
+int FPDFAPI_FlateOutput(void* context, |
+ unsigned char* dest_buf, |
+ unsigned int dest_size) { |
+ ((z_stream*)context)->next_out = dest_buf; |
+ ((z_stream*)context)->avail_out = dest_size; |
+ unsigned int pre_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context); |
+ int ret = inflate((z_stream*)context, Z_SYNC_FLUSH); |
+ unsigned int post_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context); |
+ unsigned int written = post_pos - pre_pos; |
+ if (written < dest_size) { |
+ FXSYS_memset(dest_buf + written, '\0', dest_size - written); |
+ } |
+ return ret; |
+} |
+int FPDFAPI_FlateGetAvailIn(void* context) { |
+ return ((z_stream*)context)->avail_in; |
+} |
+int FPDFAPI_FlateGetAvailOut(void* context) { |
+ return ((z_stream*)context)->avail_out; |
+} |
+void FPDFAPI_FlateEnd(void* context) { |
+ inflateEnd((z_stream*)context); |
+ ((z_stream*)context)->zfree(0, context); |
+} |
} // extern "C" |
-class CLZWDecoder |
-{ |
-public: |
- int Decode(uint8_t* output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, FX_BOOL bEarlyChange); |
+class CLZWDecoder { |
+ public: |
+ int Decode(uint8_t* output, |
+ FX_DWORD& outlen, |
+ const uint8_t* input, |
+ FX_DWORD& size, |
+ FX_BOOL bEarlyChange); |
-private: |
- void AddCode(FX_DWORD prefix_code, uint8_t append_char); |
- void DecodeString(FX_DWORD code); |
+ private: |
+ void AddCode(FX_DWORD prefix_code, uint8_t append_char); |
+ void DecodeString(FX_DWORD code); |
- FX_DWORD m_InPos; |
- FX_DWORD m_OutPos; |
- uint8_t* m_pOutput; |
- const uint8_t* m_pInput; |
- FX_BOOL m_Early; |
- FX_DWORD m_CodeArray[5021]; |
- FX_DWORD m_nCodes; |
- uint8_t m_DecodeStack[4000]; |
- FX_DWORD m_StackLen; |
- int m_CodeLen; |
+ FX_DWORD m_InPos; |
+ FX_DWORD m_OutPos; |
+ uint8_t* m_pOutput; |
+ const uint8_t* m_pInput; |
+ FX_BOOL m_Early; |
+ FX_DWORD m_CodeArray[5021]; |
+ FX_DWORD m_nCodes; |
+ uint8_t m_DecodeStack[4000]; |
+ FX_DWORD m_StackLen; |
+ int m_CodeLen; |
}; |
-void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char) |
-{ |
- if (m_nCodes + m_Early == 4094) { |
- return; |
- } |
- m_CodeArray[m_nCodes ++] = (prefix_code << 16) | append_char; |
- if (m_nCodes + m_Early == 512 - 258) { |
- m_CodeLen = 10; |
- } else if (m_nCodes + m_Early == 1024 - 258) { |
- m_CodeLen = 11; |
- } else if (m_nCodes + m_Early == 2048 - 258) { |
- m_CodeLen = 12; |
- } |
+void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char) { |
+ if (m_nCodes + m_Early == 4094) { |
+ return; |
+ } |
+ m_CodeArray[m_nCodes++] = (prefix_code << 16) | append_char; |
+ if (m_nCodes + m_Early == 512 - 258) { |
+ m_CodeLen = 10; |
+ } else if (m_nCodes + m_Early == 1024 - 258) { |
+ m_CodeLen = 11; |
+ } else if (m_nCodes + m_Early == 2048 - 258) { |
+ m_CodeLen = 12; |
+ } |
} |
-void CLZWDecoder::DecodeString(FX_DWORD code) |
-{ |
- while (1) { |
- int index = code - 258; |
- if (index < 0 || index >= (int)m_nCodes) { |
- break; |
- } |
- FX_DWORD data = m_CodeArray[index]; |
- if (m_StackLen >= sizeof(m_DecodeStack)) { |
- return; |
- } |
- m_DecodeStack[m_StackLen++] = (uint8_t)data; |
- code = data >> 16; |
+void CLZWDecoder::DecodeString(FX_DWORD code) { |
+ while (1) { |
+ int index = code - 258; |
+ if (index < 0 || index >= (int)m_nCodes) { |
+ break; |
} |
+ FX_DWORD data = m_CodeArray[index]; |
if (m_StackLen >= sizeof(m_DecodeStack)) { |
- return; |
- } |
- m_DecodeStack[m_StackLen++] = (uint8_t)code; |
-} |
-int CLZWDecoder::Decode(uint8_t* dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, FX_BOOL bEarlyChange) |
-{ |
- m_CodeLen = 9; |
- m_InPos = 0; |
- m_OutPos = 0; |
- m_pInput = src_buf; |
- m_pOutput = dest_buf; |
- m_Early = bEarlyChange ? 1 : 0; |
- m_nCodes = 0; |
- FX_DWORD old_code = (FX_DWORD) - 1; |
- uint8_t last_char; |
- while (1) { |
- if (m_InPos + m_CodeLen > src_size * 8) { |
- break; |
- } |
- int byte_pos = m_InPos / 8; |
- int bit_pos = m_InPos % 8, bit_left = m_CodeLen; |
- FX_DWORD code = 0; |
- if (bit_pos) { |
- bit_left -= 8 - bit_pos; |
- code = (m_pInput[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left; |
- } |
- if (bit_left < 8) { |
- code |= m_pInput[byte_pos] >> (8 - bit_left); |
- } else { |
- bit_left -= 8; |
- code |= m_pInput[byte_pos++] << bit_left; |
- if (bit_left) { |
- code |= m_pInput[byte_pos] >> (8 - bit_left); |
- } |
- } |
- m_InPos += m_CodeLen; |
- if (code < 256) { |
- if (m_OutPos == dest_size) { |
- return -5; |
- } |
- if (m_pOutput) { |
- m_pOutput[m_OutPos] = (uint8_t)code; |
- } |
- m_OutPos ++; |
- last_char = (uint8_t)code; |
- if (old_code != (FX_DWORD) - 1) { |
- AddCode(old_code, last_char); |
- } |
- old_code = code; |
- } else if (code == 256) { |
- m_CodeLen = 9; |
- m_nCodes = 0; |
- old_code = (FX_DWORD) - 1; |
- } else if (code == 257) { |
- break; |
- } else { |
- if (old_code == (FX_DWORD) - 1) { |
- return 2; |
- } |
- m_StackLen = 0; |
- if (code >= m_nCodes + 258) { |
- if (m_StackLen < sizeof(m_DecodeStack)) { |
- m_DecodeStack[m_StackLen++] = last_char; |
- } |
- DecodeString(old_code); |
- } else { |
- DecodeString(code); |
- } |
- if (m_OutPos + m_StackLen > dest_size) { |
- return -5; |
- } |
- if (m_pOutput) { |
- for (FX_DWORD i = 0; i < m_StackLen; i ++) { |
- m_pOutput[m_OutPos + i] = m_DecodeStack[m_StackLen - i - 1]; |
- } |
- } |
- m_OutPos += m_StackLen; |
- last_char = m_DecodeStack[m_StackLen - 1]; |
- if (old_code < 256) { |
- AddCode(old_code, last_char); |
- } else if (old_code - 258 >= m_nCodes) { |
- dest_size = m_OutPos; |
- src_size = (m_InPos + 7) / 8; |
- return 0; |
- } else { |
- AddCode(old_code, last_char); |
- } |
- old_code = code; |
- } |
- } |
- dest_size = m_OutPos; |
- src_size = (m_InPos + 7) / 8; |
- return 0; |
-} |
-static uint8_t PaethPredictor(int a, int b, int c) |
-{ |
- int p = a + b - c; |
- int pa = FXSYS_abs(p - a); |
- int pb = FXSYS_abs(p - b); |
- int pc = FXSYS_abs(p - c); |
- if (pa <= pb && pa <= pc) { |
- return (uint8_t)a; |
- } |
- if (pb <= pc) { |
- return (uint8_t)b; |
- } |
- return (uint8_t)c; |
-} |
-static FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size, |
- int predictor, int Colors, |
- int BitsPerComponent, int Columns) |
-{ |
- const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8; |
- const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
- if (row_size <= 0) |
- return FALSE; |
- const int row_count = (data_size + row_size - 1) / row_size; |
- const int last_row_size = data_size % row_size; |
- uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count); |
- int byte_cnt = 0; |
- uint8_t* pSrcData = data_buf; |
- uint8_t* pDestData = dest_buf; |
- for (int row = 0; row < row_count; row++) { |
- if (predictor == 10) { |
- pDestData[0] = 0; |
- int move_size = row_size; |
- if (move_size * (row + 1) > (int)data_size) { |
- move_size = data_size - (move_size * row); |
- } |
- FXSYS_memmove(pDestData + 1, pSrcData, move_size); |
- pDestData += (move_size + 1); |
- pSrcData += move_size; |
- byte_cnt += move_size; |
- continue; |
- } |
- for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) { |
- switch (predictor) { |
- case 11: { |
- pDestData[0] = 1; |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pSrcData[byte - BytesPerPixel]; |
- } |
- pDestData[byte + 1] = pSrcData[byte] - left; |
- } |
- break; |
- case 12: { |
- pDestData[0] = 2; |
- uint8_t up = 0; |
- if (row) { |
- up = pSrcData[byte - row_size]; |
- } |
- pDestData[byte + 1] = pSrcData[byte] - up; |
- } |
- break; |
- case 13: { |
- pDestData[0] = 3; |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pSrcData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (row) { |
- up = pSrcData[byte - row_size]; |
- } |
- pDestData[byte + 1] = pSrcData[byte] - (left + up) / 2; |
- } |
- break; |
- case 14: { |
- pDestData[0] = 4; |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pSrcData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (row) { |
- up = pSrcData[byte - row_size]; |
- } |
- uint8_t upper_left = 0; |
- if (byte >= BytesPerPixel && row) { |
- upper_left = pSrcData[byte - row_size - BytesPerPixel]; |
- } |
- pDestData[byte + 1] = pSrcData[byte] - PaethPredictor(left, up, upper_left); |
- } |
- break; |
- default: { |
- pDestData[byte + 1] = pSrcData[byte]; |
- } |
- break; |
- } |
- byte_cnt++; |
- } |
- pDestData += (row_size + 1); |
- pSrcData += row_size; |
+ return; |
} |
- FX_Free(data_buf); |
- data_buf = dest_buf; |
- data_size = (row_size + 1) * row_count - (last_row_size > 0 ? (row_size - last_row_size) : 0); |
- return TRUE; |
-} |
-static void PNG_PredictLine(uint8_t* pDestData, const uint8_t* pSrcData, const uint8_t* pLastLine, |
- int bpc, int nColors, int nPixels) |
-{ |
- int row_size = (nPixels * bpc * nColors + 7) / 8; |
- int BytesPerPixel = (bpc * nColors + 7) / 8; |
+ m_DecodeStack[m_StackLen++] = (uint8_t)data; |
+ code = data >> 16; |
+ } |
+ if (m_StackLen >= sizeof(m_DecodeStack)) { |
+ return; |
+ } |
+ m_DecodeStack[m_StackLen++] = (uint8_t)code; |
+} |
+int CLZWDecoder::Decode(uint8_t* dest_buf, |
+ FX_DWORD& dest_size, |
+ const uint8_t* src_buf, |
+ FX_DWORD& src_size, |
+ FX_BOOL bEarlyChange) { |
+ m_CodeLen = 9; |
+ m_InPos = 0; |
+ m_OutPos = 0; |
+ m_pInput = src_buf; |
+ m_pOutput = dest_buf; |
+ m_Early = bEarlyChange ? 1 : 0; |
+ m_nCodes = 0; |
+ FX_DWORD old_code = (FX_DWORD)-1; |
+ uint8_t last_char; |
+ while (1) { |
+ if (m_InPos + m_CodeLen > src_size * 8) { |
+ break; |
+ } |
+ int byte_pos = m_InPos / 8; |
+ int bit_pos = m_InPos % 8, bit_left = m_CodeLen; |
+ FX_DWORD code = 0; |
+ if (bit_pos) { |
+ bit_left -= 8 - bit_pos; |
+ code = (m_pInput[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left; |
+ } |
+ if (bit_left < 8) { |
+ code |= m_pInput[byte_pos] >> (8 - bit_left); |
+ } else { |
+ bit_left -= 8; |
+ code |= m_pInput[byte_pos++] << bit_left; |
+ if (bit_left) { |
+ code |= m_pInput[byte_pos] >> (8 - bit_left); |
+ } |
+ } |
+ m_InPos += m_CodeLen; |
+ if (code < 256) { |
+ if (m_OutPos == dest_size) { |
+ return -5; |
+ } |
+ if (m_pOutput) { |
+ m_pOutput[m_OutPos] = (uint8_t)code; |
+ } |
+ m_OutPos++; |
+ last_char = (uint8_t)code; |
+ if (old_code != (FX_DWORD)-1) { |
+ AddCode(old_code, last_char); |
+ } |
+ old_code = code; |
+ } else if (code == 256) { |
+ m_CodeLen = 9; |
+ m_nCodes = 0; |
+ old_code = (FX_DWORD)-1; |
+ } else if (code == 257) { |
+ break; |
+ } else { |
+ if (old_code == (FX_DWORD)-1) { |
+ return 2; |
+ } |
+ m_StackLen = 0; |
+ if (code >= m_nCodes + 258) { |
+ if (m_StackLen < sizeof(m_DecodeStack)) { |
+ m_DecodeStack[m_StackLen++] = last_char; |
+ } |
+ DecodeString(old_code); |
+ } else { |
+ DecodeString(code); |
+ } |
+ if (m_OutPos + m_StackLen > dest_size) { |
+ return -5; |
+ } |
+ if (m_pOutput) { |
+ for (FX_DWORD i = 0; i < m_StackLen; i++) { |
+ m_pOutput[m_OutPos + i] = m_DecodeStack[m_StackLen - i - 1]; |
+ } |
+ } |
+ m_OutPos += m_StackLen; |
+ last_char = m_DecodeStack[m_StackLen - 1]; |
+ if (old_code < 256) { |
+ AddCode(old_code, last_char); |
+ } else if (old_code - 258 >= m_nCodes) { |
+ dest_size = m_OutPos; |
+ src_size = (m_InPos + 7) / 8; |
+ return 0; |
+ } else { |
+ AddCode(old_code, last_char); |
+ } |
+ old_code = code; |
+ } |
+ } |
+ dest_size = m_OutPos; |
+ src_size = (m_InPos + 7) / 8; |
+ return 0; |
+} |
+static uint8_t PaethPredictor(int a, int b, int c) { |
+ int p = a + b - c; |
+ int pa = FXSYS_abs(p - a); |
+ int pb = FXSYS_abs(p - b); |
+ int pc = FXSYS_abs(p - c); |
+ if (pa <= pb && pa <= pc) { |
+ return (uint8_t)a; |
+ } |
+ if (pb <= pc) { |
+ return (uint8_t)b; |
+ } |
+ return (uint8_t)c; |
+} |
+static FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf, |
+ FX_DWORD& data_size, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8; |
+ const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
+ if (row_size <= 0) |
+ return FALSE; |
+ const int row_count = (data_size + row_size - 1) / row_size; |
+ const int last_row_size = data_size % row_size; |
+ uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count); |
+ int byte_cnt = 0; |
+ uint8_t* pSrcData = data_buf; |
+ uint8_t* pDestData = dest_buf; |
+ for (int row = 0; row < row_count; row++) { |
+ if (predictor == 10) { |
+ pDestData[0] = 0; |
+ int move_size = row_size; |
+ if (move_size * (row + 1) > (int)data_size) { |
+ move_size = data_size - (move_size * row); |
+ } |
+ FXSYS_memmove(pDestData + 1, pSrcData, move_size); |
+ pDestData += (move_size + 1); |
+ pSrcData += move_size; |
+ byte_cnt += move_size; |
+ continue; |
+ } |
+ for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) { |
+ switch (predictor) { |
+ case 11: { |
+ pDestData[0] = 1; |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pSrcData[byte - BytesPerPixel]; |
+ } |
+ pDestData[byte + 1] = pSrcData[byte] - left; |
+ } break; |
+ case 12: { |
+ pDestData[0] = 2; |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pSrcData[byte - row_size]; |
+ } |
+ pDestData[byte + 1] = pSrcData[byte] - up; |
+ } break; |
+ case 13: { |
+ pDestData[0] = 3; |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pSrcData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pSrcData[byte - row_size]; |
+ } |
+ pDestData[byte + 1] = pSrcData[byte] - (left + up) / 2; |
+ } break; |
+ case 14: { |
+ pDestData[0] = 4; |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pSrcData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pSrcData[byte - row_size]; |
+ } |
+ uint8_t upper_left = 0; |
+ if (byte >= BytesPerPixel && row) { |
+ upper_left = pSrcData[byte - row_size - BytesPerPixel]; |
+ } |
+ pDestData[byte + 1] = |
+ pSrcData[byte] - PaethPredictor(left, up, upper_left); |
+ } break; |
+ default: { pDestData[byte + 1] = pSrcData[byte]; } break; |
+ } |
+ byte_cnt++; |
+ } |
+ pDestData += (row_size + 1); |
+ pSrcData += row_size; |
+ } |
+ FX_Free(data_buf); |
+ data_buf = dest_buf; |
+ data_size = (row_size + 1) * row_count - |
+ (last_row_size > 0 ? (row_size - last_row_size) : 0); |
+ return TRUE; |
+} |
+static void PNG_PredictLine(uint8_t* pDestData, |
+ const uint8_t* pSrcData, |
+ const uint8_t* pLastLine, |
+ int bpc, |
+ int nColors, |
+ int nPixels) { |
+ int row_size = (nPixels * bpc * nColors + 7) / 8; |
+ int BytesPerPixel = (bpc * nColors + 7) / 8; |
+ uint8_t tag = pSrcData[0]; |
+ if (tag == 0) { |
+ FXSYS_memmove(pDestData, pSrcData + 1, row_size); |
+ return; |
+ } |
+ for (int byte = 0; byte < row_size; byte++) { |
+ uint8_t raw_byte = pSrcData[byte + 1]; |
+ switch (tag) { |
+ case 1: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ pDestData[byte] = raw_byte + left; |
+ break; |
+ } |
+ case 2: { |
+ uint8_t up = 0; |
+ if (pLastLine) { |
+ up = pLastLine[byte]; |
+ } |
+ pDestData[byte] = raw_byte + up; |
+ break; |
+ } |
+ case 3: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (pLastLine) { |
+ up = pLastLine[byte]; |
+ } |
+ pDestData[byte] = raw_byte + (up + left) / 2; |
+ break; |
+ } |
+ case 4: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (pLastLine) { |
+ up = pLastLine[byte]; |
+ } |
+ uint8_t upper_left = 0; |
+ if (byte >= BytesPerPixel && pLastLine) { |
+ upper_left = pLastLine[byte - BytesPerPixel]; |
+ } |
+ pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left); |
+ break; |
+ } |
+ default: |
+ pDestData[byte] = raw_byte; |
+ break; |
+ } |
+ } |
+} |
+static FX_BOOL PNG_Predictor(uint8_t*& data_buf, |
+ FX_DWORD& data_size, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8; |
+ const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
+ if (row_size <= 0) |
+ return FALSE; |
+ const int row_count = (data_size + row_size) / (row_size + 1); |
+ const int last_row_size = data_size % (row_size + 1); |
+ uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count); |
+ int byte_cnt = 0; |
+ uint8_t* pSrcData = data_buf; |
+ uint8_t* pDestData = dest_buf; |
+ for (int row = 0; row < row_count; row++) { |
uint8_t tag = pSrcData[0]; |
+ byte_cnt++; |
if (tag == 0) { |
- FXSYS_memmove(pDestData, pSrcData + 1, row_size); |
- return; |
- } |
- for (int byte = 0; byte < row_size; byte ++) { |
- uint8_t raw_byte = pSrcData[byte + 1]; |
- switch (tag) { |
- case 1: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- pDestData[byte] = raw_byte + left; |
- break; |
- } |
- case 2: { |
- uint8_t up = 0; |
- if (pLastLine) { |
- up = pLastLine[byte]; |
- } |
- pDestData[byte] = raw_byte + up; |
- break; |
- } |
- case 3: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (pLastLine) { |
- up = pLastLine[byte]; |
- } |
- pDestData[byte] = raw_byte + (up + left) / 2; |
- break; |
- } |
- case 4: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (pLastLine) { |
- up = pLastLine[byte]; |
- } |
- uint8_t upper_left = 0; |
- if (byte >= BytesPerPixel && pLastLine) { |
- upper_left = pLastLine[byte - BytesPerPixel]; |
- } |
- pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left); |
- break; |
- } |
- default: |
- pDestData[byte] = raw_byte; |
- break; |
- } |
- } |
+ int move_size = row_size; |
+ if ((row + 1) * (move_size + 1) > (int)data_size) { |
+ move_size = last_row_size - 1; |
+ } |
+ FXSYS_memmove(pDestData, pSrcData + 1, move_size); |
+ pSrcData += move_size + 1; |
+ pDestData += move_size; |
+ byte_cnt += move_size; |
+ continue; |
+ } |
+ for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) { |
+ uint8_t raw_byte = pSrcData[byte + 1]; |
+ switch (tag) { |
+ case 1: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ pDestData[byte] = raw_byte + left; |
+ break; |
+ } |
+ case 2: { |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pDestData[byte - row_size]; |
+ } |
+ pDestData[byte] = raw_byte + up; |
+ break; |
+ } |
+ case 3: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pDestData[byte - row_size]; |
+ } |
+ pDestData[byte] = raw_byte + (up + left) / 2; |
+ break; |
+ } |
+ case 4: { |
+ uint8_t left = 0; |
+ if (byte >= BytesPerPixel) { |
+ left = pDestData[byte - BytesPerPixel]; |
+ } |
+ uint8_t up = 0; |
+ if (row) { |
+ up = pDestData[byte - row_size]; |
+ } |
+ uint8_t upper_left = 0; |
+ if (byte >= BytesPerPixel && row) { |
+ upper_left = pDestData[byte - row_size - BytesPerPixel]; |
+ } |
+ pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left); |
+ break; |
+ } |
+ default: |
+ pDestData[byte] = raw_byte; |
+ break; |
+ } |
+ byte_cnt++; |
+ } |
+ pSrcData += row_size + 1; |
+ pDestData += row_size; |
+ } |
+ FX_Free(data_buf); |
+ data_buf = dest_buf; |
+ data_size = row_size * row_count - |
+ (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0); |
+ return TRUE; |
} |
-static FX_BOOL PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size, |
- int Colors, int BitsPerComponent, int Columns) |
-{ |
- const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8; |
- const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
- if (row_size <= 0) |
- return FALSE; |
- const int row_count = (data_size + row_size) / (row_size + 1); |
- const int last_row_size = data_size % (row_size + 1); |
- uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count); |
- int byte_cnt = 0; |
- uint8_t* pSrcData = data_buf; |
- uint8_t* pDestData = dest_buf; |
- for (int row = 0; row < row_count; row ++) { |
- uint8_t tag = pSrcData[0]; |
- byte_cnt++; |
- if (tag == 0) { |
- int move_size = row_size; |
- if ((row + 1) * (move_size + 1) > (int)data_size) { |
- move_size = last_row_size - 1; |
- } |
- FXSYS_memmove(pDestData, pSrcData + 1, move_size); |
- pSrcData += move_size + 1; |
- pDestData += move_size; |
- byte_cnt += move_size; |
- continue; |
- } |
- for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte ++) { |
- uint8_t raw_byte = pSrcData[byte + 1]; |
- switch (tag) { |
- case 1: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- pDestData[byte] = raw_byte + left; |
- break; |
- } |
- case 2: { |
- uint8_t up = 0; |
- if (row) { |
- up = pDestData[byte - row_size]; |
- } |
- pDestData[byte] = raw_byte + up; |
- break; |
- } |
- case 3: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (row) { |
- up = pDestData[byte - row_size]; |
- } |
- pDestData[byte] = raw_byte + (up + left) / 2; |
- break; |
- } |
- case 4: { |
- uint8_t left = 0; |
- if (byte >= BytesPerPixel) { |
- left = pDestData[byte - BytesPerPixel]; |
- } |
- uint8_t up = 0; |
- if (row) { |
- up = pDestData[byte - row_size]; |
- } |
- uint8_t upper_left = 0; |
- if (byte >= BytesPerPixel && row) { |
- upper_left = pDestData[byte - row_size - BytesPerPixel]; |
- } |
- pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left); |
- break; |
- } |
- default: |
- pDestData[byte] = raw_byte; |
- break; |
- } |
- byte_cnt++; |
- } |
- pSrcData += row_size + 1; |
- pDestData += row_size; |
- } |
- FX_Free(data_buf); |
- data_buf = dest_buf; |
- data_size = row_size * row_count - (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0); |
- return TRUE; |
-} |
-static void TIFF_PredictorEncodeLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns) |
-{ |
- int BytesPerPixel = BitsPerComponent * Colors / 8; |
- if (BitsPerComponent < 8) { |
- uint8_t mask = 0x01; |
- if (BitsPerComponent == 2) { |
- mask = 0x03; |
- } else if (BitsPerComponent == 4) { |
- mask = 0x0F; |
- } |
- int row_bits = Colors * BitsPerComponent * Columns; |
- for (int i = row_bits - BitsPerComponent; i >= BitsPerComponent; i -= BitsPerComponent) { |
- int col = i % 8; |
- int index = i / 8; |
- int col_pre = (col == 0) ? (8 - BitsPerComponent) : (col - BitsPerComponent); |
- int index_pre = (col == 0) ? (index - 1) : index; |
- uint8_t cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask; |
- uint8_t left = (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask; |
- cur -= left; |
- cur &= mask; |
- cur <<= (8 - col - BitsPerComponent); |
- dest_buf[index] &= ~(mask << ((8 - col - BitsPerComponent))); |
- dest_buf[index] |= cur; |
- } |
- } else if (BitsPerComponent == 8) { |
- for (int i = row_size - 1; i >= BytesPerPixel; i--) { |
- dest_buf[i] -= dest_buf[i - BytesPerPixel]; |
- } |
- } else { |
- for (int i = row_size - BytesPerPixel; i >= BytesPerPixel; i -= BytesPerPixel) { |
- FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1]; |
- pixel -= (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1]; |
- dest_buf[i] = pixel >> 8; |
- dest_buf[i + 1] = (uint8_t)pixel; |
- } |
- } |
+static void TIFF_PredictorEncodeLine(uint8_t* dest_buf, |
+ int row_size, |
+ int BitsPerComponent, |
+ int Colors, |
+ int Columns) { |
+ int BytesPerPixel = BitsPerComponent * Colors / 8; |
+ if (BitsPerComponent < 8) { |
+ uint8_t mask = 0x01; |
+ if (BitsPerComponent == 2) { |
+ mask = 0x03; |
+ } else if (BitsPerComponent == 4) { |
+ mask = 0x0F; |
+ } |
+ int row_bits = Colors * BitsPerComponent * Columns; |
+ for (int i = row_bits - BitsPerComponent; i >= BitsPerComponent; |
+ i -= BitsPerComponent) { |
+ int col = i % 8; |
+ int index = i / 8; |
+ int col_pre = |
+ (col == 0) ? (8 - BitsPerComponent) : (col - BitsPerComponent); |
+ int index_pre = (col == 0) ? (index - 1) : index; |
+ uint8_t cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask; |
+ uint8_t left = |
+ (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask; |
+ cur -= left; |
+ cur &= mask; |
+ cur <<= (8 - col - BitsPerComponent); |
+ dest_buf[index] &= ~(mask << ((8 - col - BitsPerComponent))); |
+ dest_buf[index] |= cur; |
+ } |
+ } else if (BitsPerComponent == 8) { |
+ for (int i = row_size - 1; i >= BytesPerPixel; i--) { |
+ dest_buf[i] -= dest_buf[i - BytesPerPixel]; |
+ } |
+ } else { |
+ for (int i = row_size - BytesPerPixel; i >= BytesPerPixel; |
+ i -= BytesPerPixel) { |
+ FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1]; |
+ pixel -= |
+ (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1]; |
+ dest_buf[i] = pixel >> 8; |
+ dest_buf[i + 1] = (uint8_t)pixel; |
+ } |
+ } |
} |
-static FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size, |
- int Colors, int BitsPerComponent, int Columns) |
-{ |
- int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
- if (row_size == 0) |
- return FALSE; |
- const int row_count = (data_size + row_size - 1) / row_size; |
- const int last_row_size = data_size % row_size; |
- for (int row = 0; row < row_count; row++) { |
- uint8_t* scan_line = data_buf + row * row_size; |
- if ((row + 1) * row_size > (int)data_size) { |
- row_size = last_row_size; |
- } |
- TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors, Columns); |
- } |
- return TRUE; |
-} |
-static void TIFF_PredictLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns) |
-{ |
- if (BitsPerComponent == 1) { |
- int row_bits = FX_MIN(BitsPerComponent * Colors * Columns, row_size * 8); |
- int index_pre = 0; |
- int col_pre = 0; |
- for(int i = 1; i < row_bits; i ++) { |
- int col = i % 8; |
- int index = i / 8; |
- if( ((dest_buf[index] >> (7 - col)) & 1) ^ ((dest_buf[index_pre] >> (7 - col_pre)) & 1) ) { |
- dest_buf[index] |= 1 << (7 - col); |
- } else { |
- dest_buf[index] &= ~(1 << (7 - col)); |
- } |
- index_pre = index; |
- col_pre = col; |
- } |
- return; |
- } |
- int BytesPerPixel = BitsPerComponent * Colors / 8; |
- if (BitsPerComponent == 16) { |
- for (int i = BytesPerPixel; i < row_size; i += 2) { |
- FX_WORD pixel = (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1]; |
- pixel += (dest_buf[i] << 8) | dest_buf[i + 1]; |
- dest_buf[i] = pixel >> 8; |
- dest_buf[i + 1] = (uint8_t)pixel; |
- } |
- } else { |
- for (int i = BytesPerPixel; i < row_size; i ++) { |
- dest_buf[i] += dest_buf[i - BytesPerPixel]; |
- } |
- } |
+static FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf, |
+ FX_DWORD& data_size, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
+ if (row_size == 0) |
+ return FALSE; |
+ const int row_count = (data_size + row_size - 1) / row_size; |
+ const int last_row_size = data_size % row_size; |
+ for (int row = 0; row < row_count; row++) { |
+ uint8_t* scan_line = data_buf + row * row_size; |
+ if ((row + 1) * row_size > (int)data_size) { |
+ row_size = last_row_size; |
+ } |
+ TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors, |
+ Columns); |
+ } |
+ return TRUE; |
} |
-static FX_BOOL TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size, |
- int Colors, int BitsPerComponent, int Columns) |
-{ |
- int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
- if (row_size == 0) |
- return FALSE; |
- const int row_count = (data_size + row_size - 1) / row_size; |
- const int last_row_size = data_size % row_size; |
- for (int row = 0; row < row_count; row ++) { |
- uint8_t* scan_line = data_buf + row * row_size; |
- if ((row + 1) * row_size > (int)data_size) { |
- row_size = last_row_size; |
- } |
- TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns); |
+static void TIFF_PredictLine(uint8_t* dest_buf, |
+ int row_size, |
+ int BitsPerComponent, |
+ int Colors, |
+ int Columns) { |
+ if (BitsPerComponent == 1) { |
+ int row_bits = FX_MIN(BitsPerComponent * Colors * Columns, row_size * 8); |
+ int index_pre = 0; |
+ int col_pre = 0; |
+ for (int i = 1; i < row_bits; i++) { |
+ int col = i % 8; |
+ int index = i / 8; |
+ if (((dest_buf[index] >> (7 - col)) & 1) ^ |
+ ((dest_buf[index_pre] >> (7 - col_pre)) & 1)) { |
+ dest_buf[index] |= 1 << (7 - col); |
+ } else { |
+ dest_buf[index] &= ~(1 << (7 - col)); |
+ } |
+ index_pre = index; |
+ col_pre = col; |
} |
- return TRUE; |
-} |
-class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder |
-{ |
-public: |
- CCodec_FlateScanlineDecoder(); |
- ~CCodec_FlateScanlineDecoder(); |
- void Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc, |
- int predictor, int Colors, int BitsPerComponent, int Columns); |
- virtual void Destroy() |
- { |
- delete this; |
- } |
- virtual void v_DownScale(int dest_width, int dest_height) {} |
- virtual FX_BOOL v_Rewind(); |
- virtual uint8_t* v_GetNextLine(); |
- virtual FX_DWORD GetSrcOffset(); |
- void* m_pFlate; |
- const uint8_t* m_SrcBuf; |
- FX_DWORD m_SrcSize; |
- uint8_t* m_pScanline; |
- uint8_t* m_pLastLine; |
- uint8_t* m_pPredictBuffer; |
- uint8_t* m_pPredictRaw; |
- int m_Predictor; |
- int m_Colors, m_BitsPerComponent, m_Columns, m_PredictPitch, m_LeftOver; |
+ return; |
+ } |
+ int BytesPerPixel = BitsPerComponent * Colors / 8; |
+ if (BitsPerComponent == 16) { |
+ for (int i = BytesPerPixel; i < row_size; i += 2) { |
+ FX_WORD pixel = |
+ (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1]; |
+ pixel += (dest_buf[i] << 8) | dest_buf[i + 1]; |
+ dest_buf[i] = pixel >> 8; |
+ dest_buf[i + 1] = (uint8_t)pixel; |
+ } |
+ } else { |
+ for (int i = BytesPerPixel; i < row_size; i++) { |
+ dest_buf[i] += dest_buf[i - BytesPerPixel]; |
+ } |
+ } |
+} |
+static FX_BOOL TIFF_Predictor(uint8_t*& data_buf, |
+ FX_DWORD& data_size, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ int row_size = (Colors * BitsPerComponent * Columns + 7) / 8; |
+ if (row_size == 0) |
+ return FALSE; |
+ const int row_count = (data_size + row_size - 1) / row_size; |
+ const int last_row_size = data_size % row_size; |
+ for (int row = 0; row < row_count; row++) { |
+ uint8_t* scan_line = data_buf + row * row_size; |
+ if ((row + 1) * row_size > (int)data_size) { |
+ row_size = last_row_size; |
+ } |
+ TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns); |
+ } |
+ return TRUE; |
+} |
+class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder { |
+ public: |
+ CCodec_FlateScanlineDecoder(); |
+ ~CCodec_FlateScanlineDecoder(); |
+ void Create(const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ int width, |
+ int height, |
+ int nComps, |
+ int bpc, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns); |
+ virtual void Destroy() { delete this; } |
+ virtual void v_DownScale(int dest_width, int dest_height) {} |
+ virtual FX_BOOL v_Rewind(); |
+ virtual uint8_t* v_GetNextLine(); |
+ virtual FX_DWORD GetSrcOffset(); |
+ void* m_pFlate; |
+ const uint8_t* m_SrcBuf; |
+ FX_DWORD m_SrcSize; |
+ uint8_t* m_pScanline; |
+ uint8_t* m_pLastLine; |
+ uint8_t* m_pPredictBuffer; |
+ uint8_t* m_pPredictRaw; |
+ int m_Predictor; |
+ int m_Colors, m_BitsPerComponent, m_Columns, m_PredictPitch, m_LeftOver; |
}; |
-CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() |
-{ |
- m_pFlate = NULL; |
- m_pScanline = NULL; |
- m_pLastLine = NULL; |
- m_pPredictBuffer = NULL; |
- m_pPredictRaw = NULL; |
- m_LeftOver = 0; |
-} |
-CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() |
-{ |
- if (m_pScanline) { |
- FX_Free(m_pScanline); |
- } |
- if (m_pLastLine) { |
- FX_Free(m_pLastLine); |
- } |
- if (m_pPredictBuffer) { |
- FX_Free(m_pPredictBuffer); |
- } |
- if (m_pPredictRaw) { |
- FX_Free(m_pPredictRaw); |
- } |
- if (m_pFlate) { |
- FPDFAPI_FlateEnd(m_pFlate); |
- } |
+CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() { |
+ m_pFlate = NULL; |
+ m_pScanline = NULL; |
+ m_pLastLine = NULL; |
+ m_pPredictBuffer = NULL; |
+ m_pPredictRaw = NULL; |
+ m_LeftOver = 0; |
} |
-void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, |
- int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns) |
-{ |
- m_SrcBuf = 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_Pitch = (width * nComps * bpc + 7) / 8; |
- m_pScanline = FX_Alloc(uint8_t, m_Pitch); |
- m_Predictor = 0; |
- if (predictor) { |
- if (predictor >= 10) { |
- m_Predictor = 2; |
- } else if (predictor == 2) { |
- m_Predictor = 1; |
- } |
- if (m_Predictor) { |
- if (BitsPerComponent * Colors * Columns == 0) { |
- BitsPerComponent = m_bpc; |
- Colors = m_nComps; |
- Columns = m_OrigWidth; |
- } |
- m_Colors = Colors; |
- m_BitsPerComponent = BitsPerComponent; |
- m_Columns = Columns; |
- m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8; |
- m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch); |
- m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1); |
- m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch); |
- } |
- } |
+CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() { |
+ if (m_pScanline) { |
+ FX_Free(m_pScanline); |
+ } |
+ if (m_pLastLine) { |
+ FX_Free(m_pLastLine); |
+ } |
+ if (m_pPredictBuffer) { |
+ FX_Free(m_pPredictBuffer); |
+ } |
+ if (m_pPredictRaw) { |
+ FX_Free(m_pPredictRaw); |
+ } |
+ if (m_pFlate) { |
+ FPDFAPI_FlateEnd(m_pFlate); |
+ } |
} |
-FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() |
-{ |
- if (m_pFlate) { |
- FPDFAPI_FlateEnd(m_pFlate); |
+void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ int width, |
+ int height, |
+ int nComps, |
+ int bpc, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ m_SrcBuf = 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_Pitch = (width * nComps * bpc + 7) / 8; |
+ m_pScanline = FX_Alloc(uint8_t, m_Pitch); |
+ m_Predictor = 0; |
+ if (predictor) { |
+ if (predictor >= 10) { |
+ m_Predictor = 2; |
+ } else if (predictor == 2) { |
+ m_Predictor = 1; |
} |
- m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func); |
- if (m_pFlate == NULL) { |
- return FALSE; |
- } |
- FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize); |
- m_LeftOver = 0; |
- return TRUE; |
-} |
-uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() |
-{ |
if (m_Predictor) { |
- if (m_Pitch == m_PredictPitch) { |
- if (m_Predictor == 2) { |
- FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); |
- PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns); |
- FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch); |
- } else { |
- FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch); |
- TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps, m_OutputWidth); |
- } |
- } else { |
- int bytes_to_go = m_Pitch; |
- int read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver; |
- if (read_leftover) { |
- FXSYS_memcpy(m_pScanline, m_pPredictBuffer + m_PredictPitch - m_LeftOver, read_leftover); |
- m_LeftOver -= read_leftover; |
- bytes_to_go -= read_leftover; |
- } |
- while (bytes_to_go) { |
- if (m_Predictor == 2) { |
- FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); |
- PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns); |
- FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch); |
- } else { |
- FPDFAPI_FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch); |
- TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent, m_Colors, m_Columns); |
- } |
- int read_bytes = m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch; |
- FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, read_bytes); |
- m_LeftOver += m_PredictPitch - read_bytes; |
- bytes_to_go -= read_bytes; |
- } |
- } |
- } else { |
+ if (BitsPerComponent * Colors * Columns == 0) { |
+ BitsPerComponent = m_bpc; |
+ Colors = m_nComps; |
+ Columns = m_OrigWidth; |
+ } |
+ m_Colors = Colors; |
+ m_BitsPerComponent = BitsPerComponent; |
+ m_Columns = Columns; |
+ m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8; |
+ m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch); |
+ m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1); |
+ m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch); |
+ } |
+ } |
+} |
+FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() { |
+ if (m_pFlate) { |
+ FPDFAPI_FlateEnd(m_pFlate); |
+ } |
+ m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func); |
+ if (m_pFlate == NULL) { |
+ return FALSE; |
+ } |
+ FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize); |
+ m_LeftOver = 0; |
+ return TRUE; |
+} |
+uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { |
+ if (m_Predictor) { |
+ if (m_Pitch == m_PredictPitch) { |
+ if (m_Predictor == 2) { |
+ FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); |
+ PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, |
+ m_BitsPerComponent, m_Colors, m_Columns); |
+ FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch); |
+ } else { |
FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch); |
- } |
- return m_pScanline; |
-} |
-FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset() |
-{ |
- return FPDFAPI_FlateGetTotalIn(m_pFlate); |
-} |
-static void FlateUncompress(const uint8_t* src_buf, FX_DWORD src_size, FX_DWORD orig_size, |
- uint8_t*& dest_buf, FX_DWORD& dest_size, FX_DWORD& offset) |
-{ |
- const FX_BOOL useOldImpl = src_size < 10240; |
- FX_DWORD guess_size = orig_size ? orig_size : src_size * 2; |
- FX_DWORD alloc_step = orig_size ? 10240 : (src_size < 10240 ? 10240 : src_size); |
- static const FX_DWORD kMaxInitialAllocSize = 10000000; |
- if (guess_size > kMaxInitialAllocSize) { |
- guess_size = kMaxInitialAllocSize; |
- alloc_step = kMaxInitialAllocSize; |
- } |
- FX_DWORD buf_size = guess_size; |
- FX_DWORD last_buf_size = buf_size; |
- void* context = nullptr; |
+ TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps, |
+ m_OutputWidth); |
+ } |
+ } else { |
+ int bytes_to_go = m_Pitch; |
+ int read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver; |
+ if (read_leftover) { |
+ FXSYS_memcpy(m_pScanline, |
+ m_pPredictBuffer + m_PredictPitch - m_LeftOver, |
+ read_leftover); |
+ m_LeftOver -= read_leftover; |
+ bytes_to_go -= read_leftover; |
+ } |
+ while (bytes_to_go) { |
+ if (m_Predictor == 2) { |
+ FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); |
+ PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine, |
+ m_BitsPerComponent, m_Colors, m_Columns); |
+ FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch); |
+ } else { |
+ FPDFAPI_FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch); |
+ TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent, |
+ m_Colors, m_Columns); |
+ } |
+ int read_bytes = |
+ m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch; |
+ FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, |
+ read_bytes); |
+ m_LeftOver += m_PredictPitch - read_bytes; |
+ bytes_to_go -= read_bytes; |
+ } |
+ } |
+ } else { |
+ FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch); |
+ } |
+ return m_pScanline; |
+} |
+FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset() { |
+ return FPDFAPI_FlateGetTotalIn(m_pFlate); |
+} |
+static void FlateUncompress(const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ FX_DWORD orig_size, |
+ uint8_t*& dest_buf, |
+ FX_DWORD& dest_size, |
+ FX_DWORD& offset) { |
+ const FX_BOOL useOldImpl = src_size < 10240; |
+ FX_DWORD guess_size = orig_size ? orig_size : src_size * 2; |
+ FX_DWORD alloc_step = |
+ orig_size ? 10240 : (src_size < 10240 ? 10240 : src_size); |
+ static const FX_DWORD kMaxInitialAllocSize = 10000000; |
+ if (guess_size > kMaxInitialAllocSize) { |
+ guess_size = kMaxInitialAllocSize; |
+ alloc_step = kMaxInitialAllocSize; |
+ } |
+ FX_DWORD buf_size = guess_size; |
+ FX_DWORD last_buf_size = buf_size; |
+ void* context = nullptr; |
- uint8_t* guess_buf = FX_Alloc(uint8_t, guess_size + 1); |
- uint8_t* cur_buf = guess_buf; |
- guess_buf[guess_size] = '\0'; |
- context = FPDFAPI_FlateInit(my_alloc_func, my_free_func); |
- if (!context) |
+ uint8_t* guess_buf = FX_Alloc(uint8_t, guess_size + 1); |
+ uint8_t* cur_buf = guess_buf; |
+ guess_buf[guess_size] = '\0'; |
+ context = FPDFAPI_FlateInit(my_alloc_func, my_free_func); |
+ if (!context) |
+ goto fail; |
+ FPDFAPI_FlateInput(context, src_buf, src_size); |
+ if (useOldImpl) { |
+ while (1) { |
+ int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size); |
+ if (ret != Z_OK) |
+ break; |
+ int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context); |
+ if (avail_buf_size != 0) |
+ break; |
+ |
+ // |avail_buf_size| == 0 case. |
+ FX_DWORD old_size = guess_size; |
+ guess_size += alloc_step; |
+ if (guess_size < old_size || guess_size + 1 < guess_size) |
+ goto fail; |
+ guess_buf = FX_Realloc(uint8_t, guess_buf, guess_size + 1); |
+ if (!guess_buf) |
+ goto fail; |
+ guess_buf[guess_size] = '\0'; |
+ cur_buf = guess_buf + old_size; |
+ buf_size = guess_size - old_size; |
+ } |
+ dest_size = FPDFAPI_FlateGetTotalOut(context); |
+ offset = FPDFAPI_FlateGetTotalIn(context); |
+ if (guess_size / 2 > dest_size) { |
+ guess_buf = FX_Realloc(uint8_t, guess_buf, dest_size + 1); |
+ if (!guess_buf) |
goto fail; |
- FPDFAPI_FlateInput(context, src_buf, src_size); |
- if (useOldImpl) { |
- while (1) { |
- int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size); |
- if (ret != Z_OK) |
- break; |
- int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context); |
- if (avail_buf_size != 0) |
- break; |
+ guess_size = dest_size; |
+ guess_buf[guess_size] = '\0'; |
+ } |
+ dest_buf = guess_buf; |
+ } else { |
+ CFX_ArrayTemplate<uint8_t*> result_tmp_bufs; |
+ while (1) { |
+ int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size); |
+ int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context); |
+ if (ret != Z_OK) { |
+ last_buf_size = buf_size - avail_buf_size; |
+ result_tmp_bufs.Add(cur_buf); |
+ break; |
+ } |
+ if (avail_buf_size != 0) { |
+ last_buf_size = buf_size - avail_buf_size; |
+ result_tmp_bufs.Add(cur_buf); |
+ break; |
+ } |
- // |avail_buf_size| == 0 case. |
- FX_DWORD old_size = guess_size; |
- guess_size += alloc_step; |
- if (guess_size < old_size || guess_size + 1 < guess_size) |
- goto fail; |
- guess_buf = FX_Realloc(uint8_t, guess_buf, guess_size + 1); |
- if (!guess_buf) |
- goto fail; |
- guess_buf[guess_size] = '\0'; |
- cur_buf = guess_buf + old_size; |
- buf_size = guess_size - old_size; |
- } |
- dest_size = FPDFAPI_FlateGetTotalOut(context); |
- offset = FPDFAPI_FlateGetTotalIn(context); |
- if (guess_size / 2 > dest_size) { |
- guess_buf = FX_Realloc(uint8_t, guess_buf, dest_size + 1); |
- if (!guess_buf) |
- goto fail; |
- guess_size = dest_size; |
- guess_buf[guess_size] = '\0'; |
- } |
- dest_buf = guess_buf; |
+ // |avail_buf_size| == 0 case. |
+ result_tmp_bufs.Add(cur_buf); |
+ cur_buf = FX_Alloc(uint8_t, buf_size + 1); |
+ cur_buf[buf_size] = '\0'; |
+ } |
+ dest_size = FPDFAPI_FlateGetTotalOut(context); |
+ offset = FPDFAPI_FlateGetTotalIn(context); |
+ if (result_tmp_bufs.GetSize() == 1) { |
+ dest_buf = result_tmp_bufs[0]; |
} else { |
- CFX_ArrayTemplate<uint8_t*> result_tmp_bufs; |
- while (1) { |
- int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size); |
- int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context); |
- if (ret != Z_OK) { |
- last_buf_size = buf_size - avail_buf_size; |
- result_tmp_bufs.Add(cur_buf); |
- break; |
- } |
- if (avail_buf_size != 0) { |
- last_buf_size = buf_size - avail_buf_size; |
- result_tmp_bufs.Add(cur_buf); |
- break; |
- } |
- |
- // |avail_buf_size| == 0 case. |
- result_tmp_bufs.Add(cur_buf); |
- cur_buf = FX_Alloc(uint8_t, buf_size + 1); |
- cur_buf[buf_size] = '\0'; |
- } |
- dest_size = FPDFAPI_FlateGetTotalOut(context); |
- offset = FPDFAPI_FlateGetTotalIn(context); |
- if (result_tmp_bufs.GetSize() == 1) { |
- dest_buf = result_tmp_bufs[0]; |
- } else { |
- uint8_t* result_buf = FX_Alloc(uint8_t, dest_size); |
- FX_DWORD result_pos = 0; |
- for (int32_t i = 0; i < result_tmp_bufs.GetSize(); i++) { |
- uint8_t* tmp_buf = result_tmp_bufs[i]; |
- FX_DWORD tmp_buf_size = buf_size; |
- if (i == result_tmp_bufs.GetSize() - 1) { |
- tmp_buf_size = last_buf_size; |
- } |
- FXSYS_memcpy(result_buf + result_pos, tmp_buf, tmp_buf_size); |
- result_pos += tmp_buf_size; |
- FX_Free(result_tmp_bufs[i]); |
- } |
- dest_buf = result_buf; |
- } |
- } |
- FPDFAPI_FlateEnd(context); |
- return; |
+ uint8_t* result_buf = FX_Alloc(uint8_t, dest_size); |
+ FX_DWORD result_pos = 0; |
+ for (int32_t i = 0; i < result_tmp_bufs.GetSize(); i++) { |
+ uint8_t* tmp_buf = result_tmp_bufs[i]; |
+ FX_DWORD tmp_buf_size = buf_size; |
+ if (i == result_tmp_bufs.GetSize() - 1) { |
+ tmp_buf_size = last_buf_size; |
+ } |
+ FXSYS_memcpy(result_buf + result_pos, tmp_buf, tmp_buf_size); |
+ result_pos += tmp_buf_size; |
+ FX_Free(result_tmp_bufs[i]); |
+ } |
+ dest_buf = result_buf; |
+ } |
+ } |
+ FPDFAPI_FlateEnd(context); |
+ return; |
fail: |
- FX_Free(guess_buf); |
- dest_buf = nullptr; |
- dest_size = 0; |
- return; |
+ FX_Free(guess_buf); |
+ dest_buf = nullptr; |
+ dest_size = 0; |
+ return; |
} |
-ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, |
- int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns) |
-{ |
- CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder; |
- pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor, Colors, BitsPerComponent, Columns); |
- return pDecoder; |
-} |
-FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange, |
- int predictor, int Colors, int BitsPerComponent, int Columns, |
- FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size) |
-{ |
- dest_buf = NULL; |
- FX_DWORD offset = 0; |
- int predictor_type = 0; |
- if (predictor) { |
- if (predictor >= 10) { |
- predictor_type = 2; |
- } else if (predictor == 2) { |
- predictor_type = 1; |
- } |
- } |
- if (bLZW) { |
- { |
- nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder); |
- dest_size = (FX_DWORD) - 1; |
- offset = src_size; |
- int err = decoder->Decode(NULL, dest_size, src_buf, offset, |
- bEarlyChange); |
- if (err || dest_size == 0 || dest_size + 1 < dest_size) { |
- return -1; |
- } |
- } |
- { |
- nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder); |
- dest_buf = FX_Alloc( uint8_t, dest_size + 1); |
- dest_buf[dest_size] = '\0'; |
- decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange); |
- } |
- } else { |
- FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size, offset); |
- } |
- if (predictor_type == 0) { |
- return offset; |
- } |
- FX_BOOL ret = TRUE; |
- if (predictor_type == 2) { |
- ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, |
- Columns); |
- } else if (predictor_type == 1) { |
- ret = TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, |
- Columns); |
- } |
- return ret ? offset : -1; |
-} |
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, |
- int predictor, int Colors, int BitsPerComponent, int Columns, |
- uint8_t*& dest_buf, FX_DWORD& dest_size) |
-{ |
- if (predictor != 2 && predictor < 10) { |
- return Encode(src_buf, src_size, dest_buf, dest_size); |
- } |
- uint8_t* pSrcBuf = NULL; |
- pSrcBuf = FX_Alloc(uint8_t, src_size); |
- FXSYS_memcpy(pSrcBuf, src_buf, src_size); |
- FX_BOOL ret = TRUE; |
- if (predictor == 2) { |
- ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent, |
- Columns); |
- } else if (predictor >= 10) { |
- ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors, |
- BitsPerComponent, Columns); |
+ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder( |
+ const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ int width, |
+ int height, |
+ int nComps, |
+ int bpc, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns) { |
+ CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder; |
+ pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor, |
+ Colors, BitsPerComponent, Columns); |
+ return pDecoder; |
+} |
+FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, |
+ const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ FX_BOOL bEarlyChange, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns, |
+ FX_DWORD estimated_size, |
+ uint8_t*& dest_buf, |
+ FX_DWORD& dest_size) { |
+ dest_buf = NULL; |
+ FX_DWORD offset = 0; |
+ int predictor_type = 0; |
+ if (predictor) { |
+ if (predictor >= 10) { |
+ predictor_type = 2; |
+ } else if (predictor == 2) { |
+ predictor_type = 1; |
+ } |
+ } |
+ if (bLZW) { |
+ { |
+ nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder); |
+ dest_size = (FX_DWORD)-1; |
+ offset = src_size; |
+ int err = decoder->Decode(NULL, dest_size, src_buf, offset, bEarlyChange); |
+ if (err || dest_size == 0 || dest_size + 1 < dest_size) { |
+ return -1; |
+ } |
} |
- if (ret) |
- ret = Encode(pSrcBuf, src_size, dest_buf, dest_size); |
- FX_Free(pSrcBuf); |
- return ret; |
-} |
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size) |
-{ |
- dest_size = src_size + src_size / 1000 + 12; |
- dest_buf = FX_Alloc( uint8_t, dest_size); |
- unsigned long temp_size = dest_size; |
- FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size); |
- dest_size = (FX_DWORD)temp_size; |
- return TRUE; |
+ { |
+ nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder); |
+ dest_buf = FX_Alloc(uint8_t, dest_size + 1); |
+ dest_buf[dest_size] = '\0'; |
+ decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange); |
+ } |
+ } else { |
+ FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size, |
+ offset); |
+ } |
+ if (predictor_type == 0) { |
+ return offset; |
+ } |
+ FX_BOOL ret = TRUE; |
+ if (predictor_type == 2) { |
+ ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns); |
+ } else if (predictor_type == 1) { |
+ ret = |
+ TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns); |
+ } |
+ return ret ? offset : -1; |
+} |
+FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ int predictor, |
+ int Colors, |
+ int BitsPerComponent, |
+ int Columns, |
+ uint8_t*& dest_buf, |
+ FX_DWORD& dest_size) { |
+ if (predictor != 2 && predictor < 10) { |
+ return Encode(src_buf, src_size, dest_buf, dest_size); |
+ } |
+ uint8_t* pSrcBuf = NULL; |
+ pSrcBuf = FX_Alloc(uint8_t, src_size); |
+ FXSYS_memcpy(pSrcBuf, src_buf, src_size); |
+ FX_BOOL ret = TRUE; |
+ if (predictor == 2) { |
+ ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent, |
+ Columns); |
+ } else if (predictor >= 10) { |
+ ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors, |
+ BitsPerComponent, Columns); |
+ } |
+ if (ret) |
+ ret = Encode(pSrcBuf, src_size, dest_buf, dest_size); |
+ FX_Free(pSrcBuf); |
+ return ret; |
+} |
+FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, |
+ FX_DWORD src_size, |
+ uint8_t*& dest_buf, |
+ FX_DWORD& dest_size) { |
+ dest_size = src_size + src_size / 1000 + 12; |
+ dest_buf = FX_Alloc(uint8_t, dest_size); |
+ unsigned long temp_size = dest_size; |
+ FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size); |
+ dest_size = (FX_DWORD)temp_size; |
+ return TRUE; |
} |