Log inRegister an accountBrowse CSDbHelp & documentationFacts & StatisticsThe forumsAvailable RSS-feeds on CSDbSupport CSDb Commodore 64 Scene Database
You are not logged in 
CSDb User Forums


Forums > CSDb Entries > Release id #198340 : Exomizer V3.1.0
2020-12-23 20:10
Jammer

Registered: Nov 2002
Posts: 1018
Release id #198340 : Exomizer V3.1.0

Has anyone got any reasonable kickass source of mem decruncher compatible with Exomizer 3.x? I've got only this and have to compress files with Exomizer 2.x compatibility mode:

//
// Copyright (c) 2002 - 2005 Magnus Lind.
//
// 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 distribution.
//
//   4. The names of this software and/or it's copyright holders may not be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// -------------------------------------------------------------------
// The decruncher jsr:s to the get_crunched_byte address when it wants to
// read a crunched byte. This subroutine has to preserve x and y register
// and must not modify the state of the carry flag.
// -------------------------------------------------------------------
// not needed for kickass... just defined it in client code as
// .var get_crunched_byte = get_crunched_byte_custom 
// where get_crunched_byte_custom is your routine
// -------------------------------------------------------------------
// .import get_crunched_byte  
// -------------------------------------------------------------------
// this function is the heart of the decruncher.
// It initializes the decruncher zeropage locations and precalculates the
// decrunch tables and decrunches the data
// This function will not change the interrupt status bit and it will not
// modify the memory configuration.
// -------------------------------------------------------------------
// Not needed for kickass
// .export decrunch

// -------------------------------------------------------------------
// if literal sequences is not used (the data was crunched with the -c
// flag) then the following line can be uncommented for shorter code.
// #define LITERAL_SEQUENCES_NOT_USED

//.var get_crunched_byte = get_crunched_byte_custom 

// -------------------------------------------------------------------
// zero page addresses used
// -------------------------------------------------------------------
.var zp_len_lo = exomizerzp

.var zp_src_lo  = zp_len_lo + 1
.var zp_src_hi  = zp_src_lo + 1

.var zp_bits_hi = zp_src_hi + 1

.var zp_bitbuf  = zp_bits_hi + 1
.var zp_dest_lo = zp_bitbuf + 1	// dest addr lo
.var zp_dest_hi = zp_dest_lo + 1	// dest addr hi

.var tabl_bi = decrunch_table
.var tabl_lo = decrunch_table + 52
.var tabl_hi = decrunch_table + 104

// -------------------------------------------------------------------
// no code below this comment has to be modified in order to generate
// a working decruncher of this source file.
// However, you may want to relocate the tables last in the file to a
// more suitable address.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// jsr this label to decrunch, it will in turn init the tables and
// call the decruncher
// no constraints on register content, however the
// decimal flag has to be #0 (it almost always is, otherwise do a cld)
decrunch:
// -------------------------------------------------------------------
// init zeropage, x and y regs. (12 bytes)
//
				ldy #0
				ldx #3
init_zp:
				jsr get_crunched_byte
				sta zp_bitbuf - 1,x
				dex
				bne init_zp
// -------------------------------------------------------------------
// calculate tables (50 bytes)
// x and y must be #0 when entering
//
nextone:
				inx
				tya
				and #$0f
				beq shortcut		// starta pĺ ny sekvens

				txa			// this clears reg a
				lsr 			// and sets the carry flag
				ldx tabl_bi-1,y
rolle:
				rol 
				rol zp_bits_hi
				dex
				bpl rolle		// c = 0 after this (rol zp_bits_hi)

				adc tabl_lo-1,y
				tax

				lda zp_bits_hi
				adc tabl_hi-1,y
shortcut:
				sta tabl_hi,y
				txa
				sta tabl_lo,y

				ldx #4
				jsr get_bits		// clears x-reg.
				sta tabl_bi,y
				iny
				cpy #52
				bne nextone
				ldy #0
				beq begin
// -------------------------------------------------------------------
// get bits (29 bytes)
//
// args:
//   x = number of bits to get
// returns:
//   a = #bits_lo
//   x = #0
//   c = 0
//   z = 1
//   zp_bits_hi = #bits_hi
// notes:
//   y is untouched
// -------------------------------------------------------------------
get_bits:
				lda #$00
				sta zp_bits_hi
				cpx #$01
				bcc bits_done
bits_next:
				lsr zp_bitbuf
				bne ok
				pha
