djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

lib/uzlib: Clean up tinf -> uzlib rename.

Browse Source 
This library used a mix of "tinf" and "uzlib" to refer to itself.  Remove
all use of "tinf" in the public API.

This work was funded through GitHub Sponsors.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
This commit is contained in:
Jim Mussared 2023-06-27 00:50:05 +10:00 committed by Damien George
parent 0900976384
commit c2b8e6e5d6
10 changed files with 117 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/uzlib/adler32.c
View File

@ -36,7 +36,7 @@
* Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
*/
#include "tinf.h"
#include "uzlib.h"
#define A32_BASE 65521
#define A32_NMAX 5552

2
lib/uzlib/crc32.c
View File

@ -36,7 +36,7 @@
* Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
*/
#include "tinf.h"
#include "uzlib.h"
static const unsigned int tinf_crc32tab[16] = {
0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190,

3
lib/uzlib/tinf.h
View File

@ -1,3 +0,0 @@
/* Compatibility header for the original tinf lib/older versions of uzlib.
Note: may be removed in the future, please migrate to uzlib.h. */
#include "uzlib.h"

9
lib/uzlib/tinf_compat.h
View File

@ -1,9 +0,0 @@
/* This header contains compatibility defines for the original tinf API
and uzlib 2.x and below API. These defines are deprecated and going
to be removed in the future, so applications should migrate to new
uzlib API. */
#define TINF_DATA struct uzlib_uncomp
#define destSize dest_size
#define destStart dest_start
#define readSource source_read_cb

24
lib/uzlib/tinfgzip.c
View File

@ -33,7 +33,7 @@
* any source distribution.
*/
#include "tinf.h"
#include "uzlib.h"
#define FTEXT 1
#define FHCRC 2
@ -41,38 +41,38 @@
#define FNAME 8
#define FCOMMENT 16
void tinf_skip_bytes(TINF_DATA *d, int num);
uint16_t tinf_get_uint16(TINF_DATA *d);
void tinf_skip_bytes(uzlib_uncomp_t *d, int num);
uint16_t tinf_get_uint16(uzlib_uncomp_t *d);
void tinf_skip_bytes(TINF_DATA *d, int num)
void tinf_skip_bytes(uzlib_uncomp_t *d, int num)
{
while (num--) uzlib_get_byte(d);
}
uint16_t tinf_get_uint16(TINF_DATA *d)
uint16_t tinf_get_uint16(uzlib_uncomp_t *d)
{
unsigned int v = uzlib_get_byte(d);
v = (uzlib_get_byte(d) << 8) | v;
return v;
}
int uzlib_gzip_parse_header(TINF_DATA *d)
int uzlib_gzip_parse_header(uzlib_uncomp_t *d)
{
unsigned char flg;
/* -- check format -- */
/* check id bytes */
if (uzlib_get_byte(d) != 0x1f || uzlib_get_byte(d) != 0x8b) return TINF_DATA_ERROR;
if (uzlib_get_byte(d) != 0x1f || uzlib_get_byte(d) != 0x8b) return UZLIB_DATA_ERROR;
/* check method is deflate */
if (uzlib_get_byte(d) != 8) return TINF_DATA_ERROR;
if (uzlib_get_byte(d) != 8) return UZLIB_DATA_ERROR;
/* get flag byte */
flg = uzlib_get_byte(d);
/* check that reserved bits are zero */
if (flg & 0xe0) return TINF_DATA_ERROR;
if (flg & 0xe0) return UZLIB_DATA_ERROR;
/* -- find start of compressed data -- */
@ -99,12 +99,12 @@ int uzlib_gzip_parse_header(TINF_DATA *d)
// TODO: Check!
// if (hcrc != (tinf_crc32(src, start - src) & 0x0000ffff))
// return TINF_DATA_ERROR;
// return UZLIB_DATA_ERROR;
}
/* initialize for crc32 checksum */
d->checksum_type = TINF_CHKSUM_CRC;
d->checksum_type = UZLIB_CHKSUM_CRC;
d->checksum = ~0;
return TINF_OK;
return UZLIB_OK;
}

98
lib/uzlib/tinflate.c
View File

