78#ifdef USE_FIND_FASTPATH
84 constexpr size_t min_size_for_fast_path = (
88 sizeof(size_t) +
sizeof(fast_int) +
93 if (size - offset > min_size_for_fast_path) [[likely]] {
98 const uint8_t *p_end = p +
sizeof(
size_t[2]);
100 if (*p != value) [[likely]] {
101 return size_t(p -
data);
109 p_end =
reinterpret_cast<const uint8_t *
>(
110 ((
uintptr_t(p) +
sizeof(size_t) +
sizeof(fast_int)) & ~(
sizeof(fast_int) - 1)));
112 if (*p != value) [[likely]] {
113 return size_t(p -
data);
124 const fast_int *p_fast =
reinterpret_cast<const fast_int *
>(p);
126 const fast_int *p_fast_last =
reinterpret_cast<const fast_int *
>(
data +
127 (size -
sizeof(fast_int)));
130 memset(&value_fast, value,
sizeof(value_fast));
133 if (*p_fast != value_fast) [[unlikely]] {
137 }
while (p_fast <= p_fast_last);
138 offset = size_t(
reinterpret_cast<const uint8_t *
>(p_fast) -
data);
143 while ((offset < size) && (value ==
data[offset])) {
177 size_t *span_skip_next_p)
182 constexpr size_t rle_skip_threshold = RLE_SKIP_THRESHOLD;
183 size_t ofs_test_start = offset;
185#ifdef USE_FIND_FASTPATH
189 constexpr size_t min_size_for_fast_path = (
199 (((rle_skip_threshold - 1) + (
sizeof(fast_int) - 1)) & ~(
sizeof(fast_int) - 1)));
202 if (size - offset > min_size_for_fast_path) {
203 constexpr size_t ALIGN_BITS =
sizeof(fast_int) - 1;
206 const fast_int *p =
reinterpret_cast<const fast_int *
>(
207 ((
uintptr_t(
data + offset) +
sizeof(fast_int)) & ~ALIGN_BITS));
208 const fast_int *p_end =
reinterpret_cast<const fast_int *
>(
209 ((
uintptr_t(
data + size) -
sizeof(fast_int)) & ~ALIGN_BITS));
223 const size_t stop_pos = size_t(
reinterpret_cast<const uint8_t *
>(p) -
data);
224 const size_t backtrack = rle_skip_threshold - 1;
225 if (stop_pos > offset + backtrack) {
226 ofs_test_start = stop_pos - backtrack;
233 size_t ofs_test = ofs_test_start + 1;
235 if (ofs_test < size) [[likely]] {
239 if (value ==
data[ofs_test]) {
241 const size_t span_test = ofs_test - ofs_test_start;
243 if (span_test == rle_skip_threshold) {
246 *span_skip_next_p = span_test;
247 return ofs_test_start;
251 BLI_assert(ofs_test - ofs_test_start < rle_skip_threshold);
252 value =
data[ofs_test];
253 ofs_test_start = ofs_test;
256 }
while (
LIKELY(ofs_test < size));
364 const size_t data_dec_len,
365 const size_t data_enc_extra_size,
366 size_t *r_data_enc_len)
368 size_t data_enc_alloc_size = data_enc_extra_size +
383 constexpr size_t rle_skip_threshold =
sizeof(
RLE_Literal);
389 for (
size_t ofs_dec = 0, span_skip_next = 1; ofs_dec < data_dec_len;) {
391 size_t ofs_dec_next = ofs_dec + span_skip_next;
395 uint8_t value_start = data_dec[ofs_dec];
399 const size_t span = ofs_dec_next - ofs_dec;
400 if (span >= rle_skip_threshold) {
402 BLI_assert(data_dec[ofs_dec] == data_dec[(ofs_dec + span) - 1]);
403 BLI_assert((ofs_dec + span == data_dec_len) ||
404 (data_dec[ofs_dec] != data_dec[(ofs_dec + span)]));
405 e->
head.span_size = span;
406 e->span.value = value_start;
407 data_enc_alloc_size +=
sizeof(
RLE_Span);
413 data_dec, ofs_dec_next, data_dec_len, &span_skip_next);
416 const size_t non_rle_span = ofs_dec_next - ofs_dec;
417 e->
head.span_size = 0;
418 e->literal.value = non_rle_span;
419 data_enc_alloc_size +=
sizeof(
RLE_Literal) + non_rle_span;
422 ofs_dec = ofs_dec_next;
427 data_enc += data_enc_extra_size;
437 if (
e->
head.span_size) {
438 memcpy(data_enc + ofs_enc, &
e->span,
sizeof(
RLE_Span));
440 ofs_dec +=
e->
head.span_size;
443 memcpy(data_enc + ofs_enc, &
e->literal,
sizeof(
RLE_Literal));
446 const size_t non_rle_span =
e->literal.value;
447 memcpy(data_enc + ofs_enc, data_dec + ofs_dec, non_rle_span);
448 ofs_enc += non_rle_span;
449 ofs_dec += non_rle_span;
457 memset(data_enc + ofs_enc, 0x0,
sizeof(
RLE_Literal));
459 *r_data_enc_len = data_enc_alloc_size - data_enc_extra_size;
461 data_enc -= data_enc_extra_size;
466 const size_t data_enc_len,
468 const size_t data_dec_len)
479 memcpy(&
e, data_enc + ofs_enc,
sizeof(
RLE_Head));
481 if (
e.span_size != 0) {
483 const uint8_t value = *
reinterpret_cast<const uint8_t *
>(data_enc + ofs_enc);
484 memset(data_dec + ofs_dec,
int(value),
e.span_size);
486 ofs_dec +=
e.span_size;
491 memcpy(&non_rle_span, data_enc + ofs_enc,
sizeof(
size_t));
492 ofs_enc +=
sizeof(size_t);
494 memcpy(data_dec + ofs_dec, data_enc + ofs_enc, non_rle_span);
495 ofs_enc += non_rle_span;
496 ofs_dec += non_rle_span;