literal_get_byte:
				jsr get_crunched_byte
				bcc literal_byte_gotten
				ror 
				sta zp_bitbuf
				pla
ok:
				rol 
				rol zp_bits_hi
				dex
				bne bits_next
bits_done:
				rts
// -------------------------------------------------------------------
// main copy loop (18(16) bytes)
//
copy_next_hi:
				dex
				dec zp_dest_hi
				dec zp_src_hi
copy_next:
				dey
#if !LITERAL_SEQUENCES_NOT_USED
				bcc literal_get_byte
#endif
				lda (zp_src_lo),y
literal_byte_gotten:
				sta (zp_dest_lo),y
copy_start:
				tya
				bne copy_next
begin:
				txa
				bne copy_next_hi
// -------------------------------------------------------------------
// decruncher entry point, needs calculated tables (21(13) bytes)
// x and y must be #0 when entering
//
#if !LITERAL_SEQUENCES_NOT_USED
				inx
				jsr get_bits
				tay
				bne literal_start1
#else
				dey
#endif
begin2:
				inx
				jsr bits_next
				lsr 
				iny
				bcc begin2
#if LITERAL_SEQUENCES_NOT_USED
				beq literal_start
#endif
				cpy #$11
#if !LITERAL_SEQUENCES_NOT_USED
				bcc sequence_start
				beq bits_done
// -------------------------------------------------------------------
// literal sequence handling (13(2) bytes)
//
				ldx #$10
				jsr get_bits
literal_start1:
				sta <zp_len_lo
				ldx <zp_bits_hi
				ldy #0
				bcc literal_start
sequence_start:
#else
				bcs bits_done
#endif
// -------------------------------------------------------------------
// calulate length of sequence (zp_len) (11 bytes)
//
				ldx tabl_bi - 1,y
				jsr get_bits
				adc tabl_lo - 1,y	// we have now calculated zp_len_lo
				sta zp_len_lo
// -------------------------------------------------------------------
// now do the hibyte of the sequence length calculation (6 bytes)
				lda zp_bits_hi
				adc tabl_hi - 1,y	// c = 0 after this.
				pha
// -------------------------------------------------------------------
// here we decide what offset table to use (20 bytes)
// x is 0 here
//
				bne nots123
				ldy zp_len_lo
				cpy #$04
				bcc size123
nots123:
				ldy #$03
size123:
				ldx tabl_bit - 1,y
				jsr get_bits
				adc tabl_off - 1,y	// c = 0 after this.
				tay			// 1 <= y <= 52 here
// -------------------------------------------------------------------
// Here we do the dest_lo -= len_lo subtraction to prepare zp_dest
// but we do it backwards:	a - b == (b - a - 1) ^ ~0 (C-syntax)
// (16(16) bytes)
				lda zp_len_lo
literal_start:			// literal enters here with y = 0, c = 1
				sbc zp_dest_lo
				bcc noborrow
				dec zp_dest_hi
noborrow:
				eor #$ff
				sta zp_dest_lo
				cpy #$01		// y < 1 then literal
#if !LITERAL_SEQUENCES_NOT_USED
				bcc pre_copy
#else
				bcc literal_get_byte
#endif
// -------------------------------------------------------------------
// calulate absolute offset (zp_src) (27 bytes)
//
				ldx tabl_bi,y
				jsr get_bits//
				adc tabl_lo,y
				bcc skipcarry
				inc zp_bits_hi
				clc
skipcarry:
				adc zp_dest_lo
				sta zp_src_lo
				lda zp_bits_hi
				adc tabl_hi,y
				adc zp_dest_hi
				sta zp_src_hi
// -------------------------------------------------------------------
// prepare for copy loop (8(6) bytes)
//
				pla
				tax
#if !LITERAL_SEQUENCES_NOT_USED
				sec
pre_copy:
				ldy <zp_len_lo
				jmp copy_start
#else
				ldy <zp_len_lo
				bcc copy_start
#endif

get_crunched_byte:
    lda srcptr
    bne !+
    dec srcptr + 1
!:
    dec srcptr
    lda srcptr:$ffff
    rts
	
// -------------------------------------------------------------------
// two small static tables (6(6) bytes)
//
tabl_bit:
				.byte 2,4,4
tabl_off:
				.byte 48,32,16
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// this 156 byte table area may be relocated. It may also be clobbered
// by other data between decrunches.
// -------------------------------------------------------------------
decrunch_table:
				.fill 156,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------
 
... 5 posts hidden. Click here to view all posts....
 
