7#include "core/fxcodec/flate/flatemodule.h"
18#include "core/fxcodec/scanlinedecoder.h"
19#include "core/fxcrt/data_vector.h"
20#include "core/fxcrt/fixed_size_data_vector.h"
21#include "core/fxcrt/fx_extension.h"
22#include "core/fxcrt/fx_memory_wrappers.h"
23#include "core/fxcrt/fx_safe_types.h"
24#include "core/fxcrt/span_util.h"
25#include "core/fxge/calculate_pitch.h"
26#include "third_party/base/check.h"
27#include "third_party/base/containers/span.h"
28#include "third_party/base/notreached.h"
29#include "third_party/base/numerics/safe_conversions.h"
31#if defined(USE_SYSTEM_ZLIB)
34#include "third_party/zlib/zlib.h"
42 return FX_Alloc2D(uint8_t, items, size);
55static constexpr uint32_t kMaxTotalOutSize = 1024 * 1024 * 1024;
57uint32_t FlateGetPossiblyTruncatedTotalOut(z_stream* context) {
58 return std::min(pdfium::base::saturated_cast<uint32_t>(context->total_out),
62uint32_t FlateGetPossiblyTruncatedTotalIn(z_stream* context) {
63 return pdfium::base::saturated_cast<uint32_t>(context->total_in);
66bool FlateCompress(
unsigned char* dest_buf,
67 unsigned long* dest_size,
68 const unsigned char* src_buf,
69 unsigned long src_size) {
70 return compress(dest_buf, dest_size, src_buf, src_size) == Z_OK;
73z_stream* FlateInit() {
74 z_stream* p = FX_Alloc(z_stream, 1);
81void FlateInput(z_stream* context, pdfium::span<
const uint8_t> src_buf) {
82 context->next_in =
const_cast<
unsigned char*>(src_buf.data());
83 context->avail_in =
static_cast<uint32_t>(src_buf.size());
86uint32_t FlateOutput(z_stream* context,
87 unsigned char* dest_buf,
89 context->next_out = dest_buf;
90 context->avail_out = dest_size;
91 uint32_t pre_pos = FlateGetPossiblyTruncatedTotalOut(context);
92 int ret = inflate(
static_cast<z_stream*>(context), Z_SYNC_FLUSH);
94 uint32_t post_pos = FlateGetPossiblyTruncatedTotalOut(context);
95 DCHECK(post_pos >= pre_pos);
97 uint32_t written = post_pos - pre_pos;
98 if (written < dest_size)
99 memset(dest_buf + written,
'\0', dest_size - written);
104uint32_t FlateGetAvailOut(z_stream* context) {
105 return context->avail_out;
108void FlateEnd(z_stream* context) {
115 inline void operator()(z_stream* context) { FlateEnd(context); }
120 CLZWDecoder(pdfium::span<
const uint8_t> src_span,
bool early_change);
123 uint32_t GetSrcSize()
const {
return (src_bit_pos_ + 7) / 8; }
124 uint32_t GetDestSize()
const {
return dest_byte_pos_; }
126 return std::move(dest_buf_);
130 void AddCode(uint32_t prefix_code, uint8_t append_char);
131 void DecodeString(uint32_t code);
132 void ExpandDestBuf(uint32_t additional_size);
134 pdfium::span<
const uint8_t>
const src_span_;
136 uint32_t src_bit_pos_ = 0;
137 uint32_t dest_buf_size_ = 0;
138 uint32_t dest_byte_pos_ = 0;
139 uint32_t stack_len_ = 0;
141 const uint8_t early_change_;
142 uint8_t code_len_ = 9;
143 uint32_t current_code_ = 0;
147CLZWDecoder::CLZWDecoder(pdfium::span<
const uint8_t> src_span,
149 : src_span_(src_span),
150 decode_stack_(FixedSizeDataVector<uint8_t>::Zeroed(4000)),
151 early_change_(early_change ? 1 : 0),
152 codes_(FixedSizeDataVector<uint32_t>::Zeroed(5021)) {}
154void CLZWDecoder::AddCode(uint32_t prefix_code, uint8_t append_char) {
155 if (current_code_ + early_change_ == 4094)
158 pdfium::span<uint32_t> codes_span = codes_.span();
159 codes_span[current_code_++] = (prefix_code << 16) | append_char;
160 if (current_code_ + early_change_ == 512 - 258)
162 else if (current_code_ + early_change_ == 1024 - 258)
164 else if (current_code_ + early_change_ == 2048 - 258)
168void CLZWDecoder::DecodeString(uint32_t code) {
169 pdfium::span<uint8_t> decode_span = decode_stack_.span();
170 pdfium::span<
const uint32_t> codes_span = codes_.span();
172 int index = code - 258;
173 if (index < 0 ||
static_cast<uint32_t>(index) >= current_code_)
176 uint32_t data = codes_span[index];
177 if (stack_len_ >= decode_span.size())
180 decode_span[stack_len_++] =
static_cast<uint8_t>(data);
183 if (stack_len_ >= decode_span.size())
186 decode_span[stack_len_++] =
static_cast<uint8_t>(code);
189void CLZWDecoder::ExpandDestBuf(uint32_t additional_size) {
190 FX_SAFE_UINT32 new_size = std::max(dest_buf_size_ / 2, additional_size);
191 new_size += dest_buf_size_;
192 if (!new_size.IsValid()) {
197 dest_buf_size_ = new_size.ValueOrDie();
198 dest_buf_.reset(FX_Realloc(uint8_t, dest_buf_.release(), dest_buf_size_));
201bool CLZWDecoder::Decode() {
202 pdfium::span<uint8_t> decode_span = decode_stack_.span();
203 uint32_t old_code = 0xFFFFFFFF;
204 uint8_t last_char = 0;
208 dest_buf_size_ = 512;
209 dest_buf_.reset(FX_Alloc(uint8_t, dest_buf_size_));
211 if (src_bit_pos_ + code_len_ > src_span_.size() * 8)
214 int byte_pos = src_bit_pos_ / 8;
215 int bit_pos = src_bit_pos_ % 8;
216 uint8_t bit_left = code_len_;
219 bit_left -= 8 - bit_pos;
220 code = (src_span_[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
223 code |= src_span_[byte_pos] >> (8 - bit_left);
226 code |= src_span_[byte_pos++] << bit_left;
228 code |= src_span_[byte_pos] >> (8 - bit_left);
230 src_bit_pos_ += code_len_;
233 if (dest_byte_pos_ >= dest_buf_size_) {
234 ExpandDestBuf(dest_byte_pos_ - dest_buf_size_ + 1);
239 dest_buf_.get()[dest_byte_pos_] = (uint8_t)code;
241 last_char = (uint8_t)code;
242 if (old_code != 0xFFFFFFFF)
243 AddCode(old_code, last_char);
250 old_code = 0xFFFFFFFF;
257 if (old_code == 0xFFFFFFFF)
260 DCHECK(old_code < 256 || old_code >= 258);
262 if (code - 258 >= current_code_) {
263 if (stack_len_ < decode_stack_.size())
264 decode_span[stack_len_++] = last_char;
265 DecodeString(old_code);
270 FX_SAFE_UINT32 safe_required_size = dest_byte_pos_;
271 safe_required_size += stack_len_;
272 if (!safe_required_size.IsValid())
275 uint32_t required_size = safe_required_size.ValueOrDie();
276 if (required_size > dest_buf_size_) {
277 ExpandDestBuf(required_size - dest_buf_size_);
282 for (uint32_t i = 0; i < stack_len_; i++)
283 dest_buf_.get()[dest_byte_pos_ + i] = decode_span[stack_len_ - i - 1];
284 dest_byte_pos_ += stack_len_;
285 last_char = decode_span[stack_len_ - 1];
286 if (old_code >= 258 && old_code - 258 >= current_code_)
289 AddCode(old_code, last_char);
292 return dest_byte_pos_ != 0;
295uint8_t PathPredictor(
int a,
int b,
int c) {
300 if (pa <= pb && pa <= pc)
307void PNG_PredictLine(pdfium::span<uint8_t> dest_span,
308 pdfium::span<
const uint8_t> src_span,
309 pdfium::span<
const uint8_t> last_span,
313 uint8_t* pDestData = dest_span.data();
314 const uint8_t* pSrcData = src_span.data();
315 const uint8_t* pLastLine = last_span.data();
317 const uint32_t BytesPerPixel = (bpc * nColors + 7) / 8;
318 uint8_t tag = pSrcData[0];
320 memmove(pDestData, pSrcData + 1, row_size);
323 for (uint32_t byte = 0; byte < row_size; ++byte) {
324 uint8_t raw_byte = pSrcData[byte + 1];
328 if (byte >= BytesPerPixel) {
329 left = pDestData[byte - BytesPerPixel];
331 pDestData[byte] = raw_byte + left;
337 up = pLastLine[byte];
339 pDestData[byte] = raw_byte + up;
344 if (byte >= BytesPerPixel) {
345 left = pDestData[byte - BytesPerPixel];
349 up = pLastLine[byte];
351 pDestData[byte] = raw_byte + (up + left) / 2;
356 if (byte >= BytesPerPixel) {
357 left = pDestData[byte - BytesPerPixel];
361 up = pLastLine[byte];
363 uint8_t upper_left = 0;
364 if (byte >= BytesPerPixel && pLastLine) {
365 upper_left = pLastLine[byte - BytesPerPixel];
367 pDestData[byte] = raw_byte + PathPredictor(left, up, upper_left);
371 pDestData[byte] = raw_byte;
377bool PNG_Predictor(
int Colors,
378 int BitsPerComponent,
381 uint32_t* data_size) {
382 const uint32_t row_size =
383 fxge::CalculatePitch8(BitsPerComponent, Colors, Columns).value_or(0);
388 const uint32_t src_row_size = row_size + 1;
389 if (src_row_size == 0) {
393 const uint32_t row_count = (*data_size + row_size) / src_row_size;
394 if (row_count == 0) {
398 const uint32_t last_row_size = *data_size % src_row_size;
400 FX_Alloc2D(uint8_t, row_size, row_count));
401 uint32_t byte_cnt = 0;
402 const uint8_t* pSrcData = data_buf->get();
403 uint8_t* pDestData = dest_buf.get();
404 const uint8_t* pPrevDestData =
nullptr;
405 for (uint32_t row = 0; row < row_count; row++) {
406 uint8_t tag = pSrcData[0];
409 uint32_t move_size = row_size;
410 if ((row + 1) * (move_size + 1) > *data_size) {
411 move_size = last_row_size - 1;
413 memcpy(pDestData, pSrcData + 1, move_size);
414 pSrcData += move_size + 1;
415 pPrevDestData = pDestData;
416 pDestData += move_size;
417 byte_cnt += move_size;
421 const uint32_t BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
422 for (uint32_t byte = 0; byte < row_size && byte_cnt < *data_size;
423 ++byte, ++byte_cnt) {
424 uint8_t raw_byte = pSrcData[byte + 1];
428 if (byte >= BytesPerPixel) {
429 left = pDestData[byte - BytesPerPixel];
431 pDestData[byte] = raw_byte + left;
437 up = pPrevDestData[byte];
439 pDestData[byte] = raw_byte + up;
444 if (byte >= BytesPerPixel) {
445 left = pDestData[byte - BytesPerPixel];
449 up = pPrevDestData[byte];
451 pDestData[byte] = raw_byte + (up + left) / 2;
456 if (byte >= BytesPerPixel) {
457 left = pDestData[byte - BytesPerPixel];
461 up = pPrevDestData[byte];
463 uint8_t upper_left = 0;
464 if (pPrevDestData && byte >= BytesPerPixel) {
465 upper_left = pPrevDestData[byte - BytesPerPixel];
467 pDestData[byte] = raw_byte + PathPredictor(left, up, upper_left);
471 pDestData[byte] = raw_byte;
475 pSrcData += src_row_size;
476 pPrevDestData = pDestData;
477 pDestData += row_size;
479 *data_buf =
std::move(dest_buf);
480 *data_size = row_size * row_count -
481 (last_row_size > 0 ? (src_row_size - last_row_size) : 0);
485void TIFF_PredictLine(uint8_t* dest_buf,
487 int BitsPerComponent,
490 if (BitsPerComponent == 1) {
491 int row_bits =
std::min(BitsPerComponent * Colors * Columns,
492 pdfium::base::checked_cast<
int>(row_size * 8));
495 for (
int i = 1; i < row_bits; i++) {
498 if (((dest_buf[index] >> (7 - col)) & 1) ^
499 ((dest_buf[index_pre] >> (7 - col_pre)) & 1)) {
500 dest_buf[index] |= 1 << (7 - col);
502 dest_buf[index] &= ~(1 << (7 - col));
509 int BytesPerPixel = BitsPerComponent * Colors / 8;
510 if (BitsPerComponent == 16) {
511 for (uint32_t i = BytesPerPixel; i + 1 < row_size; i += 2) {
513 (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
514 pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
515 dest_buf[i] = pixel >> 8;
516 dest_buf[i + 1] = (uint8_t)pixel;
519 for (uint32_t i = BytesPerPixel; i < row_size; i++) {
520 dest_buf[i] += dest_buf[i - BytesPerPixel];
525bool TIFF_Predictor(
int Colors,
526 int BitsPerComponent,
529 uint32_t* data_size) {
531 fxge::CalculatePitch8(BitsPerComponent, Colors, Columns).value_or(0);
535 const uint32_t row_count = (*data_size + row_size - 1) / row_size;
536 const uint32_t last_row_size = *data_size % row_size;
537 for (uint32_t row = 0; row < row_count; row++) {
538 uint8_t* scan_line = data_buf->get() + row * row_size;
539 if ((row + 1) * row_size > *data_size) {
540 row_size = last_row_size;
542 TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
547void FlateUncompress(pdfium::span<
const uint8_t> src_buf,
555 std::unique_ptr<z_stream, FlateDeleter> context(FlateInit());
559 FlateInput(context.get(), src_buf);
561 const uint32_t kMaxInitialAllocSize = 10000000;
562 uint32_t guess_size =
563 orig_size ? orig_size
564 : pdfium::base::checked_cast<uint32_t>(src_buf.size() * 2);
565 guess_size =
std::min(guess_size, kMaxInitialAllocSize);
567 uint32_t buf_size = guess_size;
568 uint32_t last_buf_size = buf_size;
570 FX_Alloc(uint8_t, guess_size + 1));
571 guess_buf.get()[guess_size] =
'\0';
573 std::vector<std::unique_ptr<uint8_t, FxFreeDeleter>> result_tmp_bufs;
577 uint32_t ret = FlateOutput(context.get(), cur_buf.get(), buf_size);
578 uint32_t avail_buf_size = FlateGetAvailOut(context.get());
579 if (ret != Z_OK || avail_buf_size != 0) {
580 last_buf_size = buf_size - avail_buf_size;
581 result_tmp_bufs.push_back(
std::move(cur_buf));
584 result_tmp_bufs.push_back(
std::move(cur_buf));
585 cur_buf.reset(FX_Alloc(uint8_t, buf_size + 1));
586 cur_buf.get()[buf_size] =
'\0';
593 *dest_size = FlateGetPossiblyTruncatedTotalOut(context.get());
594 *offset = FlateGetPossiblyTruncatedTotalIn(context.get());
595 if (result_tmp_bufs.size() == 1) {
596 *dest_buf =
std::move(result_tmp_bufs[0]);
601 FX_Alloc(uint8_t, *dest_size));
602 uint32_t result_pos = 0;
603 uint32_t remaining = *dest_size;
604 for (size_t i = 0; i < result_tmp_bufs.size(); i++) {
606 std::move(result_tmp_bufs[i]);
607 uint32_t tmp_buf_size = buf_size;
608 if (i + 1 == result_tmp_bufs.size()) {
609 tmp_buf_size = last_buf_size;
611 uint32_t cp_size =
std::min(tmp_buf_size, remaining);
612 memcpy(result_buf.get() + result_pos, tmp_buf.get(), cp_size);
613 result_pos += cp_size;
614 remaining -= cp_size;
616 *dest_buf =
std::move(result_buf);
619enum class PredictorType : uint8_t { kNone, kFlate, kPng };
620static PredictorType GetPredictor(
int predictor) {
622 return PredictorType::kPng;
624 return PredictorType::kFlate;
625 return PredictorType::kNone;
630 FlateScanlineDecoder(pdfium::span<
const uint8_t> src_span,
635 ~FlateScanlineDecoder()
override;
638 bool Rewind()
override;
639 pdfium::span<uint8_t> GetNextLine()
override;
640 uint32_t GetSrcOffset()
override;
648FlateScanlineDecoder::FlateScanlineDecoder(pdfium::span<
const uint8_t> src_span,
661 m_Scanline(m_Pitch) {}
663FlateScanlineDecoder::~FlateScanlineDecoder() {
665 m_pLastScanline = pdfium::span<uint8_t>();
668bool FlateScanlineDecoder::Rewind() {
669 m_pFlate.reset(FlateInit());
673 FlateInput(m_pFlate.get(), m_SrcBuf);
677pdfium::span<uint8_t> FlateScanlineDecoder::GetNextLine() {
678 FlateOutput(m_pFlate.get(), m_Scanline.data(), m_Pitch);
682uint32_t FlateScanlineDecoder::GetSrcOffset() {
683 return FlateGetPossiblyTruncatedTotalIn(m_pFlate.get());
686class FlatePredictorScanlineDecoder
final :
public FlateScanlineDecoder {
688 FlatePredictorScanlineDecoder(pdfium::span<
const uint8_t> src_span,
693 PredictorType predictor,
695 int BitsPerComponent,
697 ~FlatePredictorScanlineDecoder()
override;
700 bool Rewind()
override;
701 pdfium::span<uint8_t> GetNextLine()
override;
704 void GetNextLineWithPredictedPitch();
705 void GetNextLineWithoutPredictedPitch();
707 const PredictorType m_Predictor;
709 int m_BitsPerComponent = 0;
711 uint32_t m_PredictPitch = 0;
712 size_t m_LeftOver = 0;
713 DataVector<uint8_t> m_LastLine;
714 DataVector<uint8_t> m_PredictBuffer;
715 DataVector<uint8_t> m_PredictRaw;
718FlatePredictorScanlineDecoder::FlatePredictorScanlineDecoder(
719 pdfium::span<
const uint8_t> src_span,
724 PredictorType predictor,
726 int BitsPerComponent,
728 : FlateScanlineDecoder(src_span, width, height, comps, bpc),
729 m_Predictor(predictor) {
730 DCHECK(m_Predictor != PredictorType::kNone);
731 if (BitsPerComponent * Colors * Columns == 0) {
732 BitsPerComponent =
m_bpc;
737 m_BitsPerComponent = BitsPerComponent;
741 m_LastLine.resize(m_PredictPitch);
742 m_PredictBuffer.resize(m_PredictPitch);
743 m_PredictRaw.resize(m_PredictPitch + 1);
746FlatePredictorScanlineDecoder::~FlatePredictorScanlineDecoder() {
748 m_pLastScanline = pdfium::span<uint8_t>();
751bool FlatePredictorScanlineDecoder::Rewind() {
752 if (!FlateScanlineDecoder::Rewind())
759pdfium::span<uint8_t> FlatePredictorScanlineDecoder::GetNextLine() {
761 GetNextLineWithPredictedPitch();
763 GetNextLineWithoutPredictedPitch();
767void FlatePredictorScanlineDecoder::GetNextLineWithPredictedPitch() {
768 switch (m_Predictor) {
769 case PredictorType::kPng:
770 FlateOutput(m_pFlate.get(), m_PredictRaw.data(), m_PredictPitch + 1);
771 PNG_PredictLine(m_Scanline, m_PredictRaw, m_LastLine, m_BitsPerComponent,
772 m_Colors, m_Columns);
773 memcpy(m_LastLine.data(), m_Scanline.data(), m_PredictPitch);
775 case PredictorType::kFlate:
776 FlateOutput(m_pFlate.get(), m_Scanline.data(), m_Pitch);
777 TIFF_PredictLine(m_Scanline.data(), m_PredictPitch, m_bpc, m_nComps,
780 case PredictorType::kNone:
781 NOTREACHED_NORETURN();
785void FlatePredictorScanlineDecoder::GetNextLineWithoutPredictedPitch() {
786 size_t bytes_to_go = m_Pitch;
787 size_t read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
789 memcpy(m_Scanline.data(), &m_PredictBuffer[m_PredictPitch - m_LeftOver],
791 m_LeftOver -= read_leftover;
792 bytes_to_go -= read_leftover;
794 while (bytes_to_go) {
795 switch (m_Predictor) {
796 case PredictorType::kPng:
797 FlateOutput(m_pFlate.get(), m_PredictRaw.data(), m_PredictPitch + 1);
798 PNG_PredictLine(m_PredictBuffer, m_PredictRaw, m_LastLine,
799 m_BitsPerComponent, m_Colors, m_Columns);
800 memcpy(m_LastLine.data(), m_PredictBuffer.data(), m_PredictPitch);
802 case PredictorType::kFlate:
803 FlateOutput(m_pFlate.get(), m_PredictBuffer.data(), m_PredictPitch);
804 TIFF_PredictLine(m_PredictBuffer.data(), m_PredictPitch,
805 m_BitsPerComponent, m_Colors, m_Columns);
807 case PredictorType::kNone:
808 NOTREACHED_NORETURN();
811 m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch;
812 fxcrt::spancpy(pdfium::make_span(m_Scanline).subspan(m_Pitch - bytes_to_go),
813 pdfium::make_span(m_PredictBuffer).first(read_bytes));
814 m_LeftOver += m_PredictPitch - read_bytes;
815 bytes_to_go -= read_bytes;
823 pdfium::span<
const uint8_t> src_span,
830 int BitsPerComponent,
832 PredictorType predictor_type = GetPredictor(predictor);
833 if (predictor_type == PredictorType::kNone) {
834 return std::make_unique<FlateScanlineDecoder>(src_span, width, height,
837 return std::make_unique<FlatePredictorScanlineDecoder>(
838 src_span, width, height, nComps, bpc, predictor_type, Colors,
839 BitsPerComponent, Columns);
845 pdfium::span<
const uint8_t> src_span,
849 int BitsPerComponent,
851 uint32_t estimated_size,
853 uint32_t* dest_size) {
856 PredictorType predictor_type = GetPredictor(predictor);
859 auto decoder =
std::make_unique<CLZWDecoder>(src_span, bEarlyChange);
860 if (!decoder->Decode())
863 offset = decoder->GetSrcSize();
864 *dest_size = decoder->GetDestSize();
865 *dest_buf = decoder->TakeDestBuf();
867 FlateUncompress(src_span, estimated_size, dest_buf, dest_size, &offset);
871 switch (predictor_type) {
872 case PredictorType::kNone:
874 case PredictorType::kPng:
876 PNG_Predictor(Colors, BitsPerComponent, Columns, dest_buf, dest_size);
878 case PredictorType::kFlate:
879 ret = TIFF_Predictor(Colors, BitsPerComponent, Columns, dest_buf,
887DataVector<uint8_t>
FlateModule::Encode(pdfium::span<
const uint8_t> src_span) {
888 const unsigned long src_size =
889 pdfium::base::checked_cast<
unsigned long>(src_span.size());
890 pdfium::base::CheckedNumeric<
unsigned long> safe_dest_size = src_size;
891 safe_dest_size += src_size / 1000;
892 safe_dest_size += 12;
893 unsigned long dest_size = safe_dest_size.ValueOrDie();
894 DataVector<uint8_t> dest_buf(dest_size);
895 if (!FlateCompress(dest_buf.data(), &dest_size, src_span.data(), src_size))
898 dest_buf.resize(pdfium::base::checked_cast<size_t>(dest_size));
static uint32_t FlateOrLZWDecode(bool bLZW, pdfium::span< const uint8_t > src_span, bool bEarlyChange, int predictor, int Colors, int BitsPerComponent, int Columns, uint32_t estimated_size, std::unique_ptr< uint8_t, FxFreeDeleter > *dest_buf, uint32_t *dest_size)
ScanlineDecoder(int nOrigWidth, int nOrigHeight, int nOutputWidth, int nOutputHeight, int nComps, int nBpc, uint32_t nPitch)
const pdfium::span< const uint8_t > m_SrcBuf
static void * my_alloc_func(void *opaque, unsigned int items, unsigned int size)
std::unique_ptr< z_stream, FlateDeleter > m_pFlate
DataVector< uint8_t > m_Scanline
static void my_free_func(void *opaque, void *address)
#define FX_INVALID_OFFSET
uint32_t CalculatePitch8OrDie(uint32_t bpc, uint32_t components, int width)