Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2470)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: core/src/fxcodec/codec/fx_codec_flate.cpp

Issue 1265503005: clang-format all pdfium code. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: sigh Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « core/src/fxcodec/codec/fx_codec_fax.cpp ('k') | core/src/fxcodec/codec/fx_codec_icc.cpp » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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;
}
« no previous file with comments | « core/src/fxcodec/codec/fx_codec_fax.cpp ('k') | core/src/fxcodec/codec/fx_codec_icc.cpp » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698