2020-12-24 01:32
Krill

Registered: Apr 2002
Posts: 1733
Quoting Jammer
Alas, sources included in Exomizer 3 turned out to be a little above my abilities to make it kickass :D
Well, old XY problem question. Do you really need to have library stuff in your preferred assembler's syntax? Could be good enough for now to just integrate one of the supported assemblers in your build toolchain to spit out decrunch.prg now and then that you can .incbin in your sources.

Pretty much what you'd do with SID tunes as well. Or loaders, for that matter. =)
2020-12-24 11:14
Groepaz

Registered: Dec 2001
Posts: 9710
back to linking binary blobs? why not :)
2020-12-24 12:13
Krill

Registered: Apr 2002
Posts: 1733
Quoting Groepaz
back to linking binary blobs? why not :)
Less of a binary blob than linking any regular tune.prg. Would be part of the build toolchain, after all, with the small decruncher snippet just happening to be built by another assembler. Basically a pedestrian way of .o linkage otherwise done by object linkers. =)
2020-12-24 13:32
Jammer

Registered: Nov 2002
Posts: 1018
As I said, I needed to modify variables slightly. Not the most pleasant task with binary :D
2020-12-24 13:57
Krill

Registered: Apr 2002
Posts: 1733
Quoting Jammer
As I said, I needed to modify variables slightly. Not the most pleasant task with binary :D
You are perfectly capable of changing variables in the source, even if slightly different format than your preferred assembler's, no?
2020-12-30 14:09
Jammer

Registered: Nov 2002
Posts: 1018
Quoting Krill
You are perfectly capable of changing variables in the source, even if slightly different format than your preferred assembler's, no?

This thread wouldn't be a thing then :( Sometimes assembler's notation and project's layout/crossreferencing confuse me a lot. That's when I usually give up or reinvent the wheel :/
2020-12-30 14:52
Groepaz

Registered: Dec 2001
Posts: 9710
We need an assembler in GT2 notation then!
2020-12-30 19:48
CSixx

Registered: Jan 2013
Posts: 12
Here's a quick convert to Kick Assembler. Tested only briefly.
No "ENABLE_SPLIT_ENCODING" support.

assemble with " -symbolfile", then include symbols in your code.

Usage like this:
lda #<$6e0d
sta opbase+1
lda #>$6e0d
sta opbase+2
jsr exod_decrunch

//------------------------------------------------------------------------------ -------
// PROGRAM START
//------------------------------------------------------------------------------ -------
// -------------------------------------------------------------------
// this file is intended to be assembled with Kick Assembler.
// It has not been tested with any other assemblers or linkers.
// -------------------------------------------------------------------

.var DECRUNCH_FORWARDS = false

// -------------------------------------------------------------------
.pc = $3000 // <--- put wherever
      
// -------------------------------------------------------------------
exod_get_crunched_byte:
.if (!DECRUNCH_FORWARDS) {
        lda opbase+1
        bne _byte_skip_hi
        dec opbase+2
_byte_skip_hi:
        dec opbase+1
}

opbase:        lda $ffff               // needs to be set correctly before
.if (DECRUNCH_FORWARDS) {
        inc opbase+1
        bne _byte_skip_hi
        inc opbase+2
_byte_skip_hi:
}
        rts                     // decrunch_file is called.
// end_of_data needs to point to the address just after the address
// of the last byte of crunched data.
// -------------------------------------------------------------------

//
// Copyright (c) 2002 - 2019 Magnus Lind.
//
// 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 distribution.
//
//   4. The names of this software and/or it's copyright holders may not be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// -------------------------------------------------------------------
// Known quirks:
//  Can't handle a sequence reference that ends at $ffff. It is left in
//  since it is a corner case and fixing it impacts negatively on
//  performance or backwards compatibility.
//  A simple way to work around this is to not decrunch to address $ffff.
// -------------------------------------------------------------------
// Controls if the shared get_bits routines should be inlined or not.
//INLINE_GET_BITS=1
.var INLINE_GET_BITS = false

// -------------------------------------------------------------------
// if literal sequences is not used (the data was crunched with the -c
// flag) then the following line can be uncommented for shorter and.
// slightly faster code.
.var LITERAL_SEQUENCES_NOT_USED = false

// -------------------------------------------------------------------
// if the sequence length is limited to 256 (the data was crunched with
// the -M256 flag) then the following line can be uncommented for
// shorter and slightly faster code.
.var MAX_SEQUENCE_LENGTH_256 = false

