arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-07-01 04:12:37 +00:00
Code Issues Releases Wiki Activity

improve inflate code

Browse Source
This commit is contained in:
Pavol Rusnak 2016-05-13 14:33:33 +02:00
parent 32c7782d89
commit 9222b77a03
No known key found for this signature in database
GPG Key ID: 91F3B339B9A02A3D
5 changed files with 75 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
extmod/modtrezorui/display.c
View File

@ -127,7 +127,7 @@ static void inflate_callback_image(uint8_t byte, uint32_t pos, void *userdata)
void display_image(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const void *data, int datalen) void display_image(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const void *data, int datalen)
{ {
display_set_window(x, y, w, h); display_set_window(x, y, w, h);
sinf_inflate(data, inflate_callback_image, NULL); sinf_inflate(data, datalen, inflate_callback_image, NULL);
display_update(); display_update();
} }
@ -145,7 +145,7 @@ void display_icon(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const void *data,
display_set_window(x, y, w, h); display_set_window(x, y, w, h);
uint16_t colortable[16]; uint16_t colortable[16];
set_color_table(colortable, fgcolor, bgcolor); set_color_table(colortable, fgcolor, bgcolor);
sinf_inflate(data, inflate_callback_icon, colortable); sinf_inflate(data, datalen, inflate_callback_icon, colortable);
display_update(); display_update();
} }
@ -245,7 +245,7 @@ static void inflate_callback_loader(uint8_t byte, uint32_t pos, void *userdata)
out[pos] = byte; out[pos] = byte;
} }
void display_loader(uint16_t progress, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *icon, uint16_t iconfgcolor) void display_loader(uint16_t progress, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *icon, uint32_t iconlen, uint16_t iconfgcolor)
{ {
uint16_t colortable[16], iconcolortable[16]; uint16_t colortable[16], iconcolortable[16];
set_color_table(colortable, fgcolor, bgcolor); set_color_table(colortable, fgcolor, bgcolor);
@ -253,9 +253,9 @@ void display_loader(uint16_t progress, uint16_t fgcolor, uint16_t bgcolor, const
set_color_table(iconcolortable, iconfgcolor, bgcolor); set_color_table(iconcolortable, iconfgcolor, bgcolor);
} }
display_set_window(RESX / 2 - img_loader_size, RESY * 2 / 5 - img_loader_size, img_loader_size * 2, img_loader_size * 2); display_set_window(RESX / 2 - img_loader_size, RESY * 2 / 5 - img_loader_size, img_loader_size * 2, img_loader_size * 2);
if (icon && memcmp(icon, "TOIg\x60\x00\x60\x00", 8) == 0) { if (icon && memcmp(icon, "TOIg\x60\x00\x60\x00", 8) == 0 && iconlen == 12 + *(uint32_t *)(icon + 8)) {
uint8_t icondata[96 * 96 / 2]; uint8_t icondata[96 * 96 / 2];
sinf_inflate(icon + 12, inflate_callback_loader, icondata); sinf_inflate(icon + 12, iconlen - 12, inflate_callback_loader, icondata);
icon = icondata; icon = icondata;
} else { } else {
icon = NULL; icon = NULL;

2
extmod/modtrezorui/display.h
View File

@ -26,7 +26,7 @@ void display_icon(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const void *data,
void display_text(uint8_t x, uint8_t y, const uint8_t *text, int textlen, uint8_t font, uint16_t fgcolor, uint16_t bgcolor); void display_text(uint8_t x, uint8_t y, const uint8_t *text, int textlen, uint8_t font, uint16_t fgcolor, uint16_t bgcolor);
uint32_t display_text_width(const uint8_t *text, int textlen, uint8_t font); uint32_t display_text_width(const uint8_t *text, int textlen, uint8_t font);
void display_qrcode(uint8_t x, uint8_t y, const char *data, int datalen, int scale); void display_qrcode(uint8_t x, uint8_t y, const char *data, int datalen, int scale);
void display_loader(uint16_t progress, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *icon, uint16_t iconfgcolor); void display_loader(uint16_t progress, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *icon, uint32_t iconlen, uint16_t iconfgcolor);
void display_raw(uint8_t reg, const uint8_t *data, int datalen); void display_raw(uint8_t reg, const uint8_t *data, int datalen);
#endif #endif

130
extmod/modtrezorui/inflate.c
View File

@ -49,6 +49,7 @@ typedef struct {
typedef struct { typedef struct {
const uint8_t *source; const uint8_t *source;
uint32_t sourcelen;
uint32_t tag; uint32_t tag;
uint32_t bitcount; uint32_t bitcount;
uint8_t cbuf[1 << SINF_WBITS]; uint8_t cbuf[1 << SINF_WBITS];
@ -58,32 +59,32 @@ typedef struct {
void (* write)(uint8_t byte, uint32_t pos, void *userdata); void (* write)(uint8_t byte, uint32_t pos, void *userdata);
void *userdata; void *userdata;
uint32_t written; uint32_t written;
} SINF_DATA; } SINF_CTX;
/* --------------------------------------------------- * /* --------------------------------------------------- *
* -- uninitialized global data (static structures) -- * * -- uninitialized global data (static structures) -- *
* --------------------------------------------------- */ * --------------------------------------------------- */
const uint8_t SINF_LENGTH_BITS[30] = { static const uint8_t SINF_LENGTH_BITS[30] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4,
5, 5, 5, 5 5, 5, 5, 5
}; };
const uint16_t SINF_LENGTH_BASE[30] = { static const uint16_t SINF_LENGTH_BASE[30] = {
3, 4, 5, 6, 7, 8, 9, 10, 3, 4, 5, 6, 7, 8, 9, 10,
11, 13, 15, 17, 19, 23, 27, 31, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 35, 43, 51, 59, 67, 83, 99, 115,
131, 163, 195, 227, 258 131, 163, 195, 227, 258
}; };
const uint8_t SINF_DIST_BITS[30] = { static const uint8_t SINF_DIST_BITS[30] = {
0, 0, 0, 0, 1, 1, 2, 2, 0, 0, 0, 0, 1, 1, 2, 2,
3, 3, 4, 4, 5, 5, 6, 6, 3, 3, 4, 4, 5, 5, 6, 6,
7, 7, 8, 8, 9, 9, 10, 10, 7, 7, 8, 8, 9, 9, 10, 10,
11, 11, 12, 12, 13, 13 11, 11, 12, 12, 13, 13
}; };
const uint16_t SINF_DIST_BASE[30] = { static const uint16_t SINF_DIST_BASE[30] = {
1, 2, 3, 4, 5, 7, 9, 13, 1, 2, 3, 4, 5, 7, 9, 13,
17, 25, 33, 49, 65, 97, 129, 193, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
@ -91,7 +92,7 @@ const uint16_t SINF_DIST_BASE[30] = {
}; };
/* special ordering of code length codes */ /* special ordering of code length codes */
const uint8_t SINF_CLCIDX[] = { static const uint8_t SINF_CLCIDX[] = {
16, 17, 18, 0, 8, 7, 9, 6, 16, 17, 18, 0, 8, 7, 9, 6,
10, 5, 11, 4, 12, 3, 13, 2, 10, 5, 11, 4, 12, 3, 13, 2,
14, 1, 15 14, 1, 15
@ -101,12 +102,12 @@ const uint8_t SINF_CLCIDX[] = {
* -- utility functions -- * * -- utility functions -- *
* ----------------------- */ * ----------------------- */
static void sinf_write(SINF_DATA *d, uint8_t byte) static void sinf_write(SINF_CTX *ctx, uint8_t byte)
{ {
d->cbuf[d->cbufi] = byte; ctx->cbuf[ctx->cbufi] = byte;
d->cbufi = (d->cbufi + 1) % (1 << SINF_WBITS); ctx->cbufi = (ctx->cbufi + 1) % (1 << SINF_WBITS);
d->write(byte, d->written, d->userdata); ctx->write(byte, ctx->written, ctx->userdata);
d->written++; ctx->written++;
} }
/* build the fixed huffman trees */ /* build the fixed huffman trees */
@ -167,27 +168,27 @@ static void sinf_build_tree(SINF_TREE *t, const uint8_t *lengths, uint32_t num)
* ---------------------- */ * ---------------------- */
/* get one bit from source stream */ /* get one bit from source stream */
static int sinf_getbit(SINF_DATA *d) static int sinf_getbit(SINF_CTX *ctx)
{ {
uint32_t bit; uint32_t bit;
/* check if tag is empty */ /* check if tag is empty */
if (!d->bitcount--) if (!ctx->bitcount--)
{ {
/* load next tag */ /* load next tag */
d->tag = *d->source++; ctx->tag = *ctx->source++;
d->bitcount = 7; ctx->bitcount = 7;
} }
/* shift bit out of tag */ /* shift bit out of tag */
bit = d->tag & 0x01; bit = ctx->tag & 0x01;
d->tag >>= 1; ctx->tag >>= 1;
return bit; return bit;
} }
/* read a num bit value from a stream and add base */ /* read a num bit value from a stream and add base */
static uint32_t sinf_read_bits(SINF_DATA *d, int num, int base) static uint32_t sinf_read_bits(SINF_CTX *ctx, int num, int base)
{ {
uint32_t val = 0; uint32_t val = 0;
@ -198,21 +199,21 @@ static uint32_t sinf_read_bits(SINF_DATA *d, int num, int base)
uint32_t mask; uint32_t mask;
for (mask = 1; mask < limit; mask *= 2) for (mask = 1; mask < limit; mask *= 2)
if (sinf_getbit(d)) val += mask; if (sinf_getbit(ctx)) val += mask;
} }
return val + base; return val + base;
} }
/* given a data stream and a tree, decode a symbol */ /* given a data stream and a tree, decode a symbol */
static int sinf_decode_symbol(SINF_DATA *d, SINF_TREE *t) static int sinf_decode_symbol(SINF_CTX *ctx, SINF_TREE *t)
{ {
int sum = 0, cur = 0, len = 0; int sum = 0, cur = 0, len = 0;
/* get more bits while code value is above sum */ /* get more bits while code value is above sum */
do { do {
cur = 2*cur + sinf_getbit(d); cur = 2*cur + sinf_getbit(ctx);
++len; ++len;
@ -225,20 +226,20 @@ static int sinf_decode_symbol(SINF_DATA *d, SINF_TREE *t)
} }
/* given a data stream, decode dynamic trees from it */ /* given a data stream, decode dynamic trees from it */
static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt) static void sinf_decode_trees(SINF_CTX *ctx, SINF_TREE *lt, SINF_TREE *dt)
{ {
uint8_t lengths[288+32]; uint8_t lengths[288+32];
uint32_t hlit, hdist, hclen; uint32_t hlit, hdist, hclen;
uint32_t i, num, length; uint32_t i, num, length;
/* get 5 bits HLIT (257-286) */ /* get 5 bits HLIT (257-286) */
hlit = sinf_read_bits(d, 5, 257); hlit = sinf_read_bits(ctx, 5, 257);
/* get 5 bits HDIST (1-32) */ /* get 5 bits HDIST (1-32) */
hdist = sinf_read_bits(d, 5, 1); hdist = sinf_read_bits(ctx, 5, 1);
/* get 4 bits HCLEN (4-19) */ /* get 4 bits HCLEN (4-19) */
hclen = sinf_read_bits(d, 4, 4); hclen = sinf_read_bits(ctx, 4, 4);
for (i = 0; i < 19; ++i) lengths[i] = 0; for (i = 0; i < 19; ++i) lengths[i] = 0;
@ -246,7 +247,7 @@ static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
for (i = 0; i < hclen; ++i) for (i = 0; i < hclen; ++i)
{ {
/* get 3 bits code length (0-7) */ /* get 3 bits code length (0-7) */
uint32_t clen = sinf_read_bits(d, 3, 0); uint32_t clen = sinf_read_bits(ctx, 3, 0);
lengths[SINF_CLCIDX[i]] = clen; lengths[SINF_CLCIDX[i]] = clen;
} }
@ -257,7 +258,7 @@ static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
/* decode code lengths for the dynamic trees */ /* decode code lengths for the dynamic trees */
for (num = 0; num < hlit + hdist; ) for (num = 0; num < hlit + hdist; )
{ {
int sym = sinf_decode_symbol(d, lt); int sym = sinf_decode_symbol(ctx, lt);
switch (sym) switch (sym)
{ {
@ -265,7 +266,7 @@ static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
/* copy previous code length 3-6 times (read 2 bits) */ /* copy previous code length 3-6 times (read 2 bits) */
{ {
uint8_t prev = lengths[num - 1]; uint8_t prev = lengths[num - 1];
for (length = sinf_read_bits(d, 2, 3); length; --length) for (length = sinf_read_bits(ctx, 2, 3); length; --length)
{ {
lengths[num++] = prev; lengths[num++] = prev;
} }
@ -273,14 +274,14 @@ static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
break; break;
case 17: case 17:
/* repeat code length 0 for 3-10 times (read 3 bits) */ /* repeat code length 0 for 3-10 times (read 3 bits) */
for (length = sinf_read_bits(d, 3, 3); length; --length) for (length = sinf_read_bits(ctx, 3, 3); length; --length)
{ {
lengths[num++] = 0; lengths[num++] = 0;
} }
break; break;
case 18: case 18:
/* repeat code length 0 for 11-138 times (read 7 bits) */ /* repeat code length 0 for 11-138 times (read 7 bits) */
for (length = sinf_read_bits(d, 7, 11); length; --length) for (length = sinf_read_bits(ctx, 7, 11); length; --length)
{ {
lengths[num++] = 0; lengths[num++] = 0;
} }
@ -302,11 +303,11 @@ static void sinf_decode_trees(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
* ----------------------------- */ * ----------------------------- */
/* given a stream and two trees, inflate a block of data */ /* given a stream and two trees, inflate a block of data */
static int sinf_inflate_block_data(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt) static int sinf_inflate_block_data(SINF_CTX *ctx, SINF_TREE *lt, SINF_TREE *dt)
{ {
while (1) while (1)
{ {
int sym = sinf_decode_symbol(d, lt); int sym = sinf_decode_symbol(ctx, lt);
/* check for end of block */ /* check for end of block */
if (sym == 256) if (sym == 256)
@ -316,7 +317,7 @@ static int sinf_inflate_block_data(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
if (sym < 256) if (sym < 256)
{ {
sinf_write(d, sym); sinf_write(ctx, sym);
} else { } else {
uint32_t length, offs, i; uint32_t length, offs, i;
@ -325,68 +326,68 @@ static int sinf_inflate_block_data(SINF_DATA *d, SINF_TREE *lt, SINF_TREE *dt)
sym -= 257; sym -= 257;
/* possibly get more bits from length code */ /* possibly get more bits from length code */
length = sinf_read_bits(d, SINF_LENGTH_BITS[sym], SINF_LENGTH_BASE[sym]); length = sinf_read_bits(ctx, SINF_LENGTH_BITS[sym], SINF_LENGTH_BASE[sym]);
dist = sinf_decode_symbol(d, dt); dist = sinf_decode_symbol(ctx, dt);
/* possibly get more bits from distance code */ /* possibly get more bits from distance code */
offs = sinf_read_bits(d, SINF_DIST_BITS[dist], SINF_DIST_BASE[dist]); offs = sinf_read_bits(ctx, SINF_DIST_BITS[dist], SINF_DIST_BASE[dist]);
/* copy match */ /* copy match */
for (i = 0; i < length; ++i) for (i = 0; i < length; ++i)
{ {
sinf_write(d, d->cbuf[(d->cbufi + (1 << SINF_WBITS) - offs) % (1 << SINF_WBITS)]); sinf_write(ctx, ctx->cbuf[(ctx->cbufi + (1 << SINF_WBITS) - offs) % (1 << SINF_WBITS)]);
} }
} }
} }
} }
/* inflate an uncompressed block of data */ /* inflate an uncompressed block of data */
static int sinf_inflate_uncompressed_block(SINF_DATA *d) static int sinf_inflate_uncompressed_block(SINF_CTX *ctx)
{ {
uint32_t length, invlength; uint32_t length, invlength;
uint32_t i; uint32_t i;
/* get length */ /* get length */
length = d->source[1]; length = ctx->source[1];
length = 256*length + d->source[0]; length = 256*length + ctx->source[0];
/* get one's complement of length */ /* get one's complement of length */
invlength = d->source[3]; invlength = ctx->source[3];
invlength = 256*invlength + d->source[2]; invlength = 256*invlength + ctx->source[2];
/* check length */ /* check length */
if (length != (~invlength & 0x0000ffff)) return SINF_ERROR; if (length != (~invlength & 0x0000ffff)) return SINF_ERROR;
d->source += 4; ctx->source += 4;
/* copy block */ /* copy block */
for (i = length; i; --i) sinf_write(d, *d->source++); for (i = length; i; --i) sinf_write(ctx, *ctx->source++);
/* make sure we start next block on a byte boundary */ /* make sure we start next block on a byte boundary */
d->bitcount = 0; ctx->bitcount = 0;
return SINF_OK; return SINF_OK;
} }
/* inflate a block of data compressed with fixed huffman trees */ /* inflate a block of data compressed with fixed huffman trees */
static int sinf_inflate_fixed_block(SINF_DATA *d) static int sinf_inflate_fixed_block(SINF_CTX *ctx)
{ {
/* build fixed huffman trees */ /* build fixed huffman trees */
sinf_build_fixed_trees(&d->ltree, &d->dtree); sinf_build_fixed_trees(&ctx->ltree, &ctx->dtree);
/* decode block using fixed trees */ /* decode block using fixed trees */
return sinf_inflate_block_data(d, &d->ltree, &d->dtree); return sinf_inflate_block_data(ctx, &ctx->ltree, &ctx->dtree);
} }
/* inflate a block of data compressed with dynamic huffman trees */ /* inflate a block of data compressed with dynamic huffman trees */
static int sinf_inflate_dynamic_block(SINF_DATA *d) static int sinf_inflate_dynamic_block(SINF_CTX *ctx)
{ {
/* decode trees from stream */ /* decode trees from stream */
sinf_decode_trees(d, &d->ltree, &d->dtree); sinf_decode_trees(ctx, &ctx->ltree, &ctx->dtree);
/* decode block using decoded trees */ /* decode block using decoded trees */
return sinf_inflate_block_data(d, &d->ltree, &d->dtree); return sinf_inflate_block_data(ctx, &ctx->ltree, &ctx->dtree);
} }
/* ---------------------- * /* ---------------------- *
@ -394,18 +395,19 @@ static int sinf_inflate_dynamic_block(SINF_DATA *d)
* ---------------------- */ * ---------------------- */
/* inflate stream from source */ /* inflate stream from source */
int sinf_inflate(const uint8_t *data, void (*write_callback)(uint8_t byte, uint32_t pos, void *userdata), void *userdata) int sinf_inflate(const uint8_t *data, uint32_t datalen, void (*write_callback)(uint8_t byte, uint32_t pos, void *userdata), void *userdata)
{ {
SINF_DATA d; SINF_CTX ctx;
int bfinal; int bfinal;
/* initialise data */ /* initialise data */
d.bitcount = 0; ctx.bitcount = 0;
d.cbufi = 0; ctx.cbufi = 0;
d.source = data; ctx.source = data;
d.write = write_callback; ctx.sourcelen = datalen;
d.userdata = userdata; ctx.write = write_callback;
d.written = 0; ctx.userdata = userdata;
ctx.written = 0;
do { do {
@ -413,25 +415,25 @@ int sinf_inflate(const uint8_t *data, void (*write_callback)(uint8_t byte, uint3
int res; int res;
/* read final block flag */ /* read final block flag */
bfinal = sinf_getbit(&d); bfinal = sinf_getbit(&ctx);
/* read block type (2 bits) */ /* read block type (2 bits) */
btype = sinf_read_bits(&d, 2, 0); btype = sinf_read_bits(&ctx, 2, 0);
/* decompress block */ /* decompress block */
switch (btype) switch (btype)
{ {
case 0: case 0:
/* decompress uncompressed block */ /* decompress uncompressed block */
res = sinf_inflate_uncompressed_block(&d); res = sinf_inflate_uncompressed_block(&ctx);
break; break;
case 1: case 1:
/* decompress block with fixed huffman trees */ /* decompress block with fixed huffman trees */
res = sinf_inflate_fixed_block(&d); res = sinf_inflate_fixed_block(&ctx);
break; break;
case 2: case 2:
/* decompress block with dynamic huffman trees */ /* decompress block with dynamic huffman trees */
res = sinf_inflate_dynamic_block(&d); res = sinf_inflate_dynamic_block(&ctx);
break; break;
default: default:
return SINF_ERROR; return SINF_ERROR;

2
extmod/modtrezorui/inflate.h
View File

@ -3,6 +3,6 @@
#include <stdint.h> #include <stdint.h>
int sinf_inflate(const uint8_t *data, void (*write_callback)(uint8_t byte, uint32_t pos, void *userdata), void *userdata); int sinf_inflate(const uint8_t *data, uint32_t datalen, void (*write_callback)(uint8_t byte, uint32_t pos, void *userdata), void *userdata);
#endif #endif

4
extmod/modtrezorui/modtrezorui-display.h
View File

@ -244,9 +244,9 @@ STATIC mp_obj_t mod_TrezorUi_Display_loader(size_t n_args, const mp_obj_t *args)
} else { } else {
iconfgcolor = ~bgcolor; // invert iconfgcolor = ~bgcolor; // invert
} }
display_loader(progress, fgcolor, bgcolor, data, iconfgcolor); display_loader(progress, fgcolor, bgcolor, icon.buf, icon.len, iconfgcolor);
} else { } else {
display_loader(progress, fgcolor, bgcolor, NULL, 0); display_loader(progress, fgcolor, bgcolor, NULL, 0, 0);
} }
return mp_const_none; return mp_const_none;
} }