6502/lzsa
1
0
Fork 0
mirror of https://github.com/emmanuel-marty/lzsa.git synced 2024-12-29 00:31:54 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2 from emmanuel-marty/master

Browse Source 
Merge pull request
This commit is contained in:
Doug Masten 2020-06-26 17:08:44 -05:00 committed by GitHub
commit e8b2ebb89f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 57 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -71,10 +71,11 @@ License:
8-bit assembly code:
* Z80 decompressors (size- and speed-optimized) written by [introspec](https://github.com/specke)
* Z80 decompressors (size- and speed-optimized) written by [introspec](https://github.com/specke) with optimizations by [uniabis](https://github.com/uniabis)
* 6502 and 8088 size-optimized improvements by [Peter Ferrie](https://github.com/peterferrie)
* 6502 speed-optimized decompressor by [John Brandwood](https://github.com/jbrandwood)
* 8088 speed-optimized decompressor by [Jim Leonard](https://github.com/mobygamer)
* 6809 decompressors (for the Tandy CoCo, Thomson MO5/MO6/TO7/TO8/TO9, Dragon 32/64..)
* 6809 decompressors (Tandy CoCo, Thomson MO/TO, Dragon 32/64..) optimized by [Doug Masten](https://github.com/dougmasten)
External links:

89
asm/6809/unlzsa1.s
View File

@ -1,4 +1,4 @@
; unlzsa1.s - 6809 decompression routine for raw LZSA1 - 117 bytes
; unlzsa1.s - 6809 decompression routine for raw LZSA1 - 111 bytes
; compress with lzsa -r <original_file> <compressed_file>
;
; in: x = start of compressed data
@ -23,7 +23,45 @@
; misrepresented as being the original software.
; 3. This notice may not be removed or altered from any source distribution.
decompress_lzsa1
decompress_lzsa1 equ lz1token
lz1bigof ldb ,x+ ; O set: load long 16 bit (negative, signed) offset
lda ,x+ ; (little endian)
lz1gotof leau d,y ; put backreference start address in U (dst+offset)
puls b ; restore token
clra ; clear A (high part of match length)
andb #$0F ; isolate MMMM (embedded match length)
addb #$03 ; add MIN_MATCH_SIZE
cmpb #$12 ; MATCH_RUN_LEN?
bne lz1gotln ; no, we have the full match length, go copy
addb ,x+ ; add extra match length byte + MIN_MATCH_SIZE + MATCH_RUN_LEN
bcc lz1gotln ; if no overflow, we have the full length
bne lz1midln
ldb ,x+ ; load 16-bit len in D (low part in B, high in A)
lda ,x+ ; (little endian)
bne lz1gotln ; check if we hit EOD (16-bit length = 0)
tstb
bne lz1gotln ; go copy matched bytes if not
rts ; done, bail
lz1midln tfr b,a ; copy high part of len into A
ldb ,x+ ; grab low 8 bits of len in B
lz1gotln pshs x ; save source compressed data pointer
tfr d,x ; copy match length to X
lz1cpymt lda ,u+ ; copy matched byte
sta ,y+
leax -1,x ; decrement X
bne lz1cpymt ; loop until all matched bytes are copied
puls x ; restore source compressed data pointer
lz1token ldb ,x+ ; load next token into B: O|LLL|MMMM
pshs b ; save it
@ -50,59 +88,18 @@ lz1declt lsrb ; shift literals count into place
lsrb
lsrb
lsrb
lz1gotlt tfr x,u
tfr d,x ; transfer 16-bit count into X
lz1cpylt lda ,u+ ; copy literal byte
sta ,y+
sta ,y+
leax -1,x ; decrement X and update Z flag
bne lz1cpylt ; loop until all literal bytes are copied
tfr u,x
lz1nolt ldb ,s ; get token again, don't pop it from the stack
tstb ; test O bit (small or large offset)
bmi lz1bigof
bmi lz1bigof ; test O bit (small or large offset)
ldb ,x+ ; O clear: load 8 bit (negative, signed) offset
lda #$ff ; set high 8 bits
bra lz1gotof
lz1bigof ldb ,x+ ; O set: load long 16 bit (negative, signed) offset
lda ,x+ ; (little endian)
lz1gotof leau d,y ; put backreference start address in U (dst+offset)
puls b ; restore token
clra ; clear A (high part of match length)
andb #$0F ; isolate MMMM (embedded match length)
addb #$03 ; add MIN_MATCH_SIZE
cmpb #$12 ; MATCH_RUN_LEN?
bne lz1gotln ; no, we have the full match length, go copy
ldb ,x+ ; grab extra match length byte
addb #$12 ; add MIN_MATCH_SIZE + MATCH_RUN_LEN
bcc lz1gotln ; if no overflow, we have the full length
bne lz1midln
ldb ,x+ ; load 16-bit len in D (low part in B, high in A)
lda ,x+ ; (little endian)
bne lz1gotln ; check if we hit EOD (16-bit length = 0)
tstb
bne lz1gotln ; go copy matched bytes if not
rts ; done, bail
lz1midln tfr b,a ; copy high part of len into A
ldb ,x+ ; grab low 8 bits of len in B
lz1gotln pshs x ; save source compressed data pointer
tfr d,x ; copy match length to X
lz1cpymt lda ,u+ ; copy matched byte
sta ,y+
leax -1,x ; decrement X
bne lz1cpymt ; loop until all matched bytes are copied
puls x ; restore source compressed data pointer
bra lz1token ; go decode next token

9
asm/6809/unlzsa1b.s
View File

@ -1,4 +1,4 @@
; unlzsa1b.s - 6809 backward decompression routine for raw LZSA1 - 116 bytes
; unlzsa1b.s - 6809 backward decompression routine for raw LZSA1 - 112 bytes
; compress with lzsa -r -b <original_file> <compressed_file>
;
; in: x = last byte of compressed data
@ -62,9 +62,7 @@ lz1cpylt lda ,-u ; copy literal byte
tfr u,x
lz1nolt ldb ,s ; get token again, don't pop it from the stack
tstb ; test O bit (small or large offset)
bmi lz1bigof
bmi lz1bigof ; test O bit (small or large offset)
ldb ,-x ; O clear: load 8 bit (negative, signed) offset
lda #$ff ; set high 8 bits
@ -84,8 +82,7 @@ lz1gotof nega ; reverse sign of offset in D
cmpb #$12 ; MATCH_RUN_LEN?
bne lz1gotln ; no, we have the full match length, go copy
ldb ,-x ; grab extra match length byte
addb #$12 ; add MIN_MATCH_SIZE + MATCH_RUN_LEN
addb ,-x ; add extra match length byte + MIN_MATCH_SIZE + MATCH_RUN_LEN
bcc lz1gotln ; if no overflow, we have the full length
bne lz1midln

5
asm/6809/unlzsa2.s
View File

@ -1,4 +1,4 @@
; unlzsa2.s - 6809 decompression routine for raw LZSA2 - 187 bytes
; unlzsa2.s - 6809 decompression routine for raw LZSA2 - 183 bytes
; compress with lzsa -f2 -r <original_file> <compressed_file>
;
; in: x = start of compressed data
@ -40,8 +40,7 @@ lz2token ldb ,x+ ; load next token into B: XYZ|LL|MMM
cmpb #$12 ; LITERALS_RUN_LEN_V2 + 15 ?
bne lz2gotlt ; if not, we have the full literals count, go copy
ldb ,x+ ; load extra literals count byte
addb #$12 ; add LITERALS_RUN_LEN + 15
addb ,x+ ; add extra literals count byte + LITERALS_RUN_LEN + 15
bcc lz2gotlt ; if no overflow, we got the complete count, copy
ldb ,x+ ; load low 8 bits of little-endian literals count

5
asm/6809/unlzsa2b.s
View File

@ -1,4 +1,4 @@
; unlzsa2.s - 6809 backward decompression routine for raw LZSA2 - 189 bytes
; unlzsa2b.s - 6809 backward decompression routine for raw LZSA2 - 187 bytes
; compress with lzsa -f2 -r -b <original_file> <compressed_file>
;
; in: x = last byte of compressed data
@ -42,8 +42,7 @@ lz2token ldb ,-x ; load next token into B: XYZ|LL|MMM
cmpb #$12 ; LITERALS_RUN_LEN_V2 + 15 ?
bne lz2gotlt ; if not, we have the full literals count, go copy
ldb ,-x ; load extra literals count byte
addb #$12 ; add LITERALS_RUN_LEN + 15
addb ,-x ; add extra literals count byte + LITERALS_RUN_LEN + 15
bcc lz2gotlt ; if no overflow, we got the complete count, copy
ldd ,--x ; load 16 bit count in D (low part in B, high in A)

2
src/lzsa.c
View File

@ -48,7 +48,7 @@
#define OPT_RAW_BACKWARD 8
#define OPT_STATS 16
#define TOOL_VERSION "1.2.2"
#define TOOL_VERSION "1.3.0"
/*---------------------------------------------------------------------------*/

9
src/shrink_block_v2.c
View File

@ -1048,7 +1048,7 @@ static int lzsa_write_block_v2(lzsa_compressor *pCompressor, lzsa_match *pBestMa
return -1;
if (pCompressor->flags & LZSA_FLAG_RAW_BLOCK)
pOutData[nOutOffset++] = (nTokenLiteralsLen << 3) | 0x47;
pOutData[nOutOffset++] = (nTokenLiteralsLen << 3) | 0xe7;
else
pOutData[nOutOffset++] = (nTokenLiteralsLen << 3) | 0x00;
nOutOffset = lzsa_write_literals_varlen_v2(pOutData, nOutOffset, nMaxOutDataSize, &nCurNibbleOffset, &nCurFreeNibbles, nNumLiterals);
@ -1081,7 +1081,6 @@ static int lzsa_write_block_v2(lzsa_compressor *pCompressor, lzsa_match *pBestMa
if (nOutOffset >= nMaxOutDataSize)
return -1;
pOutData[nOutOffset++] = 0; /* Match offset */
nOutOffset = lzsa_write_nibble_v2(pOutData, nOutOffset, nMaxOutDataSize, &nCurNibbleOffset, &nCurFreeNibbles, 15); /* Extended match length nibble */
if (nOutOffset < 0) return -1;
@ -1119,12 +1118,12 @@ static int lzsa_write_raw_uncompressed_block_v2(lzsa_compressor *pCompressor, co
int nTokenLiteralsLen = (nNumLiterals >= LITERALS_RUN_LEN_V2) ? LITERALS_RUN_LEN_V2 : nNumLiterals;
int nOutOffset = 0;
int nCommandSize = 8 /* token */ + lzsa_get_literals_varlen_size_v2(nNumLiterals) + (nNumLiterals << 3) + 8 + 4 + 8;
int nCommandSize = 8 /* token */ + lzsa_get_literals_varlen_size_v2(nNumLiterals) + (nNumLiterals << 3) + 4 + 8;
if ((nOutOffset + ((nCommandSize + 7) >> 3)) > nMaxOutDataSize)
return -1;
pCompressor->num_commands = 0;
pOutData[nOutOffset++] = (nTokenLiteralsLen << 3) | 0x47;
pOutData[nOutOffset++] = (nTokenLiteralsLen << 3) | 0xe7;
nOutOffset = lzsa_write_literals_varlen_v2(pOutData, nOutOffset, nMaxOutDataSize, &nCurNibbleOffset, &nCurFreeNibbles, nNumLiterals);
if (nOutOffset < 0) return -1;
@ -1137,8 +1136,6 @@ static int lzsa_write_raw_uncompressed_block_v2(lzsa_compressor *pCompressor, co
/* Emit EOD marker for raw block */
pOutData[nOutOffset++] = 0; /* Match offset */
nOutOffset = lzsa_write_nibble_v2(pOutData, nOutOffset, nMaxOutDataSize, &nCurNibbleOffset, &nCurFreeNibbles, 15); /* Extended match length nibble */
if (nOutOffset < 0) return -1;