// -------------------------------------------------------------------
// if the sequence length 3 has its own offset table (the data was
// crunched with the -P+16 flag) then the following
// line must be uncommented.
.var EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE = false

// -------------------------------------------------------------------
// if sequence offsets are not reused (the data was crunched with the
// -P-32 flag) then the following line must be uncommented. Uncommenting the
// line will also result in shorter and slightly faster code.
.var DONT_REUSE_OFFSET = false


// -------------------------------------------------------------------
// The decruncher jsr:s to the exod_get_crunched_byte address when it wants to
// read a crunched byte into A. This subroutine has to preserve X and Y
// register and must not modify the state of the carry nor the overflow flag.
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// The exod_decrunch function is the heart of the decruncher.
// It initializes the decruncher zeropage locations and precalculates the
// decrunch tables and decrunches the data
// This function will not change the interrupt status bit and it will not
// modify the memory configuration.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// zero page addresses used
// -------------------------------------------------------------------
.var exod_zp_len_lo = $9e
.var exod_zp_len_hi = $9f

.var exod_zp_src_lo  = $ae
.var exod_zp_src_hi  = exod_zp_src_lo + 1

.var exod_zp_bits_hi = $a7
.var exod_zp_ro_state = $a8



.var exod_zp_bitbuf  = $fd
.var exod_zp_dest_lo = exod_zp_bitbuf + 1      // dest addr lo
.var exod_zp_dest_hi = exod_zp_bitbuf + 2      // dest addr hi
.var encoded_entries = 52

//!zone exodecrunch
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
.eval encoded_entries = 68
} 

.var tabl_bi = exod_decrunch_table
.var tabl_lo = exod_decrunch_table + encoded_entries
.var tabl_hi = exod_decrunch_table + encoded_entries * 2

        //// refill bits is always inlined
.macro exod_mac_refill_bits() {
        pha
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        pla
}

.macro exod_mac_init_zp() {
// -------------------------------------------------------------------
// init zeropage and x reg. (8 bytes)
//
init_zp:
        jsr exod_get_crunched_byte
        sta exod_zp_bitbuf - 1,x
        dex
        bne init_zp
}

exod_get_bits:
        adc #$80                // needs c=0, affects v
        asl
        bpl !gb_skip+
!gb_next:
        asl exod_zp_bitbuf
        bne !gb_ok+
        :exod_mac_refill_bits()
!gb_ok:
        rol
        bmi !gb_next-
!gb_skip:
        bvs !gb_get_hi+
        rts
!gb_get_hi:
        sec
        sta exod_zp_bits_hi
        jmp exod_get_crunched_byte

// -------------------------------------------------------------------
// no code below this comment has to be modified in order to generate
// a working decruncher of this source file.
// However, you may want to relocate the tables last in the file to a
// more suitable address.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// jsr this label to decrunch, it will in turn init the tables and
// call the decruncher
// no constraints on register content, however the
// decimal flag has to be cleared (it almost always is, otherwise do a cld)
exod_decrunch:

        ldx #3
        :exod_mac_init_zp()

// -------------------------------------------------------------------
// calculate tables (64 bytes) + get_bits macro
// x and y must be #0 when entering
//
        ldy #0
        clc
table_gen:
        tax
        tya
        and #$0f
        sta tabl_lo,y
        beq !shortcut+            // start a new sequence
// -------------------------------------------------------------------
        txa
        adc tabl_lo - 1,y
        sta tabl_lo,y
        lda exod_zp_len_hi
        adc tabl_hi - 1,y
!shortcut:
        sta tabl_hi,y
// -------------------------------------------------------------------
        lda #$01
        sta <exod_zp_len_hi
        lda #$78                // %01111000
        jsr exod_get_bits
// -------------------------------------------------------------------
        lsr
        tax
        beq !rolled+
        php
!rolle:
        asl exod_zp_len_hi
        sec
        ror
        dex
        bne !rolle-
        plp
!rolled:
        ror
        sta tabl_bi,y
        bmi !no_fixup_lohi+
        lda exod_zp_len_hi
        stx exod_zp_len_hi
        .byte $24
!no_fixup_lohi:
        txa
// -------------------------------------------------------------------
        iny
        cpy #encoded_entries
        bne table_gen
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// prepare for main decruncher
.if (!DONT_REUSE_OFFSET) {
        ror exod_zp_ro_state
        sec
}
        ldy exod_zp_dest_lo
        stx exod_zp_dest_lo
        stx exod_zp_bits_hi
