267 lines
8.1 KiB
C
267 lines
8.1 KiB
C
#ifndef _XNB_LZ4MG_H_
|
|
#define _XNB_LZ4MG_H_
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
/* Decompresses LZ4 from MonoGame. The original C lib has a lot of modes and configs, but
|
|
* MonoGame only uses the core 'block' part, which is a fairly simple LZ77 (has one command
|
|
* to copy literal and window values, with variable copy lengths).
|
|
*
|
|
* This is a basic re-implementation (not tuned for performance) for practice/test purposes,
|
|
* that handles streaming decompression as a state machine since we can run out of src or dst
|
|
* bytes anytime and LZ4 allows any copy length, with copy window as a circular buffer. Not
|
|
* sure what's the best/standard way to do it though. Info:
|
|
* - https://github.com/lz4/lz4
|
|
* - https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Utilities/Lz4Stream/Lz4DecoderStream.cs
|
|
*/
|
|
|
|
#define LZ4MG_OK 0
|
|
#define LZ4MG_ERROR -1
|
|
#define LZ4MG_WINDOW_SIZE (1 << 16)
|
|
#define LZ4MG_WINDOW_BYTES 2
|
|
#define LZ4MG_MIN_MATCH_LEN 4
|
|
#define LZ4MG_VARLEN_MARK 15
|
|
#define LZ4MG_VARLEN_CONTINUE 255
|
|
|
|
|
|
typedef enum {
|
|
READ_TOKEN,
|
|
READ_LITERAL,
|
|
COPY_LITERAL,
|
|
READ_OFFSET,
|
|
READ_MATCH,
|
|
SET_MATCH,
|
|
COPY_MATCH
|
|
} lz4mg_state_t;
|
|
|
|
typedef struct {
|
|
lz4mg_state_t state;
|
|
|
|
uint8_t token;
|
|
int literal_len;
|
|
int offset_cur;
|
|
int offset_pos;
|
|
int match_len;
|
|
int match_pos;
|
|
|
|
int window_pos;
|
|
uint8_t window[LZ4MG_WINDOW_SIZE];
|
|
} lz4mg_context_t;
|
|
|
|
typedef struct {
|
|
lz4mg_context_t ctx;
|
|
|
|
uint8_t *next_out; /* next bytes to write (reassign when avail is 0) */
|
|
int avail_out; /* bytes available at next_out */
|
|
int total_out; /* written bytes, for reference (set to 0 per call if needed) */
|
|
|
|
const uint8_t *next_in; /* next bytes to read (reassign when avail is 0) */
|
|
int avail_in; /* bytes available at next_in */
|
|
int total_in; /* read bytes, for reference (set to 0 per call if needed) */
|
|
} lz4mg_stream_t;
|
|
|
|
static void lz4mg_reset(lz4mg_stream_t* strm) {
|
|
memset(strm, 0, sizeof(lz4mg_stream_t));
|
|
}
|
|
|
|
/* Decompress src into dst, returning a code and number of bytes used. Caller must handle
|
|
* stop (when no more input data or all data has been decompressed) as LZ4 has no end markers. */
|
|
static int lz4mg_decompress(lz4mg_stream_t* strm) {
|
|
lz4mg_context_t* ctx = &strm->ctx;
|
|
uint8_t* dst = strm->next_out;
|
|
const uint8_t* src = strm->next_in;
|
|
int dst_size = strm->avail_out;
|
|
int src_size = strm->avail_in;
|
|
int dst_pos = 0;
|
|
int src_pos = 0;
|
|
uint8_t next_len, next_val;
|
|
|
|
|
|
while (1) {
|
|
/* mostly linear state machine, but it may break anytime when reaching dst or src
|
|
* end, and resume from same state in next call */
|
|
switch(ctx->state) {
|
|
|
|
case READ_TOKEN:
|
|
if (src_pos >= src_size)
|
|
goto buffer_end;
|
|
ctx->token = src[src_pos++];
|
|
|
|
ctx->literal_len = (ctx->token >> 4) & 0xF;
|
|
if (ctx->literal_len == LZ4MG_VARLEN_MARK)
|
|
ctx->state = READ_LITERAL;
|
|
else
|
|
ctx->state = COPY_LITERAL;
|
|
break;
|
|
|
|
case READ_LITERAL:
|
|
do {
|
|
if (src_pos >= src_size)
|
|
goto buffer_end;
|
|
next_len = src[src_pos++];
|
|
ctx->literal_len += next_len;
|
|
} while (next_len == LZ4MG_VARLEN_CONTINUE);
|
|
|
|
ctx->state = COPY_LITERAL;
|
|
break;
|
|
|
|
case COPY_LITERAL:
|
|
while (ctx->literal_len > 0) { /* may be 0 */
|
|
if (src_pos >= src_size || dst_pos >= dst_size)
|
|
goto buffer_end;
|
|
next_val = src[src_pos++];
|
|
|
|
dst[dst_pos++] = next_val;
|
|
|
|
ctx->window[ctx->window_pos++] = next_val;
|
|
if (ctx->window_pos == LZ4MG_WINDOW_SIZE)
|
|
ctx->window_pos = 0;
|
|
|
|
ctx->literal_len--;
|
|
};
|
|
|
|
/* LZ4 is designed to reach EOF with a literal in this state with some empty values */
|
|
|
|
ctx->offset_cur = 0;
|
|
ctx->offset_pos = 0;
|
|
ctx->state = READ_OFFSET;
|
|
break;
|
|
|
|
case READ_OFFSET:
|
|
do {
|
|
if (src_pos >= src_size)
|
|
goto buffer_end;
|
|
ctx->offset_pos |= (src[src_pos++] << ctx->offset_cur*8);
|
|
ctx->offset_cur++;
|
|
} while (ctx->offset_cur < LZ4MG_WINDOW_BYTES);
|
|
|
|
ctx->match_len = (ctx->token & 0xF);
|
|
if (ctx->match_len == LZ4MG_VARLEN_MARK)
|
|
ctx->state = READ_MATCH;
|
|
else
|
|
ctx->state = SET_MATCH;
|
|
break;
|
|
|
|
case READ_MATCH:
|
|
do {
|
|
if (src_pos >= src_size)
|
|
goto buffer_end;
|
|
next_len = src[src_pos++];
|
|
ctx->match_len += next_len;
|
|
} while (next_len == LZ4MG_VARLEN_CONTINUE);
|
|
|
|
ctx->state = SET_MATCH;
|
|
break;
|
|
|
|
case SET_MATCH:
|
|
ctx->match_len += LZ4MG_MIN_MATCH_LEN;
|
|
|
|
ctx->match_pos = ctx->window_pos - ctx->offset_pos;
|
|
if (ctx->match_pos < 0) /* circular buffer so negative is from window end */
|
|
ctx->match_pos = LZ4MG_WINDOW_SIZE + ctx->match_pos;
|
|
|
|
ctx->state = COPY_MATCH;
|
|
break;
|
|
|
|
case COPY_MATCH:
|
|
while (ctx->match_len > 0) {
|
|
if (dst_pos >= dst_size)
|
|
goto buffer_end;
|
|
|
|
next_val = ctx->window[ctx->match_pos++];
|
|
if (ctx->match_pos == LZ4MG_WINDOW_SIZE)
|
|
ctx->match_pos = 0;
|
|
|
|
dst[dst_pos++] = next_val;
|
|
|
|
ctx->window[ctx->window_pos++] = next_val;
|
|
if (ctx->window_pos == LZ4MG_WINDOW_SIZE)
|
|
ctx->window_pos = 0;
|
|
|
|
ctx->match_len--;
|
|
};
|
|
|
|
ctx->state = READ_TOKEN;
|
|
break;
|
|
|
|
default:
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
buffer_end:
|
|
strm->next_out += dst_pos;
|
|
strm->next_in += src_pos;
|
|
strm->avail_out -= dst_pos;
|
|
strm->avail_in -= src_pos;
|
|
strm->total_out += dst_pos;
|
|
strm->total_in += src_pos;
|
|
|
|
return LZ4MG_OK;
|
|
fail:
|
|
return LZ4MG_ERROR;
|
|
}
|
|
|
|
#if 0
|
|
/* non-streamed form for reference, assumes buffers are big enough */
|
|
static void decompress_lz4mg(uint8_t* dst, size_t dst_size, const uint8_t* src, size_t src_size) {
|
|
size_t src_pos = 0;
|
|
size_t dst_pos = 0;
|
|
uint8_t token;
|
|
int literal_len, match_len, next_len;
|
|
int match_pos, match_offset;
|
|
int i;
|
|
|
|
while (src_pos < src_size && dst_pos < dst_size) {
|
|
|
|
token = src[src_pos++];
|
|
if (src_pos > src_size)
|
|
break;
|
|
|
|
/* handle literals */
|
|
literal_len = token >> 4;
|
|
if (literal_len == 15) {
|
|
do {
|
|
next_len = src[src_pos++];
|
|
literal_len += next_len;
|
|
if (src_pos > src_size)
|
|
break;
|
|
} while (next_len == 255);
|
|
}
|
|
|
|
for (i = 0; i < literal_len; i++) {
|
|
dst[dst_pos++] = src[src_pos++];
|
|
}
|
|
|
|
/* can happen at EOF */
|
|
if (dst_pos >= dst_size)
|
|
break;
|
|
|
|
/* handle window matches */
|
|
match_offset = src[src_pos++];
|
|
match_offset |= (src[src_pos++] << 8);
|
|
|
|
match_len = (token & 0xF);
|
|
if (match_len == 15) {
|
|
do {
|
|
next_len = src[src_pos++];
|
|
match_len += next_len;
|
|
if (src_pos > src_size)
|
|
break;
|
|
} while (next_len == 255);
|
|
}
|
|
match_len += 4; /* min len */
|
|
|
|
match_pos = dst_pos - match_offset;
|
|
for(i = 0; i < match_len; i++) {
|
|
dst[dst_pos++] = dst[match_pos++]; /* note RLE with short offsets */
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endif /* _XNB_LZ4MG_H_ */
|