diff --git a/asm/6809/unlzsa2.s b/asm/6809/unlzsa2.s new file mode 100644 index 0000000..9c2d2e9 --- /dev/null +++ b/asm/6809/unlzsa2.s @@ -0,0 +1,167 @@ +; unlzsa2.s - 6809 decompression routine for raw LZSA2 - 198 bytes +; compress with lzsa -f2 -r +; +; in: x = start of compressed data +; y = start of decompression buffer +; out: y = end of decompression buffer + 1 +; +; Copyright (C) 2020 Emmanuel Marty +; +; 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 this software. +; +; Permission is granted to anyone to use this software for any purpose, +; including commercial applications, and to alter it and redistribute it +; freely, subject to the following restrictions: +; +; 1. The origin of this software must not be misrepresented; you must not +; claim that you wrote the original software. If you use this software +; in a product, an acknowledgment in the product documentation would be +; appreciated but is not required. +; 2. Altered source versions must be plainly marked as such, and must not be +; misrepresented as being the original software. +; 3. This notice may not be removed or altered from any source distribution. + +decompress_lzsa2 + ldb #$00 + stb lz2nibct ; clear nibble available flag + +lz2token ldb ,x+ ; load next token into B: XYZ|LL|MMM + pshs b ; save it + + lda #$00 ; clear A (high part of literals count) + andb #$18 ; isolate LLL (embedded literals count) in B + beq lz2nolt ; skip if no literals + cmpb #$18 ; LITERALS_RUN_LEN_V2? + bne lz2declt ; if not, we have the complete count, go unshift + + bsr lz2nibbl ; get extra literals length nibble in B + addb #$03 ; add LITERALS_RUN_LEN_V2 + 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 + bcc lz2gotlt ; if no overflow, we got the complete count, copy + + ldb ,x+ ; load low 8 bits of little-endian literals count + lda ,x+ ; load high 8 bits of literal count + bra lz2gotlt ; we now have the complete count, go copy + +lz2declt lsrb ; shift literals count into place + lsrb + lsrb + +lz2gotlt tfr x,u + tfr d,x ; transfer 16-bit count into X +lz2cpylt lda ,u+ ; copy literal byte + sta ,y+ + leax -1,x ; decrement X and update Z flag + bne lz2cpylt ; loop until all literal bytes are copied + tfr u,x + +lz2nolt puls b ; restore token + pshs b ; save it again + + lslb ; push token's X flag bit into carry + bcs lz2replg ; if token's X bit is set, rep or large offset + + lda #$00 ; clear A (to prepare for high 8 bits of offset) + + lslb ; push token's Y flag bit into carry + bcs lz2offs9 ; if token's Y bit is set, 9 bits offset + + lslb ; push token's Z flag bit into carry + rola ; shift Z flag from carry into bit 0 of A + eora #$e1 ; set bits 5-7 of offset, reverse bit 0 + sta lz2val5+1 + bsr lz2nibbl ; get offset nibble in B + lslb ; nibble represents offset bits 1..4 +lz2val5 orb #$aa ; merge offset bit 0 from A + lda #$ff ; set bits 8-15 of offset + bra lz2gotof + +lz2offs9 lslb ; push token's Z flag bit into carry + rola ; shift Z flag from carry into bit 0 of A + eora #$ff ; set bits 9-15 of offset, reverse bit 8 + + ldb ,x+ ; load low 8 bits of (negative, signed) offset + bra lz2gotof + +lz2nibbl ldb #$aa + lsr lz2nibct ; nibble ready? + bcs lz2gotnb + + inc lz2nibct ; flag nibble as ready for next time + ldb ,x+ ; load two nibbles + stb lz2nibbl+1 ; store nibble for next time (low 4 bits) + + lsrb ; shift 4 high bits of nibble down + lsrb + lsrb + lsrb + +lz2gotnb andb #$0f ; only keep low 4 bits +lz2done rts + +lz2replg lslb ; push token's Y flag bit into carry + bcs lz2rep16 ; if token's Y bit is set, rep or 16 bit offset + + lda #$00 ; clear A + lslb ; push token's Z flag bit into carry + rola ; shift Z flag from carry into bit 0 of A + eora #$e1 ; set bits 13-15 of offset, reverse bit 8 + + bsr lz2nibbl ; get offset nibble in B + lslb ; nibble represents offset bits 9..12 + stb lz2val13+1 +lz2val13 ora #$aa ; merge offset bits 9..12 from B + suba #$02 ; substract 512 from offset + + ldb ,x+ ; load low 8 bits of (negative, signed) offset + bra lz2gotof + +lz2rep16 bmi lz2repof ; if token's Z flag bit is set, rep match + + ldd ,x++ ; load high then low 8 bits of offset + +lz2gotof std lz2repof+1 ; store match offset + +lz2repof ldd #$aaaa ; load match offset + leau d,y ; put backreference start address in U (dst+offset) + + puls b ; restore token + + lda #$00 ; clear A (high part of match length) + andb #$07 ; isolate MMM (embedded match length) + addb #$02 ; add MIN_MATCH_SIZE_V2 + cmpb #$09 ; MIN_MATCH_SIZE_V2 + MATCH_RUN_LEN_V2? + bne lz2gotln ; no, we have the full match length, go copy + + bsr lz2nibbl ; get offset nibble in B + addb #$09 ; add MIN_MATCH_SIZE_V2 + MATCH_RUN_LEN_V2 + cmpb #$18 ; MIN_MATCH_SIZE_V2 + MATCH_RUN_LEN_V2 + 15? + bne lz2gotln ; if not, we have the full match length, go copy + + ldb ,x+ ; load extra length byte + addb #$18 ; add MIN_MATCH_SIZE_V2 + MATCH_RUN_LEN_V2 + 15 + bcc lz2gotln ; if no overflow, we have the full length + beq lz2done ; detect EOD code + + ldb ,x+ ; load 16-bit len in D (low part in B, high in A) + lda ,x+ ; (little endian) + +lz2gotln pshs x ; save source compressed data pointer + tfr d,x ; copy match length to X + +lz2cpymt lda ,u+ ; copy matched byte + sta ,y+ + leax -1,x ; decrement X + bne lz2cpymt ; loop until all matched bytes are copied + + puls x ; restore source compressed data pointer + jmp lz2token ; go decode next token + +lz2nibct rmb 1 ; nibble ready flag +