rle_detail.cpp
compression/compressors/rle/rle_detail.cpp · 103 line(s) · c
/*
* Run-length encoding -- C++ implementation shared by the RLE plugin.
*
* PackBits-style control-byte RLE (see rle_detail.h). Lossless for any input;
* worst case (no runs) expands by about 1 byte per 128 literal bytes. Both
* entry points validate sizes and fail closed on truncated input, following the
* codecs/ security posture (bound every write, reject malformed headers).
*/
#include "rle_detail.h"
namespace {
constexpr size_t MAX_LITERAL = 128; /* control 0x00..0x7F -> 1..128 literals */
constexpr size_t MAX_REPEAT = 128; /* control 0x80..0xFF -> 2..128 repeats */
/* Length of the maximal run of the identical byte input[i] starting at i. */
size_t run_length(const uint8_t *input, size_t input_len, size_t i) {
size_t n = 1;
while (i + n < input_len && input[i + n] == input[i] && n < MAX_REPEAT) ++n;
return n;
}
} // namespace
extern "C" sleela_compression_result sleela_rle_encode(const uint8_t *input, size_t input_len,
uint8_t *out, size_t *out_len) {
if (!out_len) return SLEELA_COMPRESSION_ERR_INVALID;
if (input_len && !input) return SLEELA_COMPRESSION_ERR_INVALID;
const size_t cap = out ? *out_len : 0;
size_t written = 0;
size_t i = 0;
/* Emit one control byte plus its payload, respecting cap when out != NULL. */
auto put = [&](uint8_t b) -> bool {
if (out) { if (written >= cap) return false; out[written] = b; }
++written;
return true;
};
while (i < input_len) {
size_t run = run_length(input, input_len, i);
if (run >= 2) {
/* Repeat run of `run` copies (2..128): control = 257 - run. */
if (!put((uint8_t)(257 - run))) return SLEELA_COMPRESSION_ERR_BUFFER;
if (!put(input[i])) return SLEELA_COMPRESSION_ERR_BUFFER;
i += run;
} else {
/* Gather a literal span until a run of >=2 appears or we hit 128. */
size_t start = i;
size_t lit = 0;
while (i < input_len && lit < MAX_LITERAL) {
if (run_length(input, input_len, i) >= 2) break;
++i;
++lit;
}
if (!put((uint8_t)(lit - 1))) return SLEELA_COMPRESSION_ERR_BUFFER;
for (size_t k = 0; k < lit; ++k)
if (!put(input[start + k])) return SLEELA_COMPRESSION_ERR_BUFFER;
}
}
*out_len = written;
return SLEELA_COMPRESSION_OK;
}
extern "C" sleela_compression_result sleela_rle_decode(const uint8_t *input, size_t input_len,
uint8_t *out, size_t *out_len) {
if (!out_len) return SLEELA_COMPRESSION_ERR_INVALID;
if (input_len && !input) return SLEELA_COMPRESSION_ERR_INVALID;
const size_t cap = out ? *out_len : 0;
size_t written = 0;
size_t i = 0;
auto put = [&](uint8_t b) -> bool {
if (out) { if (written >= cap) return false; out[written] = b; }
++written;
return true;
};
while (i < input_len) {
uint8_t ctrl = input[i++];
if (ctrl < MAX_LITERAL) {
size_t lit = (size_t)ctrl + 1; /* 1..128 literal bytes */
if (i + lit > input_len) return SLEELA_COMPRESSION_ERR_FORMAT; /* truncated */
for (size_t k = 0; k < lit; ++k)
if (!put(input[i + k])) return SLEELA_COMPRESSION_ERR_BUFFER;
i += lit;
} else {
size_t rep = (size_t)(257 - ctrl); /* 2..128 copies */
if (i >= input_len) return SLEELA_COMPRESSION_ERR_FORMAT; /* truncated */
uint8_t v = input[i++];
for (size_t k = 0; k < rep; ++k)
if (!put(v)) return SLEELA_COMPRESSION_ERR_BUFFER;
}
}
*out_len = written;
return SLEELA_COMPRESSION_OK;
}