// -------------------------------------------------------------------
// copy one literal byte to destination (11 bytes)
//
literal_start1:
.if (!DECRUNCH_FORWARDS) {
        tya
        bne no_hi_decr
        dec exod_zp_dest_hi
.if (!DONT_REUSE_OFFSET) {
        dec exod_zp_src_hi
}
no_hi_decr:
        dey
}
        jsr exod_get_crunched_byte
        sta (exod_zp_dest_lo),y
.if (DECRUNCH_FORWARDS) {
        iny
        bne skip_hi_incr
        inc exod_zp_dest_hi
.if (!DONT_REUSE_OFFSET) {
        inc exod_zp_src_hi
}
skip_hi_incr:
}
// -------------------------------------------------------------------
// fetch sequence length index (15 bytes)
// x must be #0 when entering and contains the length index + 1
// when exiting or 0 for literal byte
next_round:
.if (!DONT_REUSE_OFFSET) {
        ror exod_zp_ro_state
}
        dex
        lda exod_zp_bitbuf
no_literal1:
        asl
        bne nofetch8
        jsr exod_get_crunched_byte
        rol
nofetch8:
        inx
        bcc no_literal1
        sta exod_zp_bitbuf
// -------------------------------------------------------------------
// check for literal byte (2 bytes)
//
        beq literal_start1
// -------------------------------------------------------------------
// check for decrunch done and literal sequences (4 bytes)
//
        cpx #$11
.if (INLINE_GET_BITS) {
        bcc skip_jmp
        jmp exit_or_lit_seq
skip_jmp:
} else {
        bcs exit_or_lit_seq
}
// -------------------------------------------------------------------
// calulate length of sequence (zp_len) (18(11) bytes) + get_bits macro
//
        lda tabl_bi - 1,x
        jsr exod_get_bits
        adc tabl_lo - 1,x       // we have now calculated zp_len_lo
        sta exod_zp_len_lo
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda exod_zp_bits_hi
        adc tabl_hi - 1,x       // c = 0 after this.
        sta exod_zp_len_hi
// -------------------------------------------------------------------
// here we decide what offset table to use (27(26) bytes) + get_bits_nc macro
// z-flag reflects zp_len_hi here
//
        ldx exod_zp_len_lo
} else {
        tax
}
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda #0
}
.if (!DONT_REUSE_OFFSET) {
// -------------------------------------------------------------------
// here we decide to reuse latest offset or not (13(15) bytes)
//
        bit <exod_zp_ro_state
        bmi test_reuse
}
no_reuse:
// -------------------------------------------------------------------
// here we decide what offset table to use (17(15) bytes)
//
.if (!MAX_SEQUENCE_LENGTH_256) {
        sta <exod_zp_bits_hi
}
        lda #$e1
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
        cpx #$04
} else {
        cpx #$03
}
        bcs gbnc2_next
        lda tabl_bit - 1,x
gbnc2_next:
        asl exod_zp_bitbuf
        bne gbnc2_ok
        tax
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        txa
gbnc2_ok:
        rol
        bcs gbnc2_next
        tax
// -------------------------------------------------------------------
// calulate absolute offset (zp_src) (17 bytes) + get_bits macro
//
        lda tabl_bi,x
        jsr exod_get_bits
.if (!DECRUNCH_FORWARDS) {
        adc tabl_lo,x
        sta exod_zp_src_lo
        lda exod_zp_bits_hi
        adc tabl_hi,x
        adc exod_zp_dest_hi
        sta exod_zp_src_hi
} else {
        clc
        adc tabl_lo,x
        eor #$ff
        sta exod_zp_src_lo
        lda exod_zp_bits_hi
        adc tabl_hi,x
        eor #$ff
        adc exod_zp_dest_hi
        sta exod_zp_src_hi
        clc
}
// -------------------------------------------------------------------
// prepare for copy loop (2 bytes)
//
        ldx exod_zp_len_lo
// -------------------------------------------------------------------
// main copy loop (30 bytes)
//
copy_next:
.if (!DECRUNCH_FORWARDS) {
        tya
        bne !copy_skip_hi+
        dec exod_zp_dest_hi
        dec exod_zp_src_hi
!copy_skip_hi:
        dey
}
.if (!LITERAL_SEQUENCES_NOT_USED) {
        bcs get_literal_byte
}
        lda (exod_zp_src_lo),y
literal_byte_gotten:
        sta (exod_zp_dest_lo),y
