summaryrefslogtreecommitdiff
path: root/core/fxcodec/codec/ccodec_flatemodule.cpp
diff options
context:
space:
mode:
authorTom Sepez <tsepez@chromium.org>2018-08-28 22:37:20 +0000
committerChromium commit bot <commit-bot@chromium.org>2018-08-28 22:37:20 +0000
commit48cd65d67eead592bce6c67084047ad6a7071267 (patch)
treece99b96dc49923836b1954b7fc08a68f9f7fc592 /core/fxcodec/codec/ccodec_flatemodule.cpp
parent126927eaec336153e3be43086deee672829395f1 (diff)
downloadpdfium-48cd65d67eead592bce6c67084047ad6a7071267.tar.xz
Rename remaining fx_codec*.cpp to match class and .h file name
Then include headers in the proper order per standards, since it will no longer trigger a presubmit warning. Change-Id: I6bb86ac90e8fd9aed30b66dac61726f0dea8222c Reviewed-on: https://pdfium-review.googlesource.com/41535 Commit-Queue: Tom Sepez <tsepez@chromium.org> Reviewed-by: Lei Zhang <thestig@chromium.org>
Diffstat (limited to 'core/fxcodec/codec/ccodec_flatemodule.cpp')
-rw-r--r--core/fxcodec/codec/ccodec_flatemodule.cpp852
1 files changed, 852 insertions, 0 deletions
diff --git a/core/fxcodec/codec/ccodec_flatemodule.cpp b/core/fxcodec/codec/ccodec_flatemodule.cpp
new file mode 100644
index 0000000000..9074038c96
--- /dev/null
+++ b/core/fxcodec/codec/ccodec_flatemodule.cpp
@@ -0,0 +1,852 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "core/fxcodec/codec/ccodec_flatemodule.h"
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "core/fxcodec/codec/ccodec_scanlinedecoder.h"
+#include "core/fxcodec/fx_codec.h"
+#include "core/fxcrt/fx_extension.h"
+#include "third_party/base/numerics/safe_conversions.h"
+#include "third_party/base/ptr_util.h"
+#include "third_party/base/span.h"
+
+#if defined(USE_SYSTEM_ZLIB)
+#include <zlib.h>
+#else
+#include "third_party/zlib/zlib.h"
+#endif
+
+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);
+}
+
+} // extern "C"
+
+namespace {
+
+static constexpr uint32_t kMaxTotalOutSize = 1024 * 1024 * 1024; // 1 GiB
+
+uint32_t FlateGetPossiblyTruncatedTotalOut(z_stream* context) {
+ return std::min(pdfium::base::saturated_cast<uint32_t>(context->total_out),
+ kMaxTotalOutSize);
+}
+
+uint32_t FlateGetPossiblyTruncatedTotalIn(z_stream* context) {
+ return pdfium::base::saturated_cast<uint32_t>(context->total_in);
+}
+
+bool FlateCompress(unsigned char* dest_buf,
+ unsigned long* dest_size,
+ const unsigned char* src_buf,
+ uint32_t src_size) {
+ return compress(dest_buf, dest_size, src_buf, src_size) == Z_OK;
+}
+
+z_stream* FlateInit() {
+ z_stream* p = FX_Alloc(z_stream, 1);
+ p->zalloc = my_alloc_func;
+ p->zfree = my_free_func;
+ inflateInit(p);
+ return p;
+}
+
+void FlateInput(z_stream* context, pdfium::span<const uint8_t> src_buf) {
+ context->next_in = const_cast<unsigned char*>(src_buf.data());
+ context->avail_in = static_cast<uint32_t>(src_buf.size());
+}
+
+uint32_t FlateOutput(z_stream* context,
+ unsigned char* dest_buf,
+ uint32_t dest_size) {
+ context->next_out = dest_buf;
+ context->avail_out = dest_size;
+ uint32_t pre_pos = FlateGetPossiblyTruncatedTotalOut(context);
+ int ret = inflate(static_cast<z_stream*>(context), Z_SYNC_FLUSH);
+
+ uint32_t post_pos = FlateGetPossiblyTruncatedTotalOut(context);
+ ASSERT(post_pos >= pre_pos);
+
+ uint32_t written = post_pos - pre_pos;
+ if (written < dest_size)
+ memset(dest_buf + written, '\0', dest_size - written);
+
+ return ret;
+}
+
+uint32_t FlateGetAvailOut(z_stream* context) {
+ return context->avail_out;
+}
+
+void FlateEnd(z_stream* context) {
+ inflateEnd(context);
+ FX_Free(context);
+}
+
+// For use with std::unique_ptr<z_stream>.
+struct FlateDeleter {
+ inline void operator()(z_stream* context) { FlateEnd(context); }
+};
+
+class CLZWDecoder {
+ public:
+ int Decode(uint8_t* output,
+ uint32_t& outlen,
+ const uint8_t* input,
+ uint32_t& size,
+ bool bEarlyChange);
+
+ private:
+ void AddCode(uint32_t prefix_code, uint8_t append_char);
+ void DecodeString(uint32_t code);
+
+ uint32_t m_InPos;
+ uint32_t m_OutPos;
+ uint8_t* m_pOutput;
+ const uint8_t* m_pInput;
+ bool m_Early;
+ uint32_t m_nCodes;
+ uint32_t m_StackLen;
+ int m_CodeLen;
+ uint32_t m_CodeArray[5021];
+ uint8_t m_DecodeStack[4000];
+};
+
+void CLZWDecoder::AddCode(uint32_t 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(uint32_t code) {
+ while (1) {
+ int index = code - 258;
+ if (index < 0 || index >= (int)m_nCodes) {
+ break;
+ }
+ uint32_t data = m_CodeArray[index];
+ if (m_StackLen >= sizeof(m_DecodeStack)) {
+ return;
+ }
+ 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,
+ uint32_t& dest_size,
+ const uint8_t* src_buf,
+ uint32_t& src_size,
+ 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;
+ uint32_t old_code = 0xFFFFFFFF;
+ uint8_t last_char = 0;
+ 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;
+ uint32_t 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 == 257)
+ break;
+ 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 != 0xFFFFFFFF)
+ AddCode(old_code, last_char);
+ old_code = code;
+ } else if (code == 256) {
+ m_CodeLen = 9;
+ m_nCodes = 0;
+ old_code = 0xFFFFFFFF;
+ } else {
+ // Else 257 or greater.
+ if (old_code == 0xFFFFFFFF)
+ 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 (uint32_t 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;
+}
+
+uint8_t PathPredictor(int a, int b, int c) {
+ int p = a + b - c;
+ int pa = abs(p - a);
+ int pb = abs(p - b);
+ int pc = abs(p - c);
+ if (pa <= pb && pa <= pc)
+ return (uint8_t)a;
+ if (pb <= pc)
+ return (uint8_t)b;
+ return (uint8_t)c;
+}
+
+void PNG_PredictLine(uint8_t* pDestData,
+ const uint8_t* pSrcData,
+ const uint8_t* pLastLine,
+ int bpc,
+ int nColors,
+ int nPixels) {
+ const uint32_t row_size = CalculatePitch8(bpc, nColors, nPixels).ValueOrDie();
+ const uint32_t BytesPerPixel = (bpc * nColors + 7) / 8;
+ uint8_t tag = pSrcData[0];
+ if (tag == 0) {
+ memmove(pDestData, pSrcData + 1, row_size);
+ return;
+ }
+ for (uint32_t 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 + PathPredictor(left, up, upper_left);
+ break;
+ }
+ default:
+ pDestData[byte] = raw_byte;
+ break;
+ }
+ }
+}
+
+bool PNG_Predictor(uint8_t*& data_buf,
+ uint32_t& data_size,
+ int Colors,
+ int BitsPerComponent,
+ int Columns) {
+ // TODO(thestig): Look into using CalculatePitch8() here.
+ 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);
+ if (row_count <= 0)
+ return false;
+ const int last_row_size = data_size % (row_size + 1);
+ uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
+ uint32_t 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;
+ }
+ 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 < data_size;
+ ++byte, ++byte_cnt) {
+ 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 + PathPredictor(left, up, upper_left);
+ break;
+ }
+ default:
+ pDestData[byte] = raw_byte;
+ break;
+ }
+ }
+ 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;
+}
+
+void TIFF_PredictLine(uint8_t* dest_buf,
+ uint32_t row_size,
+ int BitsPerComponent,
+ int Colors,
+ int Columns) {
+ if (BitsPerComponent == 1) {
+ int row_bits = std::min(BitsPerComponent * Colors * Columns,
+ pdfium::base::checked_cast<int>(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 (uint32_t i = BytesPerPixel; i + 1 < row_size; i += 2) {
+ uint16_t 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 (uint32_t i = BytesPerPixel; i < row_size; i++) {
+ dest_buf[i] += dest_buf[i - BytesPerPixel];
+ }
+ }
+}
+
+bool TIFF_Predictor(uint8_t*& data_buf,
+ uint32_t& 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;
+}
+
+void FlateUncompress(pdfium::span<const uint8_t> src_buf,
+ uint32_t orig_size,
+ uint8_t*& dest_buf,
+ uint32_t& dest_size,
+ uint32_t& offset) {
+ dest_buf = nullptr;
+ dest_size = 0;
+
+ std::unique_ptr<z_stream, FlateDeleter> context(FlateInit());
+ if (!context)
+ return;
+
+ FlateInput(context.get(), src_buf);
+
+ const uint32_t kMaxInitialAllocSize = 10000000;
+ uint32_t guess_size = orig_size ? orig_size : src_buf.size() * 2;
+ guess_size = std::min(guess_size, kMaxInitialAllocSize);
+
+ uint32_t buf_size = guess_size;
+ uint32_t last_buf_size = buf_size;
+ std::unique_ptr<uint8_t, FxFreeDeleter> guess_buf(
+ FX_Alloc(uint8_t, guess_size + 1));
+ guess_buf.get()[guess_size] = '\0';
+
+ std::vector<uint8_t*> result_tmp_bufs;
+ uint8_t* cur_buf = guess_buf.release();
+ while (1) {
+ uint32_t ret = FlateOutput(context.get(), cur_buf, buf_size);
+ uint32_t avail_buf_size = FlateGetAvailOut(context.get());
+ if (ret != Z_OK || avail_buf_size != 0) {
+ last_buf_size = buf_size - avail_buf_size;
+ result_tmp_bufs.push_back(cur_buf);
+ break;
+ }
+ result_tmp_bufs.push_back(cur_buf);
+ cur_buf = FX_Alloc(uint8_t, buf_size + 1);
+ cur_buf[buf_size] = '\0';
+ }
+
+ // The TotalOut size returned from the library may not be big enough to
+ // handle the content the library returns. We can only handle items
+ // up to 4GB in size.
+ dest_size = FlateGetPossiblyTruncatedTotalOut(context.get());
+ offset = FlateGetPossiblyTruncatedTotalIn(context.get());
+ if (result_tmp_bufs.size() == 1) {
+ dest_buf = result_tmp_bufs[0];
+ return;
+ }
+
+ uint8_t* result_buf = FX_Alloc(uint8_t, dest_size);
+ uint32_t result_pos = 0;
+ uint32_t remaining = dest_size;
+ for (size_t i = 0; i < result_tmp_bufs.size(); i++) {
+ uint8_t* tmp_buf = result_tmp_bufs[i];
+ uint32_t tmp_buf_size = buf_size;
+ if (i == result_tmp_bufs.size() - 1)
+ tmp_buf_size = last_buf_size;
+
+ uint32_t cp_size = std::min(tmp_buf_size, remaining);
+ memcpy(result_buf + result_pos, tmp_buf, cp_size);
+ result_pos += cp_size;
+ remaining -= cp_size;
+
+ FX_Free(result_tmp_bufs[i]);
+ }
+ dest_buf = result_buf;
+}
+
+enum class PredictorType : uint8_t { kNone, kFlate, kPng };
+static PredictorType GetPredictor(int predictor) {
+ if (predictor >= 10)
+ return PredictorType::kPng;
+ if (predictor == 2)
+ return PredictorType::kFlate;
+ return PredictorType::kNone;
+}
+
+class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder {
+ public:
+ CCodec_FlateScanlineDecoder(const uint8_t* src_buf,
+ uint32_t src_size,
+ int width,
+ int height,
+ int nComps,
+ int bpc);
+ ~CCodec_FlateScanlineDecoder() override;
+
+ // CCodec_ScanlineDecoder:
+ bool v_Rewind() override;
+ uint8_t* v_GetNextLine() override;
+ uint32_t GetSrcOffset() override;
+
+ protected:
+ std::unique_ptr<z_stream, FlateDeleter> m_pFlate;
+ pdfium::span<const uint8_t> const m_SrcBuf;
+ std::unique_ptr<uint8_t, FxFreeDeleter> const m_pScanline;
+};
+
+CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder(const uint8_t* src_buf,
+ uint32_t src_size,
+ int width,
+ int height,
+ int nComps,
+ int bpc)
+ : CCodec_ScanlineDecoder(width,
+ height,
+ width,
+ height,
+ nComps,
+ bpc,
+ CalculatePitch8(bpc, nComps, width).ValueOrDie()),
+ m_SrcBuf(src_buf, src_size),
+ m_pScanline(FX_Alloc(uint8_t, m_Pitch)) {}
+
+CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() = default;
+
+bool CCodec_FlateScanlineDecoder::v_Rewind() {
+ m_pFlate.reset(FlateInit());
+ if (!m_pFlate)
+ return false;
+
+ FlateInput(m_pFlate.get(), m_SrcBuf);
+ return true;
+}
+
+uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() {
+ FlateOutput(m_pFlate.get(), m_pScanline.get(), m_Pitch);
+ return m_pScanline.get();
+}
+
+uint32_t CCodec_FlateScanlineDecoder::GetSrcOffset() {
+ return FlateGetPossiblyTruncatedTotalIn(m_pFlate.get());
+}
+
+class CCodec_FlatePredictorScanlineDecoder final
+ : public CCodec_FlateScanlineDecoder {
+ public:
+ CCodec_FlatePredictorScanlineDecoder(const uint8_t* src_buf,
+ uint32_t src_size,
+ int width,
+ int height,
+ int comps,
+ int bpc,
+ PredictorType predictor,
+ int Colors,
+ int BitsPerComponent,
+ int Columns);
+ ~CCodec_FlatePredictorScanlineDecoder() override;
+
+ // CCodec_ScanlineDecoder:
+ bool v_Rewind() override;
+ uint8_t* v_GetNextLine() override;
+
+ protected:
+ void GetNextLineWithPredictedPitch();
+ void GetNextLineWithoutPredictedPitch();
+
+ const PredictorType m_Predictor;
+ int m_Colors = 0;
+ int m_BitsPerComponent = 0;
+ int m_Columns = 0;
+ uint32_t m_PredictPitch = 0;
+ size_t m_LeftOver = 0;
+ uint8_t* m_pLastLine = nullptr;
+ uint8_t* m_pPredictBuffer = nullptr;
+ uint8_t* m_pPredictRaw = nullptr;
+};
+
+CCodec_FlatePredictorScanlineDecoder::CCodec_FlatePredictorScanlineDecoder(
+ const uint8_t* src_buf,
+ uint32_t src_size,
+ int width,
+ int height,
+ int comps,
+ int bpc,
+ PredictorType predictor,
+ int Colors,
+ int BitsPerComponent,
+ int Columns)
+ : CCodec_FlateScanlineDecoder(src_buf, src_size, width, height, comps, bpc),
+ m_Predictor(predictor) {
+ ASSERT(m_Predictor != PredictorType::kNone);
+ 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 =
+ CalculatePitch8(m_BitsPerComponent, m_Colors, m_Columns).ValueOrDie();
+ m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
+ m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
+ m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
+}
+
+CCodec_FlatePredictorScanlineDecoder::~CCodec_FlatePredictorScanlineDecoder() {
+ FX_Free(m_pLastLine);
+ FX_Free(m_pPredictBuffer);
+ FX_Free(m_pPredictRaw);
+}
+
+bool CCodec_FlatePredictorScanlineDecoder::v_Rewind() {
+ if (!CCodec_FlateScanlineDecoder::v_Rewind())
+ return false;
+
+ m_LeftOver = 0;
+ return true;
+}
+
+uint8_t* CCodec_FlatePredictorScanlineDecoder::v_GetNextLine() {
+ if (m_Pitch == m_PredictPitch)
+ GetNextLineWithPredictedPitch();
+ else
+ GetNextLineWithoutPredictedPitch();
+ return m_pScanline.get();
+}
+
+void CCodec_FlatePredictorScanlineDecoder::GetNextLineWithPredictedPitch() {
+ switch (m_Predictor) {
+ case PredictorType::kPng:
+ FlateOutput(m_pFlate.get(), m_pPredictRaw, m_PredictPitch + 1);
+ PNG_PredictLine(m_pScanline.get(), m_pPredictRaw, m_pLastLine,
+ m_BitsPerComponent, m_Colors, m_Columns);
+ memcpy(m_pLastLine, m_pScanline.get(), m_PredictPitch);
+ break;
+ case PredictorType::kFlate:
+ FlateOutput(m_pFlate.get(), m_pScanline.get(), m_Pitch);
+ TIFF_PredictLine(m_pScanline.get(), m_PredictPitch, m_bpc, m_nComps,
+ m_OutputWidth);
+ break;
+ default:
+ NOTREACHED();
+ break;
+ }
+}
+
+void CCodec_FlatePredictorScanlineDecoder::GetNextLineWithoutPredictedPitch() {
+ size_t bytes_to_go = m_Pitch;
+ size_t read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
+ if (read_leftover) {
+ memcpy(m_pScanline.get(), m_pPredictBuffer + m_PredictPitch - m_LeftOver,
+ read_leftover);
+ m_LeftOver -= read_leftover;
+ bytes_to_go -= read_leftover;
+ }
+ while (bytes_to_go) {
+ switch (m_Predictor) {
+ case PredictorType::kPng:
+ FlateOutput(m_pFlate.get(), m_pPredictRaw, m_PredictPitch + 1);
+ PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine,
+ m_BitsPerComponent, m_Colors, m_Columns);
+ memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch);
+ break;
+ case PredictorType::kFlate:
+ FlateOutput(m_pFlate.get(), m_pPredictBuffer, m_PredictPitch);
+ TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent,
+ m_Colors, m_Columns);
+ break;
+ default:
+ NOTREACHED();
+ break;
+ }
+ size_t read_bytes =
+ m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch;
+ memcpy(m_pScanline.get() + m_Pitch - bytes_to_go, m_pPredictBuffer,
+ read_bytes);
+ m_LeftOver += m_PredictPitch - read_bytes;
+ bytes_to_go -= read_bytes;
+ }
+}
+
+} // namespace
+
+std::unique_ptr<CCodec_ScanlineDecoder> CCodec_FlateModule::CreateDecoder(
+ const uint8_t* src_buf,
+ uint32_t src_size,
+ int width,
+ int height,
+ int nComps,
+ int bpc,
+ int predictor,
+ int Colors,
+ int BitsPerComponent,
+ int Columns) {
+ PredictorType predictor_type = GetPredictor(predictor);
+ if (predictor_type == PredictorType::kNone) {
+ return pdfium::MakeUnique<CCodec_FlateScanlineDecoder>(
+ src_buf, src_size, width, height, nComps, bpc);
+ }
+ return pdfium::MakeUnique<CCodec_FlatePredictorScanlineDecoder>(
+ src_buf, src_size, width, height, nComps, bpc, predictor_type, Colors,
+ BitsPerComponent, Columns);
+}
+
+uint32_t CCodec_FlateModule::FlateOrLZWDecode(bool bLZW,
+ const uint8_t* src_buf,
+ uint32_t src_size,
+ bool bEarlyChange,
+ int predictor,
+ int Colors,
+ int BitsPerComponent,
+ int Columns,
+ uint32_t estimated_size,
+ uint8_t** dest_buf,
+ uint32_t* dest_size) {
+ *dest_buf = nullptr;
+ uint32_t offset = 0;
+ PredictorType predictor_type = GetPredictor(predictor);
+
+ if (bLZW) {
+ auto decoder = pdfium::MakeUnique<CLZWDecoder>();
+ *dest_size = 0xFFFFFFFF;
+ offset = src_size;
+ int err =
+ decoder->Decode(nullptr, *dest_size, src_buf, offset, bEarlyChange);
+ if (err || *dest_size == 0 || *dest_size + 1 < *dest_size)
+ return FX_INVALID_OFFSET;
+
+ decoder = pdfium::MakeUnique<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(pdfium::make_span(src_buf, src_size), estimated_size,
+ *dest_buf, *dest_size, offset);
+ }
+
+ bool ret = false;
+ switch (predictor_type) {
+ case PredictorType::kNone:
+ return offset;
+ case PredictorType::kPng:
+ ret = PNG_Predictor(*dest_buf, *dest_size, Colors, BitsPerComponent,
+ Columns);
+ break;
+ case PredictorType::kFlate:
+ ret = TIFF_Predictor(*dest_buf, *dest_size, Colors, BitsPerComponent,
+ Columns);
+ break;
+ default:
+ NOTREACHED();
+ break;
+ }
+ return ret ? offset : FX_INVALID_OFFSET;
+}
+
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf,
+ uint32_t src_size,
+ uint8_t** dest_buf,
+ uint32_t* dest_size) {
+ *dest_size = src_size + src_size / 1000 + 12;
+ *dest_buf = FX_Alloc(uint8_t, *dest_size);
+ unsigned long temp_size = *dest_size;
+ if (!FlateCompress(*dest_buf, &temp_size, src_buf, src_size))
+ return false;
+
+ *dest_size = (uint32_t)temp_size;
+ return true;
+}