mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-09 21:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "(xdelta3) Slim down on dependency"

Browse Source 
This reverts commit d7d659147c15394f72c3e53953bfb4291bd8c982.
This commit is contained in:
libretroadmin 2022-12-19 03:25:15 +01:00
parent 910db94e9f
commit 91f3611fdd
8 changed files with 1085 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
deps/xdelta3/xdelta3-decode.h vendored
View File

@ -162,6 +162,9 @@ xd3_decode_allocate (xd3_stream *stream,
uint8_t **buf_ptr, uint8_t **buf_ptr,
usize_t *buf_alloc) usize_t *buf_alloc)
{ {
IF_DEBUG2 (DP(RINT "[xd3_decode_allocate] size %"W"u alloc %"W"u\n",
size, *buf_alloc));
if (*buf_ptr != NULL && *buf_alloc < size) if (*buf_ptr != NULL && *buf_alloc < size)
{ {
xd3_free (stream, *buf_ptr); xd3_free (stream, *buf_ptr);
@ -187,6 +190,9 @@ xd3_decode_section (xd3_stream *stream,
xd3_decode_state nstate, xd3_decode_state nstate,
int copy) int copy)
{ {
XD3_ASSERT (section->pos <= section->size);
XD3_ASSERT (stream->dec_state != nstate);
if (section->pos < section->size) if (section->pos < section->size)
{ {
usize_t sect_take; usize_t sect_take;
@ -201,6 +207,8 @@ xd3_decode_section (xd3_stream *stream,
/* No allocation/copy needed */ /* No allocation/copy needed */
section->buf = stream->next_in; section->buf = stream->next_in;
sect_take = section->size; sect_take = section->size;
IF_DEBUG1 (DP(RINT "[xd3_decode_section] zerocopy %"W"u @ %"W"u avail %"W"u\n",
sect_take, section->pos, stream->avail_in));
} }
else else
{ {
@ -217,11 +225,17 @@ xd3_decode_section (xd3_stream *stream,
section->size, section->size,
& section->copied1, & section->copied1,
& section->alloc1))) & section->alloc1)))
{
return ret; return ret;
}
section->buf = section->copied1; section->buf = section->copied1;
} }
IF_DEBUG2 (DP(RINT "[xd3_decode_section] take %"W"u @ %"W"u [need %"W"u] avail %"W"u\n",
sect_take, section->pos, sect_need, stream->avail_in));
XD3_ASSERT (section->pos + sect_take <= section->alloc1);
memcpy (section->copied1 + section->pos, memcpy (section->copied1 + section->pos,
stream->next_in, stream->next_in,
sect_take); sect_take);
@ -236,10 +250,14 @@ xd3_decode_section (xd3_stream *stream,
if (section->pos < section->size) if (section->pos < section->size)
{ {
IF_DEBUG1 (DP(RINT "[xd3_decode_section] further input required %"W"u\n",
section->size - section->pos));
stream->msg = "further input required"; stream->msg = "further input required";
return XD3_INPUT; return XD3_INPUT;
} }
XD3_ASSERT (section->pos == section->size);
stream->dec_state = nstate; stream->dec_state = nstate;
section->buf_max = section->buf + section->size; section->buf_max = section->buf + section->size;
section->pos = 0; section->pos = 0;
@ -269,13 +287,27 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
/* For copy instructions, read address. */ /* For copy instructions, read address. */
if (inst->type >= XD3_CPY) if (inst->type >= XD3_CPY)
{ {
IF_DEBUG2 ({
static int cnt = 0;
XPR(NT "DECODE:%u: COPY at %"Q"u (winoffset %"W"u) "
"size %"W"u winaddr %"W"u\n",
cnt++,
stream->total_out + (stream->dec_position -
stream->dec_cpylen),
(stream->dec_position - stream->dec_cpylen),
inst->size,
inst->addr);
});
if ((ret = xd3_decode_address (stream, if ((ret = xd3_decode_address (stream,
stream->dec_position, stream->dec_position,
inst->type - XD3_CPY, inst->type - XD3_CPY,
& stream->addr_sect.buf, & stream->addr_sect.buf,
stream->addr_sect.buf_max, stream->addr_sect.buf_max,
& inst->addr))) & inst->addr)))
{
return ret; return ret;
}
/* Cannot copy an address before it is filled-in. */ /* Cannot copy an address before it is filled-in. */
if (inst->addr >= stream->dec_position) if (inst->addr >= stream->dec_position)
@ -293,6 +325,30 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
return XD3_INVALID_INPUT; return XD3_INVALID_INPUT;
} }
} }
else
{
IF_DEBUG2 ({
if (inst->type == XD3_ADD)
{
static int cnt;
XPR(NT "DECODE:%d: ADD at %"Q"u (winoffset %"W"u) size %"W"u\n",
cnt++,
(stream->total_out + stream->dec_position - stream->dec_cpylen),
stream->dec_position - stream->dec_cpylen,
inst->size);
}
else
{
static int cnt;
XD3_ASSERT (inst->type == XD3_RUN);
XPR(NT "DECODE:%d: RUN at %"Q"u (winoffset %"W"u) size %"W"u\n",
cnt++,
stream->total_out + stream->dec_position - stream->dec_cpylen,
stream->dec_position - stream->dec_cpylen,
inst->size);
}
});
}
/* Check: The instruction will not overflow the output buffer. */ /* Check: The instruction will not overflow the output buffer. */
if (stream->dec_position + inst->size > stream->dec_maxpos) if (stream->dec_position + inst->size > stream->dec_maxpos)
@ -360,6 +416,8 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
return XD3_INVALID_INPUT; return XD3_INVALID_INPUT;
} }
XD3_ASSERT (inst->type != XD3_NOOP);
switch (inst->type) switch (inst->type)
{ {
case XD3_RUN: case XD3_RUN:
@ -449,6 +507,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
int ret; int ret;
xd3_blksize_add (&block, &blkoff, source, inst->addr); xd3_blksize_add (&block, &blkoff, source, inst->addr);
XD3_ASSERT (blkoff < blksize);
if ((ret = xd3_getblk (stream, block))) if ((ret = xd3_getblk (stream, block)))
{ {
@ -468,10 +527,18 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
if ((source->onblk != blksize) && if ((source->onblk != blksize) &&
(blkoff + take > source->onblk)) (blkoff + take > source->onblk))
{ {
IF_DEBUG1 (XPR(NT "[srcfile] short at blkno %"Q"u onblk "
"%"W"u blksize %"W"u blkoff %"W"u take %"W"u\n",
block,
source->onblk,
blksize,
blkoff,
take));
stream->msg = "source file too short"; stream->msg = "source file too short";
return XD3_INVALID_INPUT; return XD3_INVALID_INPUT;
} }
XD3_ASSERT (blkoff != blksize);
/* Check if we have enough data on this block to /* Check if we have enough data on this block to
* finish the instruction. */ * finish the instruction. */
@ -485,6 +552,9 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
take = blksize - blkoff; take = blksize - blkoff;
inst->size -= take; inst->size -= take;
inst->addr += take; inst->addr += take;
/* because (blkoff + take > blksize), above */
XD3_ASSERT (inst->size != 0);
} }
} }
} }
@ -592,6 +662,9 @@ xd3_decode_sections (xd3_stream *stream)
} }
need += stream->data_sect.size; need += stream->data_sect.size;
/* The window may be entirely processed. */
XD3_ASSERT (stream->dec_winbytes <= need);
/* Compute how much more input is needed. */ /* Compute how much more input is needed. */
more = (need - stream->dec_winbytes); more = (need - stream->dec_winbytes);
@ -636,6 +709,8 @@ xd3_decode_sections (xd3_stream *stream)
DEC_EMIT, copy))) { return ret; } DEC_EMIT, copy))) { return ret; }
} }
XD3_ASSERT (stream->dec_winbytes == need);
if ((ret = xd3_decode_secondary_sections (stream))) { return ret; } if ((ret = xd3_decode_secondary_sections (stream))) { return ret; }
if (stream->flags & XD3_SKIP_EMIT) if (stream->flags & XD3_SKIP_EMIT)
@ -656,6 +731,19 @@ xd3_decode_emit (xd3_stream *stream)
{ {
int ret; int ret;
/* Produce output: originally structured to allow reentrant code
* that fills as much of the output buffer as possible, but VCDIFF
* semantics allows to copy from anywhere from the target window, so
* instead allocate a sufficiently sized buffer after the target
* window length is decoded.
*
* This code still needs to be reentrant to allow XD3_GETSRCBLK to
* return control. This is handled by setting the
* stream->dec_currentN instruction types to XD3_NOOP after they
* have been processed. */
XD3_ASSERT (! (stream->flags & XD3_SKIP_EMIT));
XD3_ASSERT (stream->dec_tgtlen <= stream->space_out);
while (stream->inst_sect.buf != stream->inst_sect.buf_max || while (stream->inst_sect.buf != stream->inst_sect.buf_max ||
stream->dec_current1.type != XD3_NOOP || stream->dec_current1.type != XD3_NOOP ||
stream->dec_current2.type != XD3_NOOP) stream->dec_current2.type != XD3_NOOP)
@ -685,6 +773,8 @@ xd3_decode_emit (xd3_stream *stream)
if (stream->avail_out != stream->dec_tgtlen) if (stream->avail_out != stream->dec_tgtlen)
{ {
IF_DEBUG2 (DP(RINT "AVAIL_OUT(%"W"u) != DEC_TGTLEN(%"W"u)\n",
stream->avail_out, stream->dec_tgtlen));
stream->msg = "wrong window length"; stream->msg = "wrong window length";
return XD3_INVALID_INPUT; return XD3_INVALID_INPUT;
} }
@ -919,6 +1009,9 @@ xd3_decode_input (xd3_stream *stream)
if ((ret = xd3_decode_init_window (stream))) { return ret; } if ((ret = xd3_decode_init_window (stream))) { return ret; }
stream->dec_state = DEC_CPYLEN; stream->dec_state = DEC_CPYLEN;
IF_DEBUG2 (DP(RINT "--------- TARGET WINDOW %"Q"u -----------\n",
stream->current_window));
} }
case DEC_CPYLEN: case DEC_CPYLEN:
@ -1072,6 +1165,16 @@ xd3_decode_input (xd3_stream *stream)
xd3_blksize_div(stream->dec_cpyoff, src, xd3_blksize_div(stream->dec_cpyoff, src,
&src->cpyoff_blocks, &src->cpyoff_blocks,
&src->cpyoff_blkoff); &src->cpyoff_blkoff);
IF_DEBUG2(DP(RINT
"[decode_cpyoff] %"Q"u "
"cpyblkno %"Q"u "
"cpyblkoff %"W"u "
"blksize %"W"u\n",
stream->dec_cpyoff,
src->cpyoff_blocks,
src->cpyoff_blkoff,
src->blksize));
} }
/* xd3_decode_emit returns XD3_OUTPUT on every success. */ /* xd3_decode_emit returns XD3_OUTPUT on every success. */
@ -1116,4 +1219,4 @@ xd3_decode_input (xd3_stream *stream)
} }
} }
#endif /* _XDELTA3_DECODE_H_*/ #endif /* _XDELTA3_DECODE_H_*/