.if (DECRUNCH_FORWARDS) {
        iny
        bne !copy_skip_hi+
        inc exod_zp_dest_hi
        inc exod_zp_src_hi
!copy_skip_hi:
}
        dex
        bne copy_next
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda exod_zp_len_hi
.if (INLINE_GET_BITS) {
        bne copy_next_hi
}
}
        stx exod_zp_bits_hi
.if (!INLINE_GET_BITS) {
        beq next_round
} else {
        jmp next_round
}
copy_next_hi:
.if (!MAX_SEQUENCE_LENGTH_256) {
        dec exod_zp_len_hi
        jmp copy_next
}
test_reuse:
.if (!DONT_REUSE_OFFSET) {
// -------------------------------------------------------------------
// test for offset reuse (11 bytes)
//
        bvs no_reuse
.if (MAX_SEQUENCE_LENGTH_256) {
        lda #$00                // fetch one bit
}
        asl exod_zp_bitbuf
        bne gbnc1_ok
        pha
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        pla
gbnc1_ok:
        rol
        beq no_reuse            // bit == 0 => C=0, no reuse
        bne copy_next           // bit != 0 => C=0, reuse previous offset
}
// -------------------------------------------------------------------
// exit or literal sequence handling (16(12) bytes)
//
exit_or_lit_seq:
.if (!LITERAL_SEQUENCES_NOT_USED) {
        beq decr_exit
        jsr exod_get_crunched_byte
.if (!MAX_SEQUENCE_LENGTH_256) {
        sta exod_zp_len_hi
}
        jsr exod_get_crunched_byte
        tax
        bcs copy_next
decr_exit:
}
        rts
get_literal_byte:
.if (!LITERAL_SEQUENCES_NOT_USED) {
        jsr exod_get_crunched_byte
        bcs literal_byte_gotten
}
tabl_bit:
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
// -------------------------------------------------------------------
// the static stable used for bits+offset for lengths 1, 2 and 3 (3 bytes)
// bits 2, 4, 4 and offsets 64, 48, 32 corresponding to
// %10010000, %11100011, %11100010
        .byte $90, $e3, $e2
} else {
// -------------------------------------------------------------------
// the static stable used for bits+offset for lengths 1 and 2 (2 bytes)
// bits 2, 4 and offsets 48, 32 corresponding to %10001100, %11100010
        .byte $8c, $e2
}

// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// this 156 (204) byte table area may be relocated. It may also be
// clobbered by other data between decrunches.
// -------------------------------------------------------------------
exod_decrunch_table:
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
}
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------
2020-12-31 18:23
Jammer

Registered: Nov 2002
Posts: 1018
Wow, thank you, Sir! Gotta test it asap! :D
2021-01-03 15:34
wil

Registered: Jan 2019
Posts: 23
Does somebody also have streamdecoder code that works with exomizer 3.x?
Previous - 1 | 2 - Next
RefreshSubscribe to this thread:

You need to be logged in to post in the forum.

Search the forum:
Search   for   in  
All times are CET.
Search CSDb
Advanced
Users Online
pgarcia
Yazoo/Arsenic
redback
Guests online: 66
Top Demos
1 Christmas Megademo  (9.7)
2 Uncensored  (9.6)
3 Edge of Disgrace  (9.6)
4 Coma Light 13  (9.6)
5 Memento Mori  (9.6)
6 Unboxed  (9.6)
7 Comaland 100%  (9.6)
8 Lunatico  (9.6)
9 Protogeo 100%  (9.5)
10 The Shores of Reflec..  (9.5)
Top onefile Demos
1 Copper Booze  (9.8)
2 To Norah  (9.8)
3 Lovecats  (9.7)
4 For Your Sprites Only  (9.6)
5 Elite Code Mechanics  (9.6)
6 Square Booze  (9.6)
7 Quadrants  (9.5)
8 Daah, Those Acid Pil..  (9.5)
9 Dawnfall V1.1  (9.5)
10 New 30 Years Low Res..  (9.5)
Top Groups
1 Booze Design  (9.4)
2 Censor Design  (9.4)
3 Fossil  (9.4)
4 Oxyron  (9.3)
5 PriorArt  (9.3)
Top Coders
1 Sparta  (9.8)
2 Axis  (9.8)
3 Graham  (9.8)
4 Crossbow  (9.8)
5 HCL  (9.8)

Home - Disclaimer
Copyright © No Name 2001-2021
Page generated in: 0.073 sec.