diff options
Diffstat (limited to 'core')
| -rw-r--r-- | core/fxcodec/codec/fx_codec_flate.cpp | 156 |
1 files changed, 74 insertions, 82 deletions
diff --git a/core/fxcodec/codec/fx_codec_flate.cpp b/core/fxcodec/codec/fx_codec_flate.cpp index f0cbd6732a..eb68cedda5 100644 --- a/core/fxcodec/codec/fx_codec_flate.cpp +++ b/core/fxcodec/codec/fx_codec_flate.cpp @@ -17,6 +17,7 @@ #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> @@ -42,15 +43,13 @@ namespace { static constexpr uint32_t kMaxTotalOutSize = 1024 * 1024 * 1024; // 1 GiB -uint32_t FlateGetPossiblyTruncatedTotalOut(void* context) { - return std::min(pdfium::base::saturated_cast<uint32_t>( - static_cast<z_stream*>(context)->total_out), +uint32_t FlateGetPossiblyTruncatedTotalOut(z_stream* context) { + return std::min(pdfium::base::saturated_cast<uint32_t>(context->total_out), kMaxTotalOutSize); } -uint32_t FlateGetPossiblyTruncatedTotalIn(void* context) { - return pdfium::base::saturated_cast<uint32_t>( - static_cast<z_stream*>(context)->total_in); +uint32_t FlateGetPossiblyTruncatedTotalIn(z_stream* context) { + return pdfium::base::saturated_cast<uint32_t>(context->total_in); } bool FlateCompress(unsigned char* dest_buf, @@ -60,28 +59,24 @@ bool FlateCompress(unsigned char* dest_buf, return compress(dest_buf, dest_size, src_buf, src_size) == Z_OK; } -void* FlateInit() { +z_stream* FlateInit() { z_stream* p = FX_Alloc(z_stream, 1); - memset(p, 0, sizeof(z_stream)); p->zalloc = my_alloc_func; p->zfree = my_free_func; inflateInit(p); return p; } -void FlateInput(void* context, - const unsigned char* src_buf, - uint32_t src_size) { - static_cast<z_stream*>(context)->next_in = - const_cast<unsigned char*>(src_buf); - static_cast<z_stream*>(context)->avail_in = src_size; +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(void* context, +uint32_t FlateOutput(z_stream* context, unsigned char* dest_buf, uint32_t dest_size) { - static_cast<z_stream*>(context)->next_out = dest_buf; - static_cast<z_stream*>(context)->avail_out = 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); @@ -95,15 +90,20 @@ uint32_t FlateOutput(void* context, return ret; } -uint32_t FlateGetAvailOut(void* context) { - return static_cast<z_stream*>(context)->avail_out; +uint32_t FlateGetAvailOut(z_stream* context) { + return context->avail_out; } -void FlateEnd(void* context) { - inflateEnd(static_cast<z_stream*>(context)); - static_cast<z_stream*>(context)->zfree(0, context); +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, @@ -489,22 +489,22 @@ bool TIFF_Predictor(uint8_t*& data_buf, return true; } -void FlateUncompress(const uint8_t* src_buf, - uint32_t src_size, +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; - void* context = FlateInit(); + + std::unique_ptr<z_stream, FlateDeleter> context(FlateInit()); if (!context) return; - FlateInput(context, src_buf, src_size); + FlateInput(context.get(), src_buf); const uint32_t kMaxInitialAllocSize = 10000000; - uint32_t guess_size = orig_size ? orig_size : src_size * 2; + 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; @@ -516,8 +516,8 @@ void FlateUncompress(const uint8_t* src_buf, std::vector<uint8_t*> result_tmp_bufs; uint8_t* cur_buf = guess_buf.release(); while (1) { - uint32_t ret = FlateOutput(context, cur_buf, buf_size); - uint32_t avail_buf_size = FlateGetAvailOut(context); + 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); @@ -531,30 +531,30 @@ void FlateUncompress(const uint8_t* src_buf, // 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); - offset = FlateGetPossiblyTruncatedTotalIn(context); + dest_size = FlateGetPossiblyTruncatedTotalOut(context.get()); + offset = FlateGetPossiblyTruncatedTotalIn(context.get()); if (result_tmp_bufs.size() == 1) { dest_buf = result_tmp_bufs[0]; - } else { - 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; + 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]); } - FlateEnd(context); + dest_buf = result_buf; } enum class PredictorType : uint8_t { kNone, kFlate, kPng }; @@ -582,10 +582,9 @@ class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder { uint32_t GetSrcOffset() override; protected: - void* m_pFlate = nullptr; - const uint8_t* const m_SrcBuf; - const uint32_t m_SrcSize; - uint8_t* const m_pScanline; + 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, @@ -601,35 +600,27 @@ CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder(const uint8_t* src_buf, nComps, bpc, CalculatePitch8(bpc, nComps, width).ValueOrDie()), - m_SrcBuf(src_buf), - m_SrcSize(src_size), + m_SrcBuf(src_buf, src_size), m_pScanline(FX_Alloc(uint8_t, m_Pitch)) {} -CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() { - FX_Free(m_pScanline); - if (m_pFlate) - FlateEnd(m_pFlate); -} +CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() = default; bool CCodec_FlateScanlineDecoder::v_Rewind() { - if (m_pFlate) - FlateEnd(m_pFlate); - - m_pFlate = FlateInit(); + m_pFlate.reset(FlateInit()); if (!m_pFlate) return false; - FlateInput(m_pFlate, m_SrcBuf, m_SrcSize); + FlateInput(m_pFlate.get(), m_SrcBuf); return true; } uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { - FlateOutput(m_pFlate, m_pScanline, m_Pitch); - return m_pScanline; + FlateOutput(m_pFlate.get(), m_pScanline.get(), m_Pitch); + return m_pScanline.get(); } uint32_t CCodec_FlateScanlineDecoder::GetSrcOffset() { - return FlateGetPossiblyTruncatedTotalIn(m_pFlate); + return FlateGetPossiblyTruncatedTotalIn(m_pFlate.get()); } class CCodec_FlatePredictorScanlineDecoder @@ -714,19 +705,19 @@ uint8_t* CCodec_FlatePredictorScanlineDecoder::v_GetNextLine() { GetNextLineWithPredictedPitch(); else GetNextLineWithoutPredictedPitch(); - return m_pScanline; + return m_pScanline.get(); } void CCodec_FlatePredictorScanlineDecoder::GetNextLineWithPredictedPitch() { if (m_Predictor == PredictorType::kPng) { - FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); - PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, - m_Colors, m_Columns); - memcpy(m_pLastLine, m_pScanline, m_PredictPitch); + 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); } else { ASSERT(m_Predictor == PredictorType::kFlate); - FlateOutput(m_pFlate, m_pScanline, m_Pitch); - TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps, + FlateOutput(m_pFlate.get(), m_pScanline.get(), m_Pitch); + TIFF_PredictLine(m_pScanline.get(), m_PredictPitch, m_bpc, m_nComps, m_OutputWidth); } } @@ -735,26 +726,27 @@ 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, m_pPredictBuffer + m_PredictPitch - m_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) { if (m_Predictor == PredictorType::kPng) { - FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); + 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); } else { ASSERT(m_Predictor == PredictorType::kFlate); - FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch); + FlateOutput(m_pFlate.get(), m_pPredictBuffer, m_PredictPitch); TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent, m_Colors, m_Columns); } size_t read_bytes = m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch; - memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, read_bytes); + memcpy(m_pScanline.get() + m_Pitch - bytes_to_go, m_pPredictBuffer, + read_bytes); m_LeftOver += m_PredictPitch - read_bytes; bytes_to_go -= read_bytes; } @@ -812,8 +804,8 @@ uint32_t CCodec_FlateModule::FlateOrLZWDecode(bool bLZW, (*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); + FlateUncompress(pdfium::make_span(src_buf, src_size), estimated_size, + *dest_buf, *dest_size, offset); } if (predictor_type == PredictorType::kNone) return offset; |