@ -33,7 +33,7 @@
*/
#include <assert.h>
#include "tinf.h"
#include "uzlib.h"
#define UZLIB_DUMP_ARRAY(heading, arr, size) \
{ \
@ -44,8 +44,8 @@
printf("\n"); \
}
uint32_t tinf_get_le_uint32(TINF_DATA *d);
uint32_t tinf_get_be_uint32(TINF_DATA *d);
uint32_t tinf_get_le_uint32(uzlib_uncomp_t *d);
uint32_t tinf_get_be_uint32(uzlib_uncomp_t *d);
/* --------------------------------------------------- *
* -- uninitialized global data (static structures) -- *
@ -189,7 +189,7 @@ static void tinf_build_tree(TINF_TREE *t, const unsigned char *lengths, unsigned
* -- decode functions -- *
* ---------------------- */
unsigned char uzlib_get_byte(TINF_DATA *d)
unsigned char uzlib_get_byte(uzlib_uncomp_t *d)
{
/* If end of source buffer is not reached, return next byte from source
buffer. */
@ -200,14 +200,14 @@ unsigned char uzlib_get_byte(TINF_DATA *d)
/* Otherwise if there's callback and we haven't seen EOF yet, try to
read next byte using it. (Note: the callback can also update ->source
and ->source_limit). */
if (d->readSource && !d->eof) {
int val = d->readSource(d);
if (d->source_read_cb && !d->eof) {
int val = d->source_read_cb(d);
if (val >= 0) {
return (unsigned char)val;
}
}
/* Otherwise, we hit EOF (either from ->readSource() or from exhaustion
/* Otherwise, we hit EOF (either from ->source_read_cb() or from exhaustion
of the buffer), and it will be "sticky", i.e. further calls to this
function will end up here too. */
d->eof = true;
@ -215,7 +215,7 @@ unsigned char uzlib_get_byte(TINF_DATA *d)
return 0;
}
uint32_t tinf_get_le_uint32(TINF_DATA *d)
uint32_t tinf_get_le_uint32(uzlib_uncomp_t *d)
{
uint32_t val = 0;
int i;
@ -225,7 +225,7 @@ uint32_t tinf_get_le_uint32(TINF_DATA *d)
return val;
}
uint32_t tinf_get_be_uint32(TINF_DATA *d)
uint32_t tinf_get_be_uint32(uzlib_uncomp_t *d)
{
uint32_t val = 0;
int i;
@ -236,7 +236,7 @@ uint32_t tinf_get_be_uint32(TINF_DATA *d)
}
/* get one bit from source stream */
static int tinf_getbit(TINF_DATA *d)
static int tinf_getbit(uzlib_uncomp_t *d)
{
unsigned int bit;
@ -256,7 +256,7 @@ static int tinf_getbit(TINF_DATA *d)
}
/* read a num bit value from a stream and add base */
static unsigned int tinf_read_bits(TINF_DATA *d, int num, int base)
static unsigned int tinf_read_bits(uzlib_uncomp_t *d, int num, int base)
{
unsigned int val = 0;
@ -274,7 +274,7 @@ static unsigned int tinf_read_bits(TINF_DATA *d, int num, int base)
}
/* given a data stream and a tree, decode a symbol */
static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t)
static int tinf_decode_symbol(uzlib_uncomp_t *d, TINF_TREE *t)
{
int sum = 0, cur = 0, len = 0;
@ -284,7 +284,7 @@ static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t)
cur = 2*cur + tinf_getbit(d);
if (++len == TINF_ARRAY_SIZE(t->table)) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
sum += t->table[len];
@ -295,7 +295,7 @@ static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t)
sum += cur;
#if UZLIB_CONF_PARANOID_CHECKS
if (sum < 0 || sum >= TINF_ARRAY_SIZE(t->trans)) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
#endif
@ -303,7 +303,7 @@ static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t)
}
/* given a data stream, decode dynamic trees from it */
static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
static int tinf_decode_trees(uzlib_uncomp_t *d, TINF_TREE *lt, TINF_TREE *dt)
{
/* code lengths for 288 literal/len symbols and 32 dist symbols */
unsigned char lengths[288+32];
@ -348,7 +348,7 @@ static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
{
case 16:
/* copy previous code length 3-6 times (read 2 bits) */
if (num == 0) return TINF_DATA_ERROR;
if (num == 0) return UZLIB_DATA_ERROR;
fill_value = lengths[num - 1];
lbits = 2;
break;
@ -370,7 +370,7 @@ static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
/* special code length 16-18 are handled here */
length = tinf_read_bits(d, lbits, lbase);
if (num + length > hlimit) return TINF_DATA_ERROR;
if (num + length > hlimit) return UZLIB_DATA_ERROR;
for (; length; --length)
{
lengths[num++] = fill_value;
@ -387,7 +387,7 @@ static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
#if UZLIB_CONF_PARANOID_CHECKS
/* Check that there's "end of block" symbol */
if (lengths[256] == 0) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
#endif
@ -395,7 +395,7 @@ static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
tinf_build_tree(lt, lengths, hlit);
tinf_build_tree(dt, lengths + hlit, hdist);
return TINF_OK;
return UZLIB_OK;
}
/* ----------------------------- *
@ -403,7 +403,7 @@ static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
* ----------------------------- */
/* given a stream and two trees, inflate next byte of output */
static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
static int tinf_inflate_block_data(uzlib_uncomp_t *d, TINF_TREE *lt, TINF_TREE *dt)
{
if (d->curlen == 0) {
unsigned int offs;
@ -412,24 +412,24 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
//printf("huff sym: %02x\n", sym);
if (d->eof) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
/* literal byte */
if (sym < 256) {
TINF_PUT(d, sym);
return TINF_OK;
return UZLIB_OK;
}
/* end of block */
if (sym == 256) {
return TINF_DONE;
return UZLIB_DONE;
}
/* substring from sliding dictionary */
sym -= 257;
if (sym >= 29) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
/* possibly get more bits from length code */
@ -437,7 +437,7 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
dist = tinf_decode_symbol(d, dt);
if (dist >= 30) {
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
/* possibly get more bits from distance code */
@ -446,7 +446,7 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
/* calculate and validate actual LZ offset to use */
if (d->dict_ring) {
if (offs > d->dict_size) {
return TINF_DICT_ERROR;
return UZLIB_DICT_ERROR;
}
/* Note: unlike full-dest-in-memory case below, we don't
try to catch offset which points to not yet filled
@ -464,8 +464,8 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
}
} else {
/* catch trying to point before the start of dest buffer */
if (offs > (unsigned int)(d->dest - d->destStart)) {
return TINF_DATA_ERROR;
if (offs > (unsigned int)(d->dest - d->dest_start)) {
return UZLIB_DATA_ERROR;
}
d->lzOff = -offs;
}
@ -482,11 +482,11 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
d->dest++;
}
d->curlen--;
return TINF_OK;
return UZLIB_OK;
}
/* inflate next byte from uncompressed block of data */
static int tinf_inflate_uncompressed_block(TINF_DATA *d)
static int tinf_inflate_uncompressed_block(uzlib_uncomp_t *d)
{
if (d->curlen == 0) {
unsigned int length, invlength;
@ -498,9 +498,9 @@ static int tinf_inflate_uncompressed_block(TINF_DATA *d)
invlength = uzlib_get_byte(d);
invlength += 256 * uzlib_get_byte(d);
/* check length */
if (length != (~invlength & 0x0000ffff)) return TINF_DATA_ERROR;
if (length != (~invlength & 0x0000ffff)) return UZLIB_DATA_ERROR;
/* increment length to properly return TINF_DONE below, without
/* increment length to properly return UZLIB_DONE below, without
producing data at the same time */
d->curlen = length + 1;
@ -509,12 +509,12 @@ static int tinf_inflate_uncompressed_block(TINF_DATA *d)
}
if (--d->curlen == 0) {
return TINF_DONE;
return UZLIB_DONE;
}
unsigned char c = uzlib_get_byte(d);
TINF_PUT(d, c);
return TINF_OK;
return UZLIB_OK;
}
/* ---------------------- *
@ -536,7 +536,7 @@ void uzlib_init(void)
}
/* initialize decompression structure */
void uzlib_uncompress_init(TINF_DATA *d, void *dict, unsigned int dictLen)
void uzlib_uncompress_init(uzlib_uncomp_t *d, void *dict, unsigned int dictLen)
{
d->eof = 0;
d->bitcount = 0;
@ -549,7 +549,7 @@ void uzlib_uncompress_init(TINF_DATA *d, void *dict, unsigned int dictLen)
}
/* inflate next output bytes from compressed stream */
int uzlib_uncompress(TINF_DATA *d)
int uzlib_uncompress(uzlib_uncomp_t *d)
{
do {
int res;
@ -572,7 +572,7 @@ next_blk:
} else if (d->btype == 2) {
/* decode trees from stream */
res = tinf_decode_trees(d, &d->ltree, &d->dtree);
if (res != TINF_OK) {
if (res != UZLIB_OK) {
return res;
}
}
@ -592,27 +592,27 @@ next_blk:
res = tinf_inflate_block_data(d, &d->ltree, &d->dtree);
break;
default:
return TINF_DATA_ERROR;
return UZLIB_DATA_ERROR;
}
if (res == TINF_DONE && !d->bfinal) {
if (res == UZLIB_DONE && !d->bfinal) {
/* the block has ended (without producing more data), but we
can't return without data, so start procesing next block */
goto next_blk;
}
if (res != TINF_OK) {
if (res != UZLIB_OK) {
return res;
}
} while (d->dest < d->dest_limit);
return TINF_OK;
return UZLIB_OK;
}
/* inflate next output bytes from compressed stream, updating
checksum, and at the end of stream, verify it */
int uzlib_uncompress_chksum(TINF_DATA *d)
int uzlib_uncompress_chksum(uzlib_uncomp_t *d)
{
int res;
unsigned char *data = d->dest;
@ -623,31 +623,31 @@ int uzlib_uncompress_chksum(TINF_DATA *d)
switch (d->checksum_type) {
case TINF_CHKSUM_ADLER:
case UZLIB_CHKSUM_ADLER:
d->checksum = uzlib_adler32(data, d->dest - data, d->checksum);
break;
case TINF_CHKSUM_CRC:
case UZLIB_CHKSUM_CRC:
d->checksum = uzlib_crc32(data, d->dest - data, d->checksum);
break;
}
if (res == TINF_DONE) {
if (res == UZLIB_DONE) {
unsigned int val;
switch (d->checksum_type) {
case TINF_CHKSUM_ADLER:
case UZLIB_CHKSUM_ADLER:
val = tinf_get_be_uint32(d);
if (d->checksum != val) {
return TINF_CHKSUM_ERROR;
return UZLIB_CHKSUM_ERROR;
}
break;
case TINF_CHKSUM_CRC:
case UZLIB_CHKSUM_CRC:
val = tinf_get_le_uint32(d);
if (~d->checksum != val) {
return TINF_CHKSUM_ERROR;
return UZLIB_CHKSUM_ERROR;
}
// Uncompressed size. TODO: Check
val = tinf_get_le_uint32(d);

14
lib/uzlib/tinfzlib.c
View File

@ -33,9 +33,9 @@
* any source distribution.
*/
#include "tinf.h"
#include "uzlib.h"
int uzlib_zlib_parse_header(TINF_DATA *d)
int uzlib_zlib_parse_header(uzlib_uncomp_t *d)
{
unsigned char cmf, flg;
@ -47,19 +47,19 @@ int uzlib_zlib_parse_header(TINF_DATA *d)
/* -- check format -- */
/* check checksum */
if ((256*cmf + flg) % 31) return TINF_DATA_ERROR;
if ((256*cmf + flg) % 31) return UZLIB_DATA_ERROR;
/* check method is deflate */
if ((cmf & 0x0f) != 8) return TINF_DATA_ERROR;
if ((cmf & 0x0f) != 8) return UZLIB_DATA_ERROR;
/* check window size is valid */
if ((cmf >> 4) > 7) return TINF_DATA_ERROR;
if ((cmf >> 4) > 7) return UZLIB_DATA_ERROR;
/* check there is no preset dictionary */
if (flg & 0x20) return TINF_DATA_ERROR;
if (flg & 0x20) return UZLIB_DATA_ERROR;
/* initialize for adler32 checksum */
d->checksum_type = TINF_CHKSUM_ADLER;
d->checksum_type = UZLIB_CHKSUM_ADLER;
d->checksum = 1;
return cmf >> 4;

58
lib/uzlib/uzlib.h
View File

@ -7,6 +7,9 @@
*
* Copyright (c) 2014-2018 by Paul Sokolovsky
*
* Optimised for MicroPython:
* Copyright (c) 2023 by Jim Mussared
*
* This software is provided 'as-is', without any express
* or implied warranty. In no event will the authors be
* held liable for any damages arising from the use of
@ -46,31 +49,22 @@
#include <stdio.h>
#endif
/* calling convention */
#ifndef TINFCC
#ifdef __WATCOMC__
#define TINFCC __cdecl
#else
#define TINFCC
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* ok status, more data produced */
#define TINF_OK 0
#define UZLIB_OK 0
/* end of compressed stream reached */
#define TINF_DONE 1
#define TINF_DATA_ERROR (-3)
#define TINF_CHKSUM_ERROR (-4)
#define TINF_DICT_ERROR (-5)
#define UZLIB_DONE 1
#define UZLIB_DATA_ERROR (-3)
#define UZLIB_CHKSUM_ERROR (-4)
#define UZLIB_DICT_ERROR (-5)
/* checksum types */
#define TINF_CHKSUM_NONE 0
#define TINF_CHKSUM_ADLER 1
#define TINF_CHKSUM_CRC 2
#define UZLIB_CHKSUM_NONE 0
#define UZLIB_CHKSUM_ADLER 1
#define UZLIB_CHKSUM_CRC 2
/* helper macros */
#define TINF_ARRAY_SIZE(arr) (sizeof(arr) / sizeof(*(arr)))
@ -82,7 +76,7 @@ typedef struct {
unsigned short trans[288]; /* code -> symbol translation table */
} TINF_TREE;
struct uzlib_uncomp {
typedef struct _uzlib_uncomp_t {
/* Pointer to the next byte in the input buffer */
const unsigned char *source;
/* Pointer to the next byte past the input buffer (source_limit = source + len) */
@ -92,7 +86,7 @@ struct uzlib_uncomp {
also return -1 in case of EOF (or irrecoverable error). Note that
besides returning the next byte, it may also update source and
source_limit fields, thus allowing for buffered operation. */
int (*source_read_cb)(struct uzlib_uncomp *uncomp);
int (*source_read_cb)(struct _uzlib_uncomp_t *uncomp);
unsigned int tag;
unsigned int bitcount;
@ -119,9 +113,7 @@ struct uzlib_uncomp {
TINF_TREE ltree; /* dynamic length/symbol tree */
TINF_TREE dtree; /* dynamic distance tree */
};
#include "tinf_compat.h"
} uzlib_uncomp_t;
#define TINF_PUT(d, c) \
{ \
@ -129,17 +121,17 @@ struct uzlib_uncomp {
if (d->dict_ring) { d->dict_ring[d->dict_idx++] = c; if (d->dict_idx == d->dict_size) d->dict_idx = 0; } \
}
unsigned char TINFCC uzlib_get_byte(TINF_DATA *d);
unsigned char uzlib_get_byte(uzlib_uncomp_t *d);
/* Decompression API */
void TINFCC uzlib_init(void);
void TINFCC uzlib_uncompress_init(TINF_DATA *d, void *dict, unsigned int dictLen);
int TINFCC uzlib_uncompress(TINF_DATA *d);
int TINFCC uzlib_uncompress_chksum(TINF_DATA *d);
void uzlib_init(void);
void uzlib_uncompress_init(uzlib_uncomp_t *d, void *dict, unsigned int dictLen);
int uzlib_uncompress(uzlib_uncomp_t *d);
int uzlib_uncompress_chksum(uzlib_uncomp_t *d);
int TINFCC uzlib_zlib_parse_header(TINF_DATA *d);
int TINFCC uzlib_gzip_parse_header(TINF_DATA *d);
int uzlib_zlib_parse_header(uzlib_uncomp_t *d);
int uzlib_gzip_parse_header(uzlib_uncomp_t *d);
/* Compression API */
@ -151,15 +143,15 @@ struct uzlib_lz77_state {
size_t hist_len;
};
void TINFCC uzlib_lz77_init(struct uzlib_lz77_state *state, uint8_t *hist, size_t hist_max);
void TINFCC uzlib_lz77_compress(struct uzlib_lz77_state *state, const uint8_t *src, unsigned len);
void uzlib_lz77_init(struct uzlib_lz77_state *state, uint8_t *hist, size_t hist_max);
void uzlib_lz77_compress(struct uzlib_lz77_state *state, const uint8_t *src, unsigned len);
/* Checksum API */
/* prev_sum is previous value for incremental computation, 1 initially */
uint32_t TINFCC uzlib_adler32(const void *data, unsigned int length, uint32_t prev_sum);
uint32_t uzlib_adler32(const void *data, unsigned int length, uint32_t prev_sum);
/* crc is previous value for incremental computation, 0xffffffff initially */
uint32_t TINFCC uzlib_crc32(const void *data, unsigned int length, uint32_t crc);
uint32_t uzlib_crc32(const void *data, unsigned int length, uint32_t crc);
#ifdef __cplusplus
} /* extern "C" */

2
ports/stm32/mboot/fsload.c
View File

@ -27,7 +27,7 @@
#include <string.h>
#include "py/mphal.h"
#include "lib/uzlib/tinf.h"
#include "lib/uzlib/uzlib.h"
#include "mboot.h"
#include "pack.h"
#include "vfs.h"

42
ports/stm32/mboot/gzstream.c
View File

@ -38,14 +38,14 @@
typedef struct _gz_stream_t {
void *stream_data;
stream_read_t stream_read;
struct uzlib_uncomp tinf;
uzlib_uncomp_t decomp;
uint8_t buf[512];
uint8_t dict[DICT_SIZE];
} gz_stream_t;
static gz_stream_t gz_stream SECTION_NOZERO_BSS;
static int gz_stream_read_src(TINF_DATA *tinf) {
static int gz_stream_read_src(uzlib_uncomp_t *decomp) {
int n = gz_stream.stream_read(gz_stream.stream_data, gz_stream.buf, sizeof(gz_stream.buf));
if (n < 0) {
// Stream error
@ -56,17 +56,17 @@ static int gz_stream_read_src(TINF_DATA *tinf) {
return -1;
}
tinf->source = gz_stream.buf + 1;
tinf->source_limit = gz_stream.buf + n;
decomp->source = gz_stream.buf + 1;
decomp->source_limit = gz_stream.buf + n;
return gz_stream.buf[0];
}
int gz_stream_init_from_raw_data(const uint8_t *data, size_t len) {
memset(&gz_stream.tinf, 0, sizeof(gz_stream.tinf));
gz_stream.tinf.source = data;
gz_stream.tinf.source_limit = data + len;
memset(&gz_stream.decomp, 0, sizeof(gz_stream.decomp));
gz_stream.decomp.source = data;
gz_stream.decomp.source_limit = data + len;
uzlib_uncompress_init(&gz_stream.tinf, gz_stream.dict, DICT_SIZE);
uzlib_uncompress_init(&gz_stream.decomp, gz_stream.dict, DICT_SIZE);
return 0;
}
@ -75,36 +75,36 @@ int gz_stream_init_from_stream(void *stream_data, stream_read_t stream_read) {
gz_stream.stream_data = stream_data;
gz_stream.stream_read = stream_read;
memset(&gz_stream.tinf, 0, sizeof(gz_stream.tinf));
gz_stream.tinf.source_read_cb = gz_stream_read_src;
memset(&gz_stream.decomp, 0, sizeof(gz_stream.decomp));
gz_stream.decomp.source_read_cb = gz_stream_read_src;
int st = uzlib_gzip_parse_header(&gz_stream.tinf);
if (st != TINF_OK) {
int st = uzlib_gzip_parse_header(&gz_stream.decomp);
if (st != UZLIB_OK) {
return -MBOOT_ERRNO_GUNZIP_FAILED;
}
uzlib_uncompress_init(&gz_stream.tinf, gz_stream.dict, DICT_SIZE);
uzlib_uncompress_init(&gz_stream.decomp, gz_stream.dict, DICT_SIZE);
return 0;
}
int gz_stream_read(size_t len, uint8_t *buf) {
if (gz_stream.tinf.source == NULL && gz_stream.tinf.source_read_cb == NULL) {
if (gz_stream.decomp.source == NULL && gz_stream.decomp.source_read_cb == NULL) {
// End of stream.
return 0;
}
gz_stream.tinf.dest = buf;
gz_stream.tinf.dest_limit = buf + len;
int st = uzlib_uncompress_chksum(&gz_stream.tinf);
gz_stream.decomp.dest = buf;
gz_stream.decomp.dest_limit = buf + len;
int st = uzlib_uncompress_chksum(&gz_stream.decomp);
if (st < 0) {
return st;
}
if (st == TINF_DONE) {
if (st == UZLIB_DONE) {
// Indicate end-of-stream for subsequent calls.
gz_stream.tinf.source = NULL;
gz_stream.tinf.source_read_cb = NULL;
gz_stream.decomp.source = NULL;
gz_stream.decomp.source_read_cb = NULL;
}
return gz_stream.tinf.dest - buf;
return gz_stream.decomp.dest - buf;
}
#endif // MBOOT_FSLOAD || MBOOT_ENABLE_PACKING