1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 15:17:36 +00:00

LibCompress: Implement DEFLATE compression

This commit adds a fully functional DEFLATE compression
implementation that can be used to implement compression
for higher level formats like gzip, zlib or zip.

A large part of this commit is based on Hans Wennborg's
great article about the DEFLATE and zip specifications:
https://www.hanshq.net/zip.html
This commit is contained in:
Idan Horowitz 2021-03-13 01:17:18 +02:00 committed by Andreas Kling
parent 168cf6fac9
commit bcbfa7db62
3 changed files with 921 additions and 18 deletions

View file

@ -1,5 +1,6 @@
/*
* Copyright (c) 2020, the SerenityOS developers
* Copyright (c) 2021, Idan Horowitz <idan.horowitz@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -26,8 +27,10 @@
#include <AK/Array.h>
#include <AK/Assertions.h>
#include <AK/BinaryHeap.h>
#include <AK/BinarySearch.h>
#include <AK/MemoryStream.h>
#include <string.h>
#include <LibCompress/Deflate.h>
@ -41,13 +44,7 @@ const CanonicalCode& CanonicalCode::fixed_literal_codes()
if (initialized)
return code;
Array<u8, 288> data;
data.span().slice(0, 144 - 0).fill(8);
data.span().slice(144, 256 - 144).fill(9);
data.span().slice(256, 280 - 256).fill(7);
data.span().slice(280, 288 - 280).fill(8);
code = CanonicalCode::from_bytes(data).value();
code = CanonicalCode::from_bytes(fixed_literal_bit_lengths).value();
initialized = true;
return code;
@ -61,10 +58,7 @@ const CanonicalCode& CanonicalCode::fixed_distance_codes()
if (initialized)
return code;
Array<u8, 32> data;
data.span().fill(5);
code = CanonicalCode::from_bytes(data).value();
code = CanonicalCode::from_bytes(fixed_distance_bit_lengths).value();
initialized = true;
return code;
@ -76,6 +70,22 @@ Optional<CanonicalCode> CanonicalCode::from_bytes(ReadonlyBytes bytes)
CanonicalCode code;
auto non_zero_symbols = 0;
auto last_non_zero = -1;
for (size_t i = 0; i < bytes.size(); i++) {
if (bytes[i] != 0) {
non_zero_symbols++;
last_non_zero = i;
}
}
if (non_zero_symbols == 1) { // special case - only 1 symbol
code.m_symbol_codes.append(0b10);
code.m_symbol_values.append(last_non_zero);
code.m_bit_codes[last_non_zero] = 0;
code.m_bit_code_lengths[last_non_zero] = 1;
return code;
}
auto next_code = 0;
for (size_t code_length = 1; code_length <= 15; ++code_length) {
next_code <<= 1;
@ -90,6 +100,8 @@ Optional<CanonicalCode> CanonicalCode::from_bytes(ReadonlyBytes bytes)
code.m_symbol_codes.append(start_bit | next_code);
code.m_symbol_values.append(symbol);
code.m_bit_codes[symbol] = fast_reverse16(start_bit | next_code, code_length); // DEFLATE writes huffman encoded symbols as lsb-first
code.m_bit_code_lengths[symbol] = code_length;
next_code++;
}
@ -118,6 +130,11 @@ u32 CanonicalCode::read_symbol(InputBitStream& stream) const
}
}
void CanonicalCode::write_symbol(OutputBitStream& stream, u32 symbol) const
{
stream.write_bits(m_bit_codes[symbol], m_bit_code_lengths[symbol]);
}
DeflateDecompressor::CompressedBlock::CompressedBlock(DeflateDecompressor& decompressor, CanonicalCode literal_codes, Optional<CanonicalCode> distance_codes)
: m_decompressor(decompressor)
, m_literal_codes(literal_codes)
@ -366,8 +383,7 @@ void DeflateDecompressor::decode_codes(CanonicalCode& literal_code, Optional<Can
u8 code_lengths_code_lengths[19] = { 0 };
for (size_t i = 0; i < code_length_count; ++i) {
static const size_t indices[] { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
code_lengths_code_lengths[indices[i]] = m_input_stream.read_bits(3);
code_lengths_code_lengths[code_lengths_code_lengths_order[i]] = m_input_stream.read_bits(3);
}
// Now we can extract the code that was used to encode the code lengths of the code that was used to
@ -386,21 +402,21 @@ void DeflateDecompressor::decode_codes(CanonicalCode& literal_code, Optional<Can
while (code_lengths.size() < literal_code_count + distance_code_count) {
auto symbol = code_length_code.read_symbol(m_input_stream);
if (symbol <= 15) {
if (symbol < DeflateSpecialCodeLengths::COPY) {
code_lengths.append(static_cast<u8>(symbol));
continue;
} else if (symbol == 17) {
} else if (symbol == DeflateSpecialCodeLengths::ZEROS) {
auto nrepeat = 3 + m_input_stream.read_bits(3);
for (size_t j = 0; j < nrepeat; ++j)
code_lengths.append(0);
continue;
} else if (symbol == 18) {
} else if (symbol == DeflateSpecialCodeLengths::LONG_ZEROS) {
auto nrepeat = 11 + m_input_stream.read_bits(7);
for (size_t j = 0; j < nrepeat; ++j)
code_lengths.append(0);
continue;
} else {
VERIFY(symbol == 16);
VERIFY(symbol == DeflateSpecialCodeLengths::COPY);
if (code_lengths.is_empty()) {
set_fatal_error();
@ -448,4 +464,571 @@ void DeflateDecompressor::decode_codes(CanonicalCode& literal_code, Optional<Can
distance_code = distance_code_result.value();
}
DeflateCompressor::DeflateCompressor(OutputStream& stream, CompressionLevel compression_level)
: m_compression_level(compression_level)
, m_compression_constants(compression_constants[static_cast<int>(m_compression_level)])
, m_output_stream(stream)
{
m_symbol_frequencies.fill(0);
m_distance_frequencies.fill(0);
}
DeflateCompressor::~DeflateCompressor()
{
VERIFY(m_finished);
}
size_t DeflateCompressor::write(ReadonlyBytes bytes)
{
VERIFY(!m_finished);
if (bytes.size() == 0)
return 0; // recursion base case
auto n_written = bytes.copy_trimmed_to(pending_block().slice(m_pending_block_size));
m_pending_block_size += n_written;
if (m_pending_block_size == block_size)
flush();
return n_written + write(bytes.slice(n_written));
}
bool DeflateCompressor::write_or_error(ReadonlyBytes bytes)
{
if (write(bytes) < bytes.size()) {
set_fatal_error();
return false;
}
return true;
}
// Knuth's multiplicative hash on 4 bytes
u16 DeflateCompressor::hash_sequence(const u8* bytes)
{
constexpr const u32 knuth_constant = 2654435761; // shares no common factors with 2^32
return ((bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24) * knuth_constant) >> (32 - hash_bits);
}
size_t DeflateCompressor::compare_match_candidate(size_t start, size_t candidate, size_t previous_match_length, size_t maximum_match_length)
{
VERIFY(previous_match_length < maximum_match_length);
// We firstly check that the match is at least (prev_match_length + 1) long, we check backwards as theres a higher chance the end mismatches
for (ssize_t i = previous_match_length; i >= 0; i--) {
if (m_rolling_window[start + i] != m_rolling_window[candidate + i])
return 0;
}
// Find the actual length
auto match_length = previous_match_length + 1;
while (match_length < maximum_match_length && m_rolling_window[start + match_length] == m_rolling_window[candidate + match_length]) {
match_length++;
}
VERIFY(match_length > previous_match_length);
VERIFY(match_length <= maximum_match_length);
return match_length;
}
size_t DeflateCompressor::find_back_match(size_t start, u16 hash, size_t previous_match_length, size_t maximum_match_length, size_t& match_position)
{
auto max_chain_length = m_compression_constants.max_chain;
if (previous_match_length == 0)
previous_match_length = min_match_length - 1; // we only care about matches that are at least min_match_length long
if (previous_match_length >= maximum_match_length)
return 0; // we cant improve a maximum length match
if (previous_match_length >= m_compression_constants.max_lazy_length)
return 0; // the previous match is already pretty, we shouldn't waste another full search
if (previous_match_length >= m_compression_constants.good_match_length)
max_chain_length /= 4; // we already have a pretty good much, so do a shorter search
auto candidate = m_hash_head[hash];
auto match_found = false;
while (max_chain_length--) {
if (candidate == empty_slot)
break; // no remaining candidates
VERIFY(candidate < start);
if (start - candidate > window_size)
break; // outside the window
auto match_length = compare_match_candidate(start, candidate, previous_match_length, maximum_match_length);
if (match_length != 0) {
match_found = true;
match_position = candidate;
previous_match_length = match_length;
if (match_length == maximum_match_length)
return match_length; // bail if we got the maximum possible length
}
candidate = m_hash_prev[candidate % window_size];
}
if (!match_found)
return 0; // we didnt find any matches
return previous_match_length; // we found matches, but they were at most previous_match_length long
}
ALWAYS_INLINE u8 DeflateCompressor::distance_to_base(u16 distance)
{
return (distance <= 256) ? distance_to_base_lo[distance - 1] : distance_to_base_hi[(distance - 1) >> 7];
}
template<size_t Size>
void DeflateCompressor::generate_huffman_lengths(Array<u8, Size>& lengths, const Array<u16, Size>& frequencies, size_t max_bit_length)
{
VERIFY((1u << max_bit_length) >= Size);
u16 heap_keys[Size]; // Used for O(n) heap construction
u16 heap_values[Size];
u16 huffman_links[Size * 2 + 1] = { 0 };
u16 frequency_cap = UINT16_MAX;
try_again:
size_t non_zero_freqs = 0;
for (size_t i = 0; i < Size; i++) {
auto frequency = frequencies[i];
if (frequency == 0)
continue;
if (frequency > frequency_cap) {
frequency = frequency_cap;
}
heap_keys[non_zero_freqs] = frequency; // sort symbols by frequency
heap_values[non_zero_freqs] = Size + non_zero_freqs; // huffman_links "links"
non_zero_freqs++;
}
// special case for only 1 used symbol
if (non_zero_freqs < 2) {
for (size_t i = 0; i < Size; i++)
lengths[i] = (frequencies[i] == 0) ? 0 : 1;
return;
}
BinaryHeap<u16, u16, Size> heap { heap_keys, heap_values, non_zero_freqs };
// build the huffman tree - binary heap is used for efficient frequency comparisons
while (heap.size() > 1) {
u16 lowest_frequency = heap.peek_min_key();
u16 lowest_link = heap.pop_min();
u16 second_lowest_frequency = heap.peek_min_key();
u16 second_lowest_link = heap.pop_min();
u16 new_link = heap.size() + 2;
heap.insert(lowest_frequency + second_lowest_frequency, new_link);
huffman_links[lowest_link] = new_link;
huffman_links[second_lowest_link] = new_link;
}
non_zero_freqs = 0;
for (size_t i = 0; i < Size; i++) {
if (frequencies[i] == 0) {
lengths[i] = 0;
continue;
}
u16 link = huffman_links[Size + non_zero_freqs];
non_zero_freqs++;
size_t bit_length = 1;
while (link != 2) {
bit_length++;
link = huffman_links[link];
}
if (bit_length > max_bit_length) {
VERIFY(frequency_cap != 1);
frequency_cap /= 2;
goto try_again; // FIXME: gotos are ugly, but i cant think of a good way to flatten this
}
lengths[i] = bit_length;
}
}
void DeflateCompressor::lz77_compress_block()
{
for (auto& slot : m_hash_head) { // initialize chained hash table
slot = empty_slot;
}
auto insert_hash = [&](auto pos, auto hash) {
auto window_pos = pos % window_size;
m_hash_prev[window_pos] = m_hash_head[hash];
m_hash_head[hash] = window_pos;
};
auto emit_literal = [&](auto literal) {
VERIFY(m_pending_symbol_size <= block_size + 1);
auto index = m_pending_symbol_size++;
m_symbol_buffer[index].distance = 0;
m_symbol_buffer[index].literal = literal;
m_symbol_frequencies[literal]++;
};
auto emit_back_reference = [&](auto distance, auto length) {
VERIFY(m_pending_symbol_size <= block_size + 1);
auto index = m_pending_symbol_size++;
m_symbol_buffer[index].distance = distance;
m_symbol_buffer[index].length = length;
m_symbol_frequencies[length_to_symbol[length]]++;
m_distance_frequencies[distance_to_base(distance)]++;
};
size_t previous_match_length = 0;
size_t previous_match_position = 0;
VERIFY(m_compression_constants.great_match_length <= max_match_length);
// our block starts at block_size and is m_pending_block_size in length
auto block_end = block_size + m_pending_block_size;
size_t current_position;
for (current_position = block_size; current_position < block_end - min_match_length + 1; current_position++) {
auto hash = hash_sequence(&m_rolling_window[current_position]);
size_t match_position;
auto match_length = find_back_match(current_position, hash, previous_match_length,
min(m_compression_constants.great_match_length, block_end - current_position), match_position);
insert_hash(current_position, hash);
// if the previous match is as good as the new match, just use it
if (previous_match_length != 0 && previous_match_length >= match_length) {
emit_back_reference((current_position - 1) - previous_match_position, previous_match_length);
// skip all the bytes that are included in this match
for (size_t j = current_position + 1; j < min(current_position - 1 + previous_match_length, block_end - min_match_length + 1); j++) {
insert_hash(j, hash_sequence(&m_rolling_window[j]));
}
current_position = (current_position - 1) + previous_match_length - 1;
previous_match_length = 0;
continue;
}
if (match_length == 0) {
VERIFY(previous_match_length == 0);
emit_literal(m_rolling_window[current_position]);
continue;
}
// if this is a lazy match, and the new match is better than the old one, output previous as literal
if (previous_match_length != 0) {
emit_literal(m_rolling_window[current_position - 1]);
}
previous_match_length = match_length;
previous_match_position = match_position;
}
// clean up leftover lazy match
if (previous_match_length != 0) {
emit_back_reference((current_position - 1) - previous_match_position, previous_match_length);
current_position = (current_position - 1) + previous_match_length;
}
// output remaining literals
while (current_position < block_end) {
emit_literal(m_rolling_window[current_position++]);
}
}
size_t DeflateCompressor::huffman_block_length(const Array<u8, max_huffman_literals>& literal_bit_lengths, const Array<u8, max_huffman_distances>& distance_bit_lengths)
{
size_t length = 0;
for (size_t i = 0; i < 286; i++) {
auto frequency = m_symbol_frequencies[i];
length += literal_bit_lengths[i] * frequency;
if (i >= 257) // back reference length symbols
length += packed_length_symbols[i - 257].extra_bits * frequency;
}
for (size_t i = 0; i < 30; i++) {
auto frequency = m_distance_frequencies[i];
length += distance_bit_lengths[i] * frequency;
length += packed_distances[i].extra_bits * frequency;
}
return length;
}
size_t DeflateCompressor::uncompressed_block_length()
{
auto padding = 8 - ((m_output_stream.bit_offset() + 3) % 8);
// 3 bit block header + align to byte + 2 * 16 bit length fields + block contents
return 3 + padding + (2 * 16) + m_pending_block_size * 8;
}
size_t DeflateCompressor::fixed_block_length()
{
// block header + fixed huffman encoded block contents
return 3 + huffman_block_length(fixed_literal_bit_lengths, fixed_distance_bit_lengths);
}
size_t DeflateCompressor::dynamic_block_length(const Array<u8, max_huffman_literals>& literal_bit_lengths, const Array<u8, max_huffman_distances>& distance_bit_lengths, const Array<u8, 19>& code_lengths_bit_lengths, const Array<u16, 19>& code_lengths_frequencies, size_t code_lengths_count)
{
// block header + literal code count + distance code count + code length count
auto length = 3 + 5 + 5 + 4;
// 3 bits per code_length
length += 3 * code_lengths_count;
for (size_t i = 0; i < code_lengths_frequencies.size(); i++) {
auto frequency = code_lengths_frequencies[i];
length += code_lengths_bit_lengths[i] * frequency;
if (i == DeflateSpecialCodeLengths::COPY) {
length += 2 * frequency;
} else if (i == DeflateSpecialCodeLengths::ZEROS) {
length += 3 * frequency;
} else if (i == DeflateSpecialCodeLengths::LONG_ZEROS) {
length += 7 * frequency;
}
}
return length + huffman_block_length(literal_bit_lengths, distance_bit_lengths);
}
void DeflateCompressor::write_huffman(const CanonicalCode& literal_code, const CanonicalCode& distance_code)
{
for (size_t i = 0; i < m_pending_symbol_size; i++) {
if (m_symbol_buffer[i].distance == 0) {
literal_code.write_symbol(m_output_stream, m_symbol_buffer[i].literal);
continue;
}
auto symbol = length_to_symbol[m_symbol_buffer[i].length];
literal_code.write_symbol(m_output_stream, symbol);
// Emit extra bits if needed
m_output_stream.write_bits(m_symbol_buffer[i].length - packed_length_symbols[symbol - 257].base_length, packed_length_symbols[symbol - 257].extra_bits);
auto base_distance = distance_to_base(m_symbol_buffer[i].distance);
distance_code.write_symbol(m_output_stream, base_distance);
// Emit extra bits if needed
m_output_stream.write_bits(m_symbol_buffer[i].distance - packed_distances[base_distance].base_distance, packed_distances[base_distance].extra_bits);
}
}
size_t DeflateCompressor::encode_huffman_lengths(const Array<u8, max_huffman_literals + max_huffman_distances>& lengths, size_t lengths_count, Array<code_length_symbol, max_huffman_literals + max_huffman_distances>& encoded_lengths)
{
size_t encoded_count = 0;
size_t i = 0;
while (i < lengths_count) {
if (lengths[i] == 0) {
auto zero_count = 0;
for (size_t j = i; j < min(lengths_count, i + 138) && lengths[j] == 0; j++)
zero_count++;
if (zero_count < 3) { // below minimum repeated zero count
encoded_lengths[encoded_count++].symbol = 0;
i++;
continue;
}
if (zero_count <= 10) {
encoded_lengths[encoded_count].symbol = DeflateSpecialCodeLengths::ZEROS;
encoded_lengths[encoded_count++].count = zero_count;
} else {
encoded_lengths[encoded_count].symbol = DeflateSpecialCodeLengths::LONG_ZEROS;
encoded_lengths[encoded_count++].count = zero_count;
}
i += zero_count;
continue;
}
encoded_lengths[encoded_count++].symbol = lengths[i++];
auto copy_count = 0;
for (size_t j = i; j < min(lengths_count, i + 6) && lengths[j] == lengths[i - 1]; j++)
copy_count++;
if (copy_count >= 3) {
encoded_lengths[encoded_count].symbol = DeflateSpecialCodeLengths::COPY;
encoded_lengths[encoded_count++].count = copy_count;
i += copy_count;
continue;
}
}
return encoded_count;
}
size_t DeflateCompressor::encode_block_lengths(const Array<u8, max_huffman_literals>& literal_bit_lengths, const Array<u8, max_huffman_distances>& distance_bit_lengths, Array<code_length_symbol, max_huffman_literals + max_huffman_distances>& encoded_lengths, size_t& literal_code_count, size_t& distance_code_count)
{
literal_code_count = max_huffman_literals;
distance_code_count = max_huffman_distances;
VERIFY(literal_bit_lengths[256] != 0); // Make sure at least the EndOfBlock marker is present
while (literal_bit_lengths[literal_code_count - 1] == 0)
literal_code_count--;
// Drop trailing zero lengths, keeping at least one
while (distance_bit_lengths[distance_code_count - 1] == 0 && distance_code_count > 1)
distance_code_count--;
Array<u8, max_huffman_literals + max_huffman_distances> all_lengths {};
size_t lengths_count = 0;
for (size_t i = 0; i < literal_code_count; i++) {
all_lengths[lengths_count++] = literal_bit_lengths[i];
}
for (size_t i = 0; i < distance_code_count; i++) {
all_lengths[lengths_count++] = distance_bit_lengths[i];
}
return encode_huffman_lengths(all_lengths, lengths_count, encoded_lengths);
}
void DeflateCompressor::write_dynamic_huffman(const CanonicalCode& literal_code, size_t literal_code_count, const CanonicalCode& distance_code, size_t distance_code_count, const Array<u8, 19>& code_lengths_bit_lengths, size_t code_length_count, const Array<code_length_symbol, max_huffman_literals + max_huffman_distances>& encoded_lengths, size_t encoded_lengths_count)
{
m_output_stream.write_bits(literal_code_count - 257, 5);
m_output_stream.write_bits(distance_code_count - 1, 5);
m_output_stream.write_bits(code_length_count - 4, 4);
for (size_t i = 0; i < code_length_count; i++) {
m_output_stream.write_bits(code_lengths_bit_lengths[code_lengths_code_lengths_order[i]], 3);
}
auto code_lengths_code = CanonicalCode::from_bytes(code_lengths_bit_lengths);
VERIFY(code_lengths_code.has_value());
for (size_t i = 0; i < encoded_lengths_count; i++) {
auto encoded_length = encoded_lengths[i];
code_lengths_code->write_symbol(m_output_stream, encoded_length.symbol);
if (encoded_length.symbol == DeflateSpecialCodeLengths::COPY) {
m_output_stream.write_bits(encoded_length.count - 3, 2);
} else if (encoded_length.symbol == DeflateSpecialCodeLengths::ZEROS) {
m_output_stream.write_bits(encoded_length.count - 3, 3);
} else if (encoded_length.symbol == DeflateSpecialCodeLengths::LONG_ZEROS) {
m_output_stream.write_bits(encoded_length.count - 11, 7);
}
}
write_huffman(literal_code, distance_code);
}
void DeflateCompressor::flush()
{
if (m_output_stream.handle_any_error()) {
set_fatal_error();
return;
}
m_output_stream.write_bit(m_finished);
// if this is just an empty block to signify the end of the deflate stream use the smallest block possible (10 bits total)
if (m_pending_block_size == 0) {
VERIFY(m_finished); // we shouldn't be writing empty blocks unless this is the final one
m_output_stream.write_bits(0b01, 2); // fixed huffman codes
m_output_stream.write_bits(0b0000000, 7); // end of block symbol
m_output_stream.align_to_byte_boundary();
return;
}
auto write_uncompressed = [&]() {
m_output_stream.write_bits(0b00, 2); // no compression
m_output_stream.align_to_byte_boundary();
LittleEndian<u16> len = m_pending_block_size;
m_output_stream << len;
LittleEndian<u16> nlen = ~m_pending_block_size;
m_output_stream << nlen;
m_output_stream.write_or_error(pending_block().slice(0, m_pending_block_size));
};
if (m_compression_level == CompressionLevel::STORE) { // disabled compression fast path
write_uncompressed();
m_pending_block_size = 0;
return;
}
// The following implementation of lz77 compression and huffman encoding is based on the reference implementation by Hans Wennborg https://www.hanshq.net/zip.html
// this reads from the pending block and writes to m_symbol_buffer
lz77_compress_block();
// insert EndOfBlock marker to the symbol buffer
m_symbol_buffer[m_pending_symbol_size].distance = 0;
m_symbol_buffer[m_pending_symbol_size++].literal = 256;
m_symbol_frequencies[256]++;
// generate optimal dynamic huffman code lengths
Array<u8, max_huffman_literals> dynamic_literal_bit_lengths {};
Array<u8, max_huffman_distances> dynamic_distance_bit_lengths {};
generate_huffman_lengths(dynamic_literal_bit_lengths, m_symbol_frequencies, 15); // deflate data huffman can use up to 15 bits per symbol
generate_huffman_lengths(dynamic_distance_bit_lengths, m_distance_frequencies, 15);
// encode literal and distance lengths together in deflate format
Array<code_length_symbol, max_huffman_literals + max_huffman_distances> encoded_lengths {};
size_t literal_code_count;
size_t distance_code_count;
auto encoded_lengths_count = encode_block_lengths(dynamic_literal_bit_lengths, dynamic_distance_bit_lengths, encoded_lengths, literal_code_count, distance_code_count);
// count code length frequencies
Array<u16, 19> code_lengths_frequencies { 0 };
for (size_t i = 0; i < encoded_lengths_count; i++) {
code_lengths_frequencies[encoded_lengths[i].symbol]++;
}
// generate optimal huffman code lengths code lengths
Array<u8, 19> code_lengths_bit_lengths {};
generate_huffman_lengths(code_lengths_bit_lengths, code_lengths_frequencies, 7); // deflate code length huffman can use up to 7 bits per symbol
// calculate actual code length code lengths count (without trailing zeros)
auto code_lengths_count = code_lengths_bit_lengths.size();
while (code_lengths_bit_lengths[code_lengths_code_lengths_order[code_lengths_count - 1]] == 0)
code_lengths_count--;
auto uncompressed_size = uncompressed_block_length();
auto fixed_huffman_size = fixed_block_length();
auto dynamic_huffman_size = dynamic_block_length(dynamic_literal_bit_lengths, dynamic_distance_bit_lengths, code_lengths_bit_lengths, code_lengths_frequencies, code_lengths_count);
// If the compression somehow didnt reduce the size enough, just write out the block uncompressed as it allows for much faster decompression
if (uncompressed_size <= min(fixed_huffman_size, dynamic_huffman_size)) {
write_uncompressed();
} else if (fixed_huffman_size <= dynamic_huffman_size) { // If the fixed and dynamic huffman codes come out the same size, prefer the fixed version, as it takes less time to decode
m_output_stream.write_bits(0b01, 2); // fixed huffman codes
write_huffman(CanonicalCode::fixed_literal_codes(), CanonicalCode::fixed_distance_codes());
} else {
m_output_stream.write_bits(0b10, 2); // dynamic huffman codes
auto literal_code = CanonicalCode::from_bytes(dynamic_literal_bit_lengths);
VERIFY(literal_code.has_value());
auto distance_code = CanonicalCode::from_bytes(dynamic_distance_bit_lengths);
VERIFY(distance_code.has_value());
write_dynamic_huffman(literal_code.value(), literal_code_count, distance_code.value(), distance_code_count, code_lengths_bit_lengths, code_lengths_count, encoded_lengths, encoded_lengths_count);
}
if (m_finished)
m_output_stream.align_to_byte_boundary();
// reset all block specific members
m_pending_block_size = 0;
m_pending_symbol_size = 0;
m_symbol_frequencies.fill(0);
m_distance_frequencies.fill(0);
// On the final block this copy will potentially produce an invalid search window, but since its the final block we dont care
pending_block().copy_trimmed_to({ m_rolling_window, block_size });
}
void DeflateCompressor::final_flush()
{
VERIFY(!m_finished);
m_finished = true;
flush();
}
Optional<ByteBuffer> DeflateCompressor::compress_all(const ReadonlyBytes& bytes, CompressionLevel compression_level)
{
DuplexMemoryStream output_stream;
DeflateCompressor deflate_stream { output_stream, compression_level };
deflate_stream.write_or_error(bytes);
deflate_stream.final_flush();
if (deflate_stream.handle_any_error())
return {};
return output_stream.copy_into_contiguous_buffer();
}
}