145
deps/xdelta3/xdelta3-djw.h vendored
View File

@ -305,6 +305,21 @@ heap_extract (usize_t *heap, const djw_heapen *ents, usize_t heap_last)
return (djw_heapen*) & ents[smallest]; return (djw_heapen*) & ents[smallest];
} }
#if XD3_DEBUG
static void
heap_check (usize_t *heap, djw_heapen *ents, usize_t heap_last)
{
usize_t i;
for (i = 1; i <= heap_last; i += 1)
{
/* Heap property: child not less than parent */
XD3_ASSERT (! heap_less (& ents[heap[i]], & ents[heap[i/2]]));
IF_DEBUG2 (DP(RINT "heap[%"W"u] = %u\n", i, ents[heap[i]].freq));
}
}
#endif
/*********************************************************************/ /*********************************************************************/
/* MTF, 1/2 */ /* MTF, 1/2 */
/*********************************************************************/ /*********************************************************************/
@ -380,9 +395,15 @@ djw_build_prefix (const djw_weight *freq, uint8_t *clen, usize_t asize, usize_t
usize_t total_bits; usize_t total_bits;
usize_t i; usize_t i;
IF_DEBUG (usize_t first_bits = 0);
/* Insert real symbol frequences. */ /* Insert real symbol frequences. */
for (i = 0; i < asize; i += 1) for (i = 0; i < asize; i += 1)
{
ents[i+1].freq = freq[i]; ents[i+1].freq = freq[i];
IF_DEBUG2 (DP(RINT "ents[%"W"i] = freq[%"W"u] = %d\n",
i+1, i, freq[i]));
}
again: again:
@ -410,6 +431,11 @@ djw_build_prefix (const djw_weight *freq, uint8_t *clen, usize_t asize, usize_t
} }
} }
IF_DEBUG (heap_check (heap, ents, heap_last));
/* Must be at least one symbol, or else we can't get here. */
XD3_ASSERT (heap_last != 0);
/* If there is only one symbol, fake a second to prevent zero-length /* If there is only one symbol, fake a second to prevent zero-length
* codes. */ * codes. */
if (heap_last == 1) if (heap_last == 1)
@ -435,6 +461,8 @@ djw_build_prefix (const djw_weight *freq, uint8_t *clen, usize_t asize, usize_t
heap_insert (heap, ents, ++heap_last, ents_size++); heap_insert (heap, ents, ++heap_last, ents_size++);
} }
IF_DEBUG (heap_check (heap, ents, heap_last));
/* Now compute prefix code lengths, counting parents. */ /* Now compute prefix code lengths, counting parents. */
for (i = 1; i < asize+1; i += 1) for (i = 1; i < asize+1; i += 1)
{ {
@ -452,11 +480,21 @@ djw_build_prefix (const djw_weight *freq, uint8_t *clen, usize_t asize, usize_t
} }
/* clen is 0-origin, unlike ents. */ /* clen is 0-origin, unlike ents. */
IF_DEBUG2 (DP(RINT "clen[%"W"u] = %"W"u\n", i-1, b));
clen[i-1] = b; clen[i-1] = b;
} }
IF_DEBUG (if (first_bits == 0) first_bits = total_bits);
if (! overflow) if (! overflow)
{
IF_DEBUG2 (if (first_bits != total_bits)
{
DP(RINT "code length overflow changed %"W"u bits\n",
total_bits - first_bits);
});
return total_bits; return total_bits;
}
/* OPT: There is a non-looping way to fix overflow shown in zlib, but this /* OPT: There is a non-looping way to fix overflow shown in zlib, but this
* is easier (for now), as done in bzip2. */ * is easier (for now), as done in bzip2. */
@ -487,6 +525,8 @@ djw_build_codes (usize_t *codes, const uint8_t *clen, usize_t asize, usize_t abs
max_clen = xd3_max (max_clen, (usize_t) clen[i]); max_clen = xd3_max (max_clen, (usize_t) clen[i]);
} }
XD3_ASSERT (max_clen <= abs_max);
/* Generate a code for each symbol with the appropriate length. */ /* Generate a code for each symbol with the appropriate length. */
for (l = min_clen; l <= max_clen; l += 1) for (l = min_clen; l <= max_clen; l += 1)
{ {
@ -500,6 +540,13 @@ djw_build_codes (usize_t *codes, const uint8_t *clen, usize_t asize, usize_t abs
code <<= 1; code <<= 1;
} }
IF_DEBUG2 ({
for (i = 0; i < asize; i += 1)
{
DP(RINT "code[%"W"u] = %"W"u\n", i, codes[i]);
}
});
} }
/*********************************************************************/ /*********************************************************************/
@ -528,6 +575,8 @@ djw_compute_mtf_1_2 (djw_prefix *prefix,
for (j = 0; mtf[j] != sym; j += 1) { } for (j = 0; mtf[j] != sym; j += 1) { }
XD3_ASSERT (j <= nsym);
for (k = j; k >= 1; k -= 1) { mtf[k] = mtf[k-1]; } for (k = j; k >= 1; k -= 1) { mtf[k] = mtf[k-1]; }
mtf[0] = sym; mtf[0] = sym;
@ -579,6 +628,14 @@ djw_count_freqs (djw_weight *freq, xd3_output *input)
while (++p < p_max); while (++p < p_max);
} }
IF_DEBUG2 ({int i;
DP(RINT "freqs: ");
for (i = 0; i < ALPHABET_SIZE; i += 1)
{
DP(RINT "%u ", freq[i]);
}
DP(RINT "\n");});
return size; return size;
} }
@ -643,6 +700,7 @@ djw_encode_prefix (xd3_stream *stream,
{ {
num_to_encode -= 1; num_to_encode -= 1;
} }
XD3_ASSERT (num_to_encode - DJW_EXTRA_12OFFSET < (1 << DJW_EXTRA_CODE_BITS));
/* Encode: # of extra codes */ /* Encode: # of extra codes */
if ((ret = xd3_encode_bits (stream, output, bstate, DJW_EXTRA_CODE_BITS, if ((ret = xd3_encode_bits (stream, output, bstate, DJW_EXTRA_CODE_BITS,
@ -789,6 +847,11 @@ xd3_encode_howmany_groups (xd3_stream *stream,
(*ret_groups) = cfg_groups; (*ret_groups) = cfg_groups;
(*ret_sector_size) = cfg_sector_size; (*ret_sector_size) = cfg_sector_size;
XD3_ASSERT (cfg_groups > 0 && cfg_groups <= DJW_MAX_GROUPS);
XD3_ASSERT (cfg_groups == 1 ||
(cfg_sector_size >= DJW_SECTORSZ_MULT &&
cfg_sector_size <= DJW_SECTORSZ_MAX));
return 0; return 0;
} }
@ -814,6 +877,8 @@ xd3_encode_huff (xd3_stream *stream,
input_bytes = djw_count_freqs (real_freq, input); input_bytes = djw_count_freqs (real_freq, input);
input_bits = input_bytes * 8; input_bits = input_bytes * 8;
XD3_ASSERT (input_bytes > 0);
if ((ret = xd3_encode_howmany_groups (stream, cfg, input_bytes, if ((ret = xd3_encode_howmany_groups (stream, cfg, input_bytes,
& groups, & sector_size))) & groups, & sector_size)))
{ {
@ -877,12 +942,18 @@ xd3_encode_huff (xd3_stream *stream,
usize_t sym = *p++; usize_t sym = *p++;
usize_t bits = clen[sym]; usize_t bits = clen[sym];
IF_DEBUG (output_bits -= bits);
if ((ret = xd3_encode_bits (stream, & output, if ((ret = xd3_encode_bits (stream, & output,
& bstate, bits, code[sym]))) & bstate, bits, code[sym])))
{
goto failure; goto failure;
}
} }
while (p < p_max); while (p < p_max);
} }
XD3_ASSERT (output_bits == 0);
} }
else else
{ {
@ -902,6 +973,7 @@ xd3_encode_huff (xd3_stream *stream,
usize_t gbest_no; usize_t gbest_no;
usize_t gpcnt; usize_t gpcnt;
const uint8_t *p; const uint8_t *p;
IF_DEBUG2 (usize_t gcount[DJW_MAX_GROUPS]);
/* Encode: sector size (5 bits) */ /* Encode: sector size (5 bits) */
if ((ret = xd3_encode_bits (stream, & output, & bstate, if ((ret = xd3_encode_bits (stream, & output, & bstate,
@ -938,19 +1010,32 @@ xd3_encode_huff (xd3_stream *stream,
djw_weight sum = 0; djw_weight sum = 0;
djw_weight goal = left / (groups - gp); djw_weight goal = left / (groups - gp);
IF_DEBUG2 (usize_t nz = 0);
/* Due to the single-code granularity of this distribution, it may /* Due to the single-code granularity of this distribution, it may
* be that we can't generate a distribution for each group. In that * be that we can't generate a distribution for each group. In that
* case subtract one group and try again. If (inefficient), we're * case subtract one group and try again. If (inefficient), we're
* testing group behavior, so don't mess things up. */ * testing group behavior, so don't mess things up. */
if (goal == 0 && !cfg->inefficient) if (goal == 0 && !cfg->inefficient)
{ {
IF_DEBUG2 (DP(RINT "too many groups (%"W"u), dropping one\n",
groups));
groups -= 1; groups -= 1;
goto regroup; goto regroup;
} }
/* Sum == goal is possible when (cfg->inefficient)... */ /* Sum == goal is possible when (cfg->inefficient)... */
while (sum < goal) while (sum < goal)
{
XD3_ASSERT (sym2 < ALPHABET_SIZE);
IF_DEBUG2 (nz += real_freq[sym2] != 0);
sum += real_freq[sym2++]; sum += real_freq[sym2++];
}
IF_DEBUG2(DP(RINT "group %"W"u has symbols %"W"u..%"W"u (%"W"u non-zero) "
"(%u/%"W"u = %.3f)\n",
gp, sym1, sym2, nz, sum,
input_bytes, sum / (double)input_bytes););
for (s = 0; s < ALPHABET_SIZE; s += 1) for (s = 0; s < ALPHABET_SIZE; s += 1)
{ {
@ -966,6 +1051,7 @@ xd3_encode_huff (xd3_stream *stream,
niter += 1; niter += 1;
gbest_no = 0; gbest_no = 0;
memset (evolve_freq, 0, sizeof (evolve_freq[0]) * groups); memset (evolve_freq, 0, sizeof (evolve_freq[0]) * groups);
IF_DEBUG2 (memset (gcount, 0, sizeof (gcount[0]) * groups));
/* For each input page (loop is irregular to allow non-pow2-size group /* For each input page (loop is irregular to allow non-pow2-size group
* size. */ * size. */
@ -1015,7 +1101,9 @@ xd3_encode_huff (xd3_stream *stream,
} }
} }
XD3_ASSERT(gbest_no < gbest_max);
gbest[gbest_no++] = winner; gbest[gbest_no++] = winner;
IF_DEBUG2 (gcount[winner] += 1);
p = p0; p = p0;
in = in0; in = in0;
@ -1030,6 +1118,8 @@ xd3_encode_huff (xd3_stream *stream,
} }
while (in != NULL); while (in != NULL);
XD3_ASSERT (gbest_no == gbest_max);
/* Recompute code lengths. */ /* Recompute code lengths. */
output_bits = 0; output_bits = 0;
for (gp = 0; gp < groups; gp += 1) for (gp = 0; gp < groups; gp += 1)
@ -1065,14 +1155,29 @@ xd3_encode_huff (xd3_stream *stream,
* for the (output_bits==0) assert after all bits are output. */ * for the (output_bits==0) assert after all bits are output. */
if (any_zeros) if (any_zeros)
{ {
IF_DEBUG2 (usize_t save_total = output_bits);
for (i = 0; i < ALPHABET_SIZE; i += 1) for (i = 0; i < ALPHABET_SIZE; i += 1)
{ {
if (evolve_zero[i]) { output_bits -= evolve_clen[gp][i]; } if (evolve_zero[i]) { output_bits -= evolve_clen[gp][i]; }
} }
IF_DEBUG2 (DP(RINT "evolve_zero reduced %"W"u bits in group %"W"u\n",
save_total - output_bits, gp));
} }
} }
IF_DEBUG2(
DP(RINT "pass %"W"u total bits: %"W"u group uses: ", niter, output_bits);
for (gp = 0; gp < groups; gp += 1) { DP(RINT "%"W"u ", gcount[gp]); }
DP(RINT "\n");
);
/* End iteration. */ /* End iteration. */
IF_DEBUG2 (if (niter > 1 && best_bits < output_bits) {
DP(RINT "iteration lost %"W"u bits\n", output_bits - best_bits); });
if (niter == 1 || (niter < DJW_MAX_ITER && if (niter == 1 || (niter < DJW_MAX_ITER &&
(best_bits - output_bits) >= DJW_MIN_IMPROVEMENT)) (best_bits - output_bits) >= DJW_MIN_IMPROVEMENT))
{ {
@ -1086,6 +1191,9 @@ xd3_encode_huff (xd3_stream *stream,
goto nosecond; goto nosecond;
} }
IF_DEBUG2 (DP(RINT "djw compression: %"W"u -> %0.3f\n",
input_bytes, output_bits / 8.0));
/* Encode: prefix */ /* Encode: prefix */
{ {
uint8_t prefix_symbol[DJW_MAX_GROUPS * ALPHABET_SIZE]; uint8_t prefix_symbol[DJW_MAX_GROUPS * ALPHABET_SIZE];
@ -1136,10 +1244,18 @@ xd3_encode_huff (xd3_stream *stream,
usize_t gp_sel_bits = gbest_clen[gp_mtf]; usize_t gp_sel_bits = gbest_clen[gp_mtf];
usize_t gp_sel_code = gbest_code[gp_mtf]; usize_t gp_sel_code = gbest_code[gp_mtf];
XD3_ASSERT (gp_mtf < groups+1);
if ((ret = xd3_encode_bits (stream, & output, & bstate, if ((ret = xd3_encode_bits (stream, & output, & bstate,
gp_sel_bits, gp_sel_code))) gp_sel_bits, gp_sel_code)))
{
goto failure; goto failure;
}
IF_DEBUG (select_bits -= gp_sel_bits);
} }
XD3_ASSERT (select_bits == 0);
} }
/* Efficiency check. */ /* Efficiency check. */
@ -1172,6 +1288,8 @@ xd3_encode_huff (xd3_stream *stream,
usize_t *gp_codes = evolve_code[gp_best]; usize_t *gp_codes = evolve_code[gp_best];
uint8_t *gp_clens = evolve_clen[gp_best]; uint8_t *gp_clens = evolve_clen[gp_best];
XD3_ASSERT (sector < gbest_no);
sector += 1; sector += 1;
/* Encode the sector data. */ /* Encode the sector data. */
@ -1181,14 +1299,21 @@ xd3_encode_huff (xd3_stream *stream,
usize_t bits = gp_clens[sym]; usize_t bits = gp_clens[sym];
usize_t code = gp_codes[sym]; usize_t code = gp_codes[sym];
IF_DEBUG (output_bits -= bits);
if ((ret = xd3_encode_bits (stream, & output, & bstate, if ((ret = xd3_encode_bits (stream, & output, & bstate,
bits, code))) bits, code)))
{
goto failure; goto failure;
}
GP_PAGE (); GP_PAGE ();
} }
} }
while (in != NULL); while (in != NULL);
XD3_ASSERT (select_bits == 0);
XD3_ASSERT (output_bits == 0);
} }
} }
@ -1231,6 +1356,9 @@ djw_build_decoder (xd3_stream *stream,
usize_t min_clen; usize_t min_clen;
usize_t max_clen; usize_t max_clen;
/* Assumption: the two temporary arrays are large enough to hold abs_max. */
XD3_ASSERT (abs_max <= DJW_MAX_CODELEN);
/* This looks something like the start of zlib's inftrees.c */ /* This looks something like the start of zlib's inftrees.c */
memset (nr_clen, 0, sizeof (nr_clen[0]) * (abs_max+1)); memset (nr_clen, 0, sizeof (nr_clen[0]) * (abs_max+1));
@ -1239,6 +1367,13 @@ djw_build_decoder (xd3_stream *stream,
ci = clen; ci = clen;
do do
{ {
/* Caller _must_ check that values are in-range. Most of the time the
* caller decodes a specific number of bits, which imply the max value,
* and the other time the caller decodes a huffman value, which must be
* in-range. Therefore, its an assertion and this function cannot
* otherwise fail. */
XD3_ASSERT (*ci <= abs_max);
nr_clen[*ci++]++; nr_clen[*ci++]++;
} }
while (--i != 0); while (--i != 0);
@ -1333,6 +1468,7 @@ djw_decode_symbol (xd3_stream *stream,
if (offset <= max_sym) if (offset <= max_sym)
{ {
IF_DEBUG2 (DP(RINT "(j) %"W"u ", code));
*sym = inorder[offset]; *sym = inorder[offset];
return 0; return 0;
} }
@ -1384,6 +1520,9 @@ djw_decode_clclen (xd3_stream *stream,
/* Set the rest to zero. */ /* Set the rest to zero. */
for (; i < DJW_TOTAL_CODES; i += 1) { cl_clen[i] = 0; } for (; i < DJW_TOTAL_CODES; i += 1) { cl_clen[i] = 0; }
/* No need to check for in-range clen values, because: */
XD3_ASSERT (1 << DJW_CLCLEN_BITS == DJW_MAX_CLCLEN + 1);
/* Build the code-length decoder. */ /* Build the code-length decoder. */
djw_build_decoder (stream, DJW_TOTAL_CODES, DJW_MAX_CLCLEN, djw_build_decoder (stream, DJW_TOTAL_CODES, DJW_MAX_CLCLEN,
cl_clen, cl_inorder, cl_base, cl_clen, cl_inorder, cl_base,
@ -1645,6 +1784,8 @@ xd3_decode_huff (xd3_stream *stream,
{ {
gp = sel_group[c]; gp = sel_group[c];
XD3_ASSERT (gp < groups);
gp_inorder = inorder[gp]; gp_inorder = inorder[gp];
gp_base = base[gp]; gp_base = base[gp];
gp_limit = limit[gp]; gp_limit = limit[gp];
@ -1682,6 +1823,10 @@ xd3_decode_huff (xd3_stream *stream,
} }
} }
IF_REGRESSION (if ((ret = xd3_test_clean_bits (stream, & bstate)))
{ goto fail; });
XD3_ASSERT (ret == 0);
fail: fail:
xd3_free (stream, sel_group); xd3_free (stream, sel_group);

22
deps/xdelta3/xdelta3-fgk.h vendored
View File

@ -204,8 +204,12 @@ static int fgk_init (xd3_stream *stream, fgk_stream *h, int is_encode)
fgk_factor_remaining(h); /* set ZFE and ZFR */ fgk_factor_remaining(h); /* set ZFE and ZFR */
fgk_factor_remaining(h); /* set ZFDB according to prev state */ fgk_factor_remaining(h); /* set ZFDB according to prev state */
IF_DEBUG (memset (h->alphabet, 0, sizeof (h->alphabet[0]) * h->total_nodes));
for (ui = 0; ui < h->total_blocks-1; ui += 1) for (ui = 0; ui < h->total_blocks-1; ui += 1)
{
h->block_array[ui].block_freeptr = &h->block_array[ui + 1]; h->block_array[ui].block_freeptr = &h->block_array[ui + 1];
}
h->block_array[h->total_blocks - 1].block_freeptr = NULL; h->block_array[h->total_blocks - 1].block_freeptr = NULL;
h->free_block = h->block_array; h->free_block = h->block_array;
@ -234,6 +238,8 @@ static usize_t fgk_encode_data (fgk_stream* h, usize_t n)
{ {
fgk_node *target_ptr = h->alphabet + n; fgk_node *target_ptr = h->alphabet + n;
XD3_ASSERT (n < h->alphabet_size);
h->coded_depth = 0; h->coded_depth = 0;
/* First encode the binary representation of the nth remaining /* First encode the binary representation of the nth remaining
@ -290,6 +296,8 @@ static usize_t fgk_encode_data (fgk_stream* h, usize_t n)
*/ */
static INLINE fgk_bit fgk_get_encoded_bit (fgk_stream *h) static INLINE fgk_bit fgk_get_encoded_bit (fgk_stream *h)
{ {
XD3_ASSERT (h->coded_depth > 0);
return h->coded_bits[--h->coded_depth]; return h->coded_bits[--h->coded_depth];
} }
@ -412,6 +420,9 @@ static void fgk_promote (fgk_stream *h, fgk_node *node)
node->left_child && node->left_child &&
node->left_child->weight == 0) node->left_child->weight == 0)
{ {
XD3_ASSERT (node->left_child == h->remaining_zeros);
XD3_ASSERT (node->right_child->weight == (node->weight+1)); /* child weight was already incremented */
if (node->weight == (my_right->weight - 1) && my_right != h->root_node) if (node->weight == (my_right->weight - 1) && my_right != h->root_node)
{ {
fgk_free_block (h, cur_block); fgk_free_block (h, cur_block);
@ -613,6 +624,8 @@ static fgk_block* fgk_make_block (fgk_stream *h, fgk_node* lead)
{ {
fgk_block *ret = h->free_block; fgk_block *ret = h->free_block;
XD3_ASSERT (h->free_block != NULL);
h->free_block = h->free_block->block_freeptr; h->free_block = h->free_block->block_freeptr;
ret->block_leader = lead; ret->block_leader = lead;
@ -652,6 +665,8 @@ static void fgk_factor_remaining (fgk_stream *h)
*/ */
static INLINE int fgk_decode_bit (fgk_stream* h, fgk_bit b) static INLINE int fgk_decode_bit (fgk_stream* h, fgk_bit b)
{ {
XD3_ASSERT (b == 1 || b == 0);
if (IS_ADAPTIVE && h->decode_ptr->weight == 0) if (IS_ADAPTIVE && h->decode_ptr->weight == 0)
{ {
usize_t bitsreq; usize_t bitsreq;
@ -827,6 +842,13 @@ xd3_decode_fgk (xd3_stream *stream,
if (output == output_max) if (output == output_max)
{ {
/* During regression testing: */
IF_REGRESSION ({
int ret;
bstate.cur_mask <<= 1;
if ((ret = xd3_test_clean_bits (stream, & bstate))) { return ret; }
});
(*output_pos) = output; (*output_pos) = output;
(*input_pos) = input; (*input_pos) = input;
return 0; return 0;

13
deps/xdelta3/xdelta3-hash.h vendored
View File

@ -20,6 +20,19 @@
#include "retro_inline.h" #include "retro_inline.h"
#include "xdelta3-internal.h" #include "xdelta3-internal.h"
#if XD3_DEBUG
#define SMALL_HASH_DEBUG1(s,inp) \
uint32_t debug_state; \
uint32_t debug_hval = xd3_checksum_hash (& (s)->small_hash, \
xd3_scksum (&debug_state, (inp), (s)->smatcher.small_look))
#define SMALL_HASH_DEBUG2(s,inp) \
XD3_ASSERT (debug_hval == xd3_checksum_hash (& (s)->small_hash, \
xd3_scksum (&debug_state, (inp), (s)->smatcher.small_look)))
#else
#define SMALL_HASH_DEBUG1(s,inp)
#define SMALL_HASH_DEBUG2(s,inp)
#endif /* XD3_DEBUG */
#if UNALIGNED_OK #if UNALIGNED_OK
#define UNALIGNED_READ32(dest,src) (*(dest)) = (*(uint32_t*)(src)) #define UNALIGNED_READ32(dest,src) (*(dest)) = (*(uint32_t*)(src))
#else #else

87
deps/xdelta3/xdelta3-internal.h vendored
View File

@ -20,6 +20,31 @@
#include "retro_inline.h" #include "retro_inline.h"
#include "xdelta3.h" #include "xdelta3.h"
typedef struct _main_file main_file;
typedef struct _main_extcomp main_extcomp;
void main_buffree (void *ptr);
void* main_bufalloc (size_t size);
void main_file_init (main_file *xfile);
int main_file_close (main_file *xfile);
void main_file_cleanup (main_file *xfile);
int main_file_isopen (main_file *xfile);
int main_file_open (main_file *xfile, const char* name, int mode);
int main_file_exists (main_file *xfile);
int main_file_stat (main_file *xfile, xoff_t *size);
int xd3_whole_append_window (xd3_stream *stream);
int xd3_main_cmdline (int argc, char **argv);
int main_file_read (main_file *ifile,
uint8_t *buf,
size_t size,
size_t *nread,
const char *msg);
int main_file_write (main_file *ofile, uint8_t *buf,
usize_t size, const char *msg);
void* main_malloc (size_t size);
void main_free (void *ptr);
int test_compare_files (const char* f0, const char* f1);
usize_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno); usize_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno);
xoff_t xd3_source_eof(const xd3_source *src); xoff_t xd3_source_eof(const xd3_source *src);
@ -39,6 +64,7 @@ xd3_output* xd3_alloc_output (xd3_stream *stream,
int xd3_encode_init_full (xd3_stream *stream); int xd3_encode_init_full (xd3_stream *stream);
usize_t xd3_pow2_roundup (usize_t x); usize_t xd3_pow2_roundup (usize_t x);
long get_millisecs_now (void);
int xd3_process_stream (int is_encode, int xd3_process_stream (int is_encode,
xd3_stream *stream, xd3_stream *stream,
int (*func) (xd3_stream *), int (*func) (xd3_stream *),
@ -49,6 +75,67 @@ int xd3_process_stream (int is_encode,
usize_t *output_size, usize_t *output_size,
usize_t output_size_max); usize_t output_size_max);
#if PYTHON_MODULE || SWIG_MODULE || NOT_MAIN
int xd3_main_cmdline (int argc, char **argv);
#endif
#if REGRESSION_TEST
int xd3_selftest (void);
#endif
/* main_file->mode values */
typedef enum
{
XO_READ = 0,
XO_WRITE = 1
} main_file_modes;
#ifndef XD3_POSIX
#define XD3_POSIX 0
#endif
#ifndef XD3_STDIO
#define XD3_STDIO 0
#endif
#ifndef XD3_WIN32
#define XD3_WIN32 0
#endif
#ifndef NOT_MAIN
#define NOT_MAIN 0
#endif
/* If none are set, default to posix. */
#if (XD3_POSIX + XD3_STDIO + XD3_WIN32) == 0
#undef XD3_POSIX
#define XD3_POSIX 1
#endif
struct _main_file
{
#if XD3_WIN32
HANDLE file;
#elif XD3_STDIO
FILE *file;
#elif XD3_POSIX
int file;
#endif
int mode; /* XO_READ and XO_WRITE */
const char *filename; /* File name or /dev/stdin,
* /dev/stdout, /dev/stderr. */
char *filename_copy; /* File name or /dev/stdin,
* /dev/stdout, /dev/stderr. */
const char *realname; /* File name or /dev/stdin,
* /dev/stdout, /dev/stderr. */
const main_extcomp *compressor; /* External compression struct. */
int flags; /* RD_FIRST, RD_NONEXTERNAL, ... */
xoff_t nread; /* for input position */
xoff_t nwrite; /* for output position */
uint8_t *snprintf_buf; /* internal snprintf() use */
int size_known; /* Set by main_set_souze */
xoff_t source_position; /* for avoiding seek in getblk_func */
int seek_failed; /* after seek fails once, try FIFO */
};
#ifndef UINT32_MAX #ifndef UINT32_MAX
#define UINT32_MAX 4294967295U #define UINT32_MAX 4294967295U
#endif #endif

40
deps/xdelta3/xdelta3-second.h vendored
View File

@ -65,10 +65,32 @@ static INLINE int xd3_decode_bits (xd3_stream *stream,
done: done:
IF_DEBUG2 (DP(RINT "(d) %"W"u ", value));
(*valuep) = value; (*valuep) = value;
return 0; return 0;
} }
#if REGRESSION_TEST
/* There may be extra bits at the end of secondary decompression, this macro
* checks for non-zero bits. This is overly strict, but helps pass the
* single-bit-error regression test. */
static int
xd3_test_clean_bits (xd3_stream *stream, bit_state *bits)
{
for (; bits->cur_mask != 0x100; bits->cur_mask <<= 1)
{
if (bits->cur_byte & bits->cur_mask)
{
stream->msg = "secondary decoder garbage";
return XD3_INTERNAL;
}
}
return 0;
}
#endif
static int static int
xd3_get_secondary (xd3_stream *stream, xd3_sec_stream **sec_streamp, xd3_get_secondary (xd3_stream *stream, xd3_sec_stream **sec_streamp,
int is_encode) int is_encode)
@ -198,15 +220,23 @@ static INLINE int xd3_encode_bits (xd3_stream *stream,
int ret; int ret;
usize_t mask = 1 << nbits; usize_t mask = 1 << nbits;
XD3_ASSERT (nbits > 0);
XD3_ASSERT (nbits < sizeof (usize_t) * 8);
XD3_ASSERT (value < mask);
do do
{ {
mask >>= 1; mask >>= 1;
if ((ret = xd3_encode_bit (stream, output, bits, value & mask))) if ((ret = xd3_encode_bit (stream, output, bits, value & mask)))
{
return ret; return ret;
}
} }
while (mask != 1); while (mask != 1);
IF_DEBUG2 (DP(RINT "(e) %"W"u ", value));
return 0; return 0;
} }
@ -260,8 +290,18 @@ xd3_encode_secondary (xd3_stream *stream,
comp_size += tmp_tail->next; comp_size += tmp_tail->next;
} }
XD3_ASSERT (comp_size == xd3_sizeof_output (tmp_head));
XD3_ASSERT (tmp_tail != NULL);
if (comp_size < (orig_size - SECONDARY_MIN_SAVINGS) || cfg->inefficient) if (comp_size < (orig_size - SECONDARY_MIN_SAVINGS) || cfg->inefficient)
{ {
if (comp_size < orig_size)
{
IF_DEBUG1(DP(RINT "[encode_secondary] saved %"W"u bytes: %"W"u -> %"W"u (%0.2f%%)\n",
orig_size - comp_size, orig_size, comp_size,
100.0 * (double) comp_size / (double) orig_size));
}
xd3_free_output (stream, *head); xd3_free_output (stream, *head);
*head = tmp_head; *head = tmp_head;

500
deps/xdelta3/xdelta3.c vendored
View File

File diff suppressed because it is too large Load Diff

184
deps/xdelta3/xdelta3.h vendored
View File

@ -22,11 +22,21 @@
#ifndef _XDELTA3_H_ #ifndef _XDELTA3_H_
#define _XDELTA3_H_ #define _XDELTA3_H_
#define _POSIX_SOURCE 200112L
#define _ISOC99_SOURCE
#define _C99_SOURCE
/* To include RetroArch's INLINE macro */ /* To include RetroArch's INLINE macro */
#include <retro_inline.h> #include "retro_inline.h"
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include <assert.h>
#include <errno.h>
#include <stdarg.h> #include <stdarg.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
@ -106,9 +116,46 @@
#ifndef _WIN32 #ifndef _WIN32
#define __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS
#include <inttypes.h> #include <inttypes.h>
#endif /* _WIN32 defined */
#include <stdint.h> #include <stdint.h>
#else /* WIN32 case */
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef WINVER
#if XD3_USE_LARGEFILE64
/* 64 bit file offsets: uses GetFileSizeEx and SetFilePointerEx. */
#define WINVER 0x0500
#define _WIN32_WINNT 0x0500
#else /* xoff_t is 32bit */
/* 32 bit file offsets: uses GetFileSize and SetFilePointer. */
#define WINVER 0x0400
#define _WIN32_WINNT 0x0400
#endif /* if XD3_USE_LARGEFILE64 */
#endif /* ifndef WINVER */
#include <windows.h>
/* _MSV_VER is defined by Microsoft tools, not by Mingw32 */
#ifdef _MSC_VER
typedef signed int ssize_t;
typedef int pid_t;
#if _MSC_VER < 1600
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned long uint32_t;
typedef ULONGLONG uint64_t;
#else /* _MSC_VER >= 1600 */
/* For MSVC10 and above */
#include <stdint.h>
#define inline __inline
#endif /* _MSC_VER < 1600 */
#else /* _MSC_VER not defined */
/* Mingw32 */
#include <stdint.h>
#endif /* _MSC_VER defined */
#endif /* _WIN32 defined */
#if SIZE_MAX == UINT64_MAX #if SIZE_MAX == UINT64_MAX
#define SIZEOF_SIZE_T 8 #define SIZEOF_SIZE_T 8
@ -149,6 +196,12 @@
#define _FILE_OFFSET_BITS 64 #define _FILE_OFFSET_BITS 64
#endif #endif
_Static_assert(SIZEOF_SIZE_T == sizeof(size_t), "SIZEOF_SIZE_T not correctly set");
#ifdef SIZEOF_UNSIGNED_LONG_LONG
_Static_assert(SIZEOF_UNSIGNED_LONG_LONG == sizeof(unsigned long long), "SIZEOF_UNSIGNED_LONG_LONG not correctly set");
#endif
/* Set a xoff_t typedef and the "Q" printf insert. */ /* Set a xoff_t typedef and the "Q" printf insert. */
#if defined(_WIN32) #if defined(_WIN32)
typedef uint64_t xoff_t; typedef uint64_t xoff_t;
@ -229,8 +282,10 @@ typedef uint32_t usize_t;
#error Bad configure script #error Bad configure script
#endif /* size_t printf flags */ #endif /* size_t printf flags */
#define USE_UINT32 (SIZEOF_USIZE_T == 4 || SIZEOF_XOFF_T == 4 ) #define USE_UINT32 (SIZEOF_USIZE_T == 4 || \
#define USE_UINT64 (SIZEOF_USIZE_T == 8 || SIZEOF_XOFF_T == 8 ) SIZEOF_XOFF_T == 4 || REGRESSION_TEST)
#define USE_UINT64 (SIZEOF_USIZE_T == 8 || \
SIZEOF_XOFF_T == 8 || REGRESSION_TEST)
#ifndef UNALIGNED_OK #ifndef UNALIGNED_OK
#ifdef HAVE_ALIGNED_ACCESS_REQUIRED #ifdef HAVE_ALIGNED_ACCESS_REQUIRED
@ -248,6 +303,37 @@ typedef uint32_t usize_t;
#define XD3_ENCODER 1 #define XD3_ENCODER 1
#endif #endif
/* The code returned when main() fails, also defined in system
includes. */
#ifndef EXIT_FAILURE
#define EXIT_FAILURE 1
#endif
/* REGRESSION TEST enables the "xdelta3 test" command, which runs a
series of self-tests. */
#ifndef REGRESSION_TEST
#define REGRESSION_TEST 0
#endif
/* XD3_DEBUG=1 enables assertions and various statistics. Levels > 1
* enable some additional output only useful during development and
* debugging. */
#ifndef XD3_DEBUG
#define XD3_DEBUG 0
#endif
#ifndef PYTHON_MODULE
#define PYTHON_MODULE 0
#endif
#ifndef SWIG_MODULE
#define SWIG_MODULE 0
#endif
#ifndef NOT_MAIN
#define NOT_MAIN 0
#endif
/* There are three string matching functions supplied: one fast, one /* There are three string matching functions supplied: one fast, one
* slow (default), and one soft-configurable. To disable any of * slow (default), and one soft-configurable. To disable any of
* these, use the following definitions. */ * these, use the following definitions. */
@ -270,6 +356,10 @@ typedef uint32_t usize_t;
#define XD3_BUILD_DEFAULT 1 #define XD3_BUILD_DEFAULT 1
#endif #endif
#if XD3_DEBUG
#include <stdio.h>
#endif
typedef struct _xd3_stream xd3_stream; typedef struct _xd3_stream xd3_stream;
typedef struct _xd3_source xd3_source; typedef struct _xd3_source xd3_source;
typedef struct _xd3_hash_cfg xd3_hash_cfg; typedef struct _xd3_hash_cfg xd3_hash_cfg;
@ -310,6 +400,52 @@ typedef int (xd3_getblk_func) (xd3_stream *stream,
typedef const xd3_dinst* (xd3_code_table_func) (void); typedef const xd3_dinst* (xd3_code_table_func) (void);
#ifdef _WIN32
#define vsnprintf_func _vsnprintf
#define snprintf_func _snprintf
#else
#define vsnprintf_func vsnprintf
#define snprintf_func snprintf
#endif
/* Type used for short snprintf calls. */
typedef struct {
char buf[48];
} shortbuf;
#ifndef PRINTF_ATTRIBUTE
#ifdef __GNUC__
#define PRINTF_ATTRIBUTE(x,y) __attribute__ ((__format__ (__printf__, x, y)))
#else
#define PRINTF_ATTRIBUTE(x,y)
#endif
#endif
/* Underlying xprintf() */
int xsnprintf_func (char *str, size_t n, const char *fmt, ...)
PRINTF_ATTRIBUTE(3,4);
/* XPR(NT "", ...) (used by main) prefixes an "xdelta3: " to the output. */
void xprintf(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
#define XPR xprintf
#define NT "xdelta3: "
#define NTR ""
/* DP(RINT ...) */
#define DP xprintf
#define RINT ""
#if XD3_DEBUG
#define XD3_ASSERT(x) \
do { \
if (! (x)) { \
DP(RINT "%s:%d: XD3 assertion failed: %s\n", \
__FILE__, __LINE__, #x); \
abort (); } } while (0)
#else
#define XD3_ASSERT(x) (void)0
#endif /* XD3_DEBUG */
#define xd3_max(x,y) ((x) < (y) ? (y) : (x)) #define xd3_max(x,y) ((x) < (y) ? (y) : (x))
#define xd3_min(x,y) ((x) < (y) ? (x) : (y)) #define xd3_min(x,y) ((x) < (y) ? (x) : (y))
@ -990,6 +1126,14 @@ struct _xd3_stream
xoff_t l_run; xoff_t l_run;
usize_t i_slots_used; usize_t i_slots_used;
#if XD3_DEBUG
usize_t large_ckcnt;
/* memory usage */
usize_t alloc_cnt;
usize_t free_cnt;
#endif
}; };
/************************************************************************** /**************************************************************************
@ -1244,6 +1388,14 @@ void xd3_avail_input (xd3_stream *stream,
const uint8_t *idata, const uint8_t *idata,
usize_t isize) usize_t isize)
{ {
/* Even if isize is zero, the code expects a non-NULL idata. Why?
* It uses this value to determine whether xd3_avail_input has ever
* been called. If xd3_encode_input is called before
* xd3_avail_input it will return XD3_INPUT right away without
* allocating a stream->winsize buffer. This is to avoid an
* unwanted allocation. */
XD3_ASSERT (idata != NULL || isize == 0);
stream->next_in = idata; stream->next_in = idata;
stream->avail_in = isize; stream->avail_in = isize;
} }
@ -1274,6 +1426,9 @@ usize_t xd3_encoder_srclen (xd3_stream *stream) {
static INLINE static INLINE
void xd3_set_flags (xd3_stream *stream, uint32_t flags) void xd3_set_flags (xd3_stream *stream, uint32_t flags)
{ {
/* The bitwise difference should contain only XD3_FLUSH or
XD3_SKIP_WINDOW */
XD3_ASSERT(((flags ^ stream->flags) & ~(XD3_FLUSH | XD3_SKIP_WINDOW)) == 0);
stream->flags = flags; stream->flags = flags;
} }
@ -1296,6 +1451,7 @@ void xd3_blksize_div (const xoff_t offset,
usize_t *blkoff) { usize_t *blkoff) {
*blkno = offset >> source->shiftby; *blkno = offset >> source->shiftby;
*blkoff = offset & source->maskby; *blkoff = offset & source->maskby;
XD3_ASSERT (*blkoff < source->blksize);
} }
static INLINE static INLINE
@ -1315,6 +1471,8 @@ void xd3_blksize_add (xoff_t *blkno,
*blkno += blkdiff; *blkno += blkdiff;
*blkoff &= source->maskby; *blkoff &= source->maskby;
} }
XD3_ASSERT (*blkoff < source->blksize);
} }
#ifdef __cplusplus #ifdef __cplusplus
@ -1327,6 +1485,22 @@ void xd3_blksize_add (xoff_t *blkno,
#define XD3_CPY 3U /* XD3_CPY rtypes are represented as (XD3_CPY + #define XD3_CPY 3U /* XD3_CPY rtypes are represented as (XD3_CPY +
* copy-mode value) */ * copy-mode value) */
#if XD3_DEBUG
#define IF_DEBUG(x) x
#else
#define IF_DEBUG(x)
#endif
#if XD3_DEBUG > 1
#define IF_DEBUG1(x) x
#else
#define IF_DEBUG1(x)
#endif
#if XD3_DEBUG > 2
#define IF_DEBUG2(x) x
#else
#define IF_DEBUG2(x)
#endif
#define SIZEOF_ARRAY(x) (sizeof(x) / sizeof(x[0])) #define SIZEOF_ARRAY(x) (sizeof(x) / sizeof(x[0]))
#endif /* _XDELTA3_H_ */ #endif /* _XDELTA3_H_ */