mirror of
https://github.com/Michaelangel007/c2t.git
synced 2024-11-04 16:06:31 +00:00
4353 lines
142 KiB
C
4353 lines
142 KiB
C
|
|
||
|
const char *usagetext="\n\
|
||
|
usage: c2t [-vh?]\n\
|
||
|
c2t [-elp] input[.mon],[addr] ... [output.mon]\n\
|
||
|
c2t {-1} [-cepr] input[.mon],[addr] ... [output.[aif[f]|wav[e]]]\n\
|
||
|
c2t {-2} [-abcdef8pmqr] input[.mon],[addr] ... [output.[aif[f]|wav[e]]]\n\
|
||
|
c2t [-n8] input.dsk ... [output.[aif[f]|wav[e]]]\n\
|
||
|
\n\
|
||
|
-1 or -2 for Apple I or II tape format\n\
|
||
|
-8 use 48k/8bit 8000 bps transfer (Apple II/II+/IIe 64K only)\n\
|
||
|
Implies -2a. Negates -f and -d.\n\
|
||
|
-a assembly autoload and run (Apple II/II+/IIe 64K only)\n\
|
||
|
-b basic autoload and run (Apple II+/IIe 64K only)\n\
|
||
|
Implies -2a.\n\
|
||
|
-c compress data\n\
|
||
|
-d use fast 44.1k/16bit transfer (Apple II/II+/IIe 64K only)\n\
|
||
|
Implies -2a. Negates -f and -8. Use for burning CDs.\n\
|
||
|
-e pad with $00 to end on page boundary\n\
|
||
|
-f use faster 48k/8bit (9600 bps) transfer (Apple II/II+/IIe 64K only)\n\
|
||
|
Implies -2a. Negates -8 and -d. Unreliable on some systems.\n\
|
||
|
-h|? this help\n\
|
||
|
-l long monitor format (24 bytes/line)\n\
|
||
|
-m jump to monitor after autoload\n\
|
||
|
-n do not format disks\n\
|
||
|
-p pipe to stdout\n\
|
||
|
-q parameters and data only (for use with custom client)\n\
|
||
|
-r #, where # overrides the sample rate (e.g. -r 48000)\n\
|
||
|
Negates -a, -b, -8, -q, -f, and -d\n\
|
||
|
-t 10 second preamble (default 4) for real tape use\n\
|
||
|
-v print version number and exit\n\
|
||
|
\n\
|
||
|
input(s) without a .mon or .dsk extension is assumed to be a binary with a 4\n\
|
||
|
byte header. If the header is missing then you must append ,load_address to\n\
|
||
|
each binary input missing a header, e.g. filename,800. The load address\n\
|
||
|
will be read as hex.\n\
|
||
|
\n\
|
||
|
input(s) with a .mon extension expected input format:\n\
|
||
|
\n\
|
||
|
0280: A2 FF 9A 20 8C 02 20 4F\n\
|
||
|
0288: 03 4C 00 FF 20 9E 02 A9\n\
|
||
|
\n\
|
||
|
A single input with a .dsk extension expected to be a 140K disk image.\n\
|
||
|
\n\
|
||
|
output must have aiff, aif, wav, wave, or mon extention.\n\
|
||
|
\n\
|
||
|
Examples:\n\
|
||
|
\n\
|
||
|
c2t hello hello.mon\n\
|
||
|
c2t -p hello.mon print.mon foo,800 | pbcopy\n\
|
||
|
c2t -2f moon.patrol,801 moon.patrol.aif\n\
|
||
|
c2t -2 hello,300 hello.aiff\n\
|
||
|
c2t -1 hello.mon hello.wav\n\
|
||
|
c2t -2 thief,801 thief.obj,3ffd thief.pic,2000 theif.aif\n\
|
||
|
c2t foo.dsk foo.wav\n\
|
||
|
\n\
|
||
|
";
|
||
|
|
||
|
//51 00 D5, 3 byte header, LENGTH LSB/MSB, D5 for autorun
|
||
|
unsigned char header[] = {0x00,0x00,0xD5};
|
||
|
|
||
|
|
||
|
/*
|
||
|
basic program "CALL 2060", 801.80B
|
||
|
|
||
|
end of code[LSB,MSB] = 0x0B,0x08
|
||
|
line #[LSB,MSG] = 0x01,0x00
|
||
|
CALL[1] = 0x8C
|
||
|
vec[4] = 0x32,0x30,0x36,0x30 (2060 in ASCII)
|
||
|
end[2] = 0x00,0x00
|
||
|
*/
|
||
|
unsigned char basic[] = {0x0B,0x08,0x01,0x00,0x8C,0x32,0x30,0x36,0x30,0x00,0x00};
|
||
|
|
||
|
/*
|
||
|
;autoload.s
|
||
|
|
||
|
org = $BF00 ; should be $BF00
|
||
|
cout = $FDED ; character out sub
|
||
|
crout = $FD8E ; CR out sub
|
||
|
prbyte = $FDDA
|
||
|
warm = $FF69 ; back to monitor
|
||
|
readblk = $FEFD
|
||
|
pointer = $06
|
||
|
endbas = $80C
|
||
|
;target = $1000
|
||
|
target = $801
|
||
|
chksum = $00
|
||
|
inflate = $BA00
|
||
|
inf_zp = $0
|
||
|
|
||
|
start:
|
||
|
.org endbas
|
||
|
move:
|
||
|
ldx #0
|
||
|
move1: lda moved,x
|
||
|
sta load,x
|
||
|
inx
|
||
|
bne move1 ; move 256 bytes
|
||
|
jmp load
|
||
|
moved:
|
||
|
.org org
|
||
|
load:
|
||
|
lda #<loadm
|
||
|
ldy #>loadm
|
||
|
jsr print
|
||
|
|
||
|
lda ld_beg
|
||
|
sta $3C ; starting tape address low
|
||
|
lda ld_beg+1
|
||
|
sta $3D ; starting tape address high
|
||
|
lda ld_end
|
||
|
sta $3E ; ending tape address low
|
||
|
lda ld_end+1
|
||
|
sta $3F ; ending tape address high
|
||
|
jsr readblk ; read block from tape
|
||
|
|
||
|
lda inf_flag ; if inf_flag = 0 runit
|
||
|
beq runit
|
||
|
inf:
|
||
|
jsr crout
|
||
|
lda #<infm
|
||
|
ldy #>infm
|
||
|
jsr print
|
||
|
|
||
|
lda inf_src ;src lsb
|
||
|
sta inf_zp+0
|
||
|
lda inf_src+1 ;src msb
|
||
|
sta inf_zp+1
|
||
|
lda inf_dst ;dst lsb
|
||
|
sta inf_zp+2
|
||
|
lda inf_dst+1 ;dst msb
|
||
|
sta inf_zp+3
|
||
|
|
||
|
jsr inflate
|
||
|
|
||
|
lda inf_end ;dst end +1 lsb
|
||
|
cmp inf_zp+2
|
||
|
bne error
|
||
|
lda inf_end+1 ;dst end +1 msb
|
||
|
cmp inf_zp+3
|
||
|
bne error
|
||
|
runit:
|
||
|
lda warm_flag ; if warm_flag = 1 warm boot
|
||
|
bne warmit
|
||
|
jmp (runcode)
|
||
|
warmit:
|
||
|
jmp warm ; run it
|
||
|
sumerror:
|
||
|
jsr crout
|
||
|
lda #<chkm
|
||
|
ldy #>chkm
|
||
|
jsr print
|
||
|
error:
|
||
|
lda #<errm
|
||
|
ldy #>errm
|
||
|
jsr print
|
||
|
jmp warm
|
||
|
print:
|
||
|
sta pointer
|
||
|
sty pointer+1
|
||
|
ldy #0
|
||
|
lda (pointer),y ; load initial char
|
||
|
print1: ora #$80
|
||
|
jsr cout
|
||
|
iny
|
||
|
lda (pointer),y
|
||
|
bne print1
|
||
|
rts
|
||
|
chkm: .asciiz "CHKSUM "
|
||
|
errm: .asciiz "ERROR"
|
||
|
infm: .asciiz "INFLATING "
|
||
|
ld_beg:
|
||
|
.org *+2
|
||
|
ld_end:
|
||
|
.org *+2
|
||
|
inf_src:
|
||
|
.org *+2
|
||
|
runcode:
|
||
|
inf_dst:
|
||
|
.org *+2
|
||
|
inf_end:
|
||
|
.org *+2
|
||
|
inf_flag:
|
||
|
.org *+1
|
||
|
warm_flag:
|
||
|
.org *+1
|
||
|
loadm:
|
||
|
;.asciiz "LOADING "
|
||
|
|
||
|
end:
|
||
|
|
||
|
*/
|
||
|
unsigned char autoloadcode[] = {
|
||
|
0xA2,0x00,0xBD,0x1A,
|
||
|
0x08,0x9D,0x00,0xBF,0xE8,0xD0,0xF7,0x4C,
|
||
|
0x00,0xBF,0xA9,0xA9,0xA0,0xBF,0x20,0x71,
|
||
|
0xBF,0xAD,0x9D,0xBF,0x85,0x3C,0xAD,0x9E,
|
||
|
0xBF,0x85,0x3D,0xAD,0x9F,0xBF,0x85,0x3E,
|
||
|
0xAD,0xA0,0xBF,0x85,0x3F,0x20,0xFD,0xFE,
|
||
|
0xAD,0xA7,0xBF,0xF0,0x2F,0x20,0x8E,0xFD,
|
||
|
0xA9,0x92,0xA0,0xBF,0x20,0x71,0xBF,0xAD,
|
||
|
0xA1,0xBF,0x85,0x00,0xAD,0xA2,0xBF,0x85,
|
||
|
0x01,0xAD,0xA3,0xBF,0x85,0x02,0xAD,0xA4,
|
||
|
0xBF,0x85,0x03,0x20,0x00,0xBA,0xAD,0xA5,
|
||
|
0xBF,0xC5,0x02,0xD0,0x1C,0xAD,0xA6,0xBF,
|
||
|
0xC5,0x03,0xD0,0x15,0xAD,0xA8,0xBF,0xD0,
|
||
|
0x03,0x6C,0xA3,0xBF,0x4C,0x69,0xFF,0x20,
|
||
|
0x8E,0xFD,0xA9,0x84,0xA0,0xBF,0x20,0x71,
|
||
|
0xBF,0xA9,0x8C,0xA0,0xBF,0x20,0x71,0xBF,
|
||
|
0x4C,0x69,0xFF,0x85,0x06,0x84,0x07,0xA0,
|
||
|
0x00,0xB1,0x06,0x09,0x80,0x20,0xED,0xFD,
|
||
|
0xC8,0xB1,0x06,0xD0,0xF6,0x60,0x43,0x48,
|
||
|
0x4B,0x53,0x55,0x4D,0x20,0x00,0x45,0x52,
|
||
|
0x52,0x4F,0x52,0x00,0x49,0x4E,0x46,0x4C,
|
||
|
0x41,0x54,0x49,0x4E,0x47,0x20,0x00
|
||
|
};
|
||
|
/*
|
||
|
; inflate - uncompress data stored in the DEFLATE format
|
||
|
; by Piotr Fusik <fox@scene.pl>
|
||
|
; Last modified: 2007-06-17
|
||
|
|
||
|
; Compile with xasm (http://xasm.atari.org/), for example:
|
||
|
; xasm inflate.asx /l /d:inflate=$b700 /d:inflate_data=$b900 /d:inflate_zp=$f0
|
||
|
; inflate is 509 bytes of code and initialized data
|
||
|
; inflate_data is 764 bytes of uninitialized data
|
||
|
; inflate_zp is 10 bytes on page zero
|
||
|
|
||
|
; hacked for apple ii and ca65 by Egan Ford <egan@sense.net>
|
||
|
; dates
|
||
|
|
||
|
; compile nodes
|
||
|
|
||
|
; changes
|
||
|
|
||
|
;EFF
|
||
|
.define equ =
|
||
|
|
||
|
inflate = $BA00
|
||
|
inflate_zp = $0
|
||
|
inflate_data = $BC00
|
||
|
|
||
|
; Pointer to compressed data
|
||
|
inputPointer equ inflate_zp ; 2 bytes
|
||
|
|
||
|
; Pointer to uncompressed data
|
||
|
outputPointer equ inflate_zp+2 ; 2 bytes
|
||
|
|
||
|
; Local variables
|
||
|
|
||
|
getBit_buffer equ inflate_zp+4 ; 1 byte
|
||
|
|
||
|
getBits_base equ inflate_zp+5 ; 1 byte
|
||
|
inflateStoredBlock_pageCounter equ inflate_zp+5 ; 1 byte
|
||
|
|
||
|
inflateCodes_sourcePointer equ inflate_zp+6 ; 2 bytes
|
||
|
inflateDynamicBlock_lengthIndex equ inflate_zp+6 ; 1 byte
|
||
|
inflateDynamicBlock_lastLength equ inflate_zp+7 ; 1 byte
|
||
|
inflateDynamicBlock_tempCodes equ inflate_zp+7 ; 1 byte
|
||
|
|
||
|
inflateCodes_lengthMinus2 equ inflate_zp+8 ; 1 byte
|
||
|
inflateDynamicBlock_allCodes equ inflate_zp+8 ; 1 byte
|
||
|
|
||
|
inflateCodes_primaryCodes equ inflate_zp+9 ; 1 byte
|
||
|
|
||
|
|
||
|
; Argument values for getBits
|
||
|
GET_1_BIT equ $81
|
||
|
GET_2_BITS equ $82
|
||
|
GET_3_BITS equ $84
|
||
|
GET_4_BITS equ $88
|
||
|
GET_5_BITS equ $90
|
||
|
GET_6_BITS equ $a0
|
||
|
GET_7_BITS equ $c0
|
||
|
|
||
|
; Maximum length of a Huffman code
|
||
|
MAX_CODE_LENGTH equ 15
|
||
|
|
||
|
; Huffman trees
|
||
|
TREE_SIZE equ MAX_CODE_LENGTH+1
|
||
|
PRIMARY_TREE equ 0
|
||
|
DISTANCE_TREE equ TREE_SIZE
|
||
|
|
||
|
; Alphabet
|
||
|
LENGTH_SYMBOLS equ 1+29+2
|
||
|
DISTANCE_SYMBOLS equ 30
|
||
|
CONTROL_SYMBOLS equ LENGTH_SYMBOLS+DISTANCE_SYMBOLS
|
||
|
TOTAL_SYMBOLS equ 256+CONTROL_SYMBOLS
|
||
|
|
||
|
; Optional (recommend for c2t or DOS)
|
||
|
; DOS header location and size LSB/MSB
|
||
|
; .byte <START,>START,<(END-START),>(END-START)
|
||
|
|
||
|
; Uncompress DEFLATE stream starting from the address stored in inputPointer
|
||
|
; to the memory starting from the address stored in outputPointer
|
||
|
;; org inflate
|
||
|
.org inflate
|
||
|
START:
|
||
|
;; mvy #0 getBit_buffer
|
||
|
LDY #0
|
||
|
STY getBit_buffer
|
||
|
|
||
|
|
||
|
inflate_blockLoop:
|
||
|
; Get a bit of EOF and two bits of block type
|
||
|
; ldy #0
|
||
|
sty getBits_base
|
||
|
lda #GET_3_BITS
|
||
|
jsr getBits
|
||
|
;; lsr @
|
||
|
lsr A
|
||
|
php
|
||
|
tax
|
||
|
bne inflateCompressedBlock
|
||
|
|
||
|
; Copy uncompressed block
|
||
|
; ldy #0
|
||
|
sty getBit_buffer
|
||
|
jsr getWord
|
||
|
jsr getWord
|
||
|
sta inflateStoredBlock_pageCounter
|
||
|
; jmp inflateStoredBlock_firstByte
|
||
|
bcs inflateStoredBlock_firstByte
|
||
|
inflateStoredBlock_copyByte:
|
||
|
jsr getByte
|
||
|
inflateStoreByte:
|
||
|
jsr storeByte
|
||
|
bcc inflateCodes_loop
|
||
|
inflateStoredBlock_firstByte:
|
||
|
inx
|
||
|
bne inflateStoredBlock_copyByte
|
||
|
inc inflateStoredBlock_pageCounter
|
||
|
bne inflateStoredBlock_copyByte
|
||
|
|
||
|
inflate_nextBlock:
|
||
|
plp
|
||
|
bcc inflate_blockLoop
|
||
|
rts
|
||
|
|
||
|
inflateCompressedBlock:
|
||
|
|
||
|
; Decompress a block with fixed Huffman trees
|
||
|
; :144 dta 8
|
||
|
; :112 dta 9
|
||
|
; :24 dta 7
|
||
|
; :6 dta 8
|
||
|
; :2 dta 8 ; codes with no meaning
|
||
|
; :30 dta 5+DISTANCE_TREE
|
||
|
; ldy #0
|
||
|
inflateFixedBlock_setCodeLengths:
|
||
|
lda #4
|
||
|
cpy #144
|
||
|
;; rol @
|
||
|
rol A
|
||
|
sta literalSymbolCodeLength,y
|
||
|
cpy #CONTROL_SYMBOLS
|
||
|
bcs inflateFixedBlock_noControlSymbol
|
||
|
lda #5+DISTANCE_TREE
|
||
|
cpy #LENGTH_SYMBOLS
|
||
|
bcs inflateFixedBlock_setControlCodeLength
|
||
|
cpy #24
|
||
|
adc #2-DISTANCE_TREE
|
||
|
inflateFixedBlock_setControlCodeLength:
|
||
|
sta controlSymbolCodeLength,y
|
||
|
inflateFixedBlock_noControlSymbol:
|
||
|
iny
|
||
|
bne inflateFixedBlock_setCodeLengths
|
||
|
; mva #LENGTH_SYMBOLS inflateCodes_primaryCodes
|
||
|
LDA #LENGTH_SYMBOLS
|
||
|
STA inflateCodes_primaryCodes
|
||
|
|
||
|
dex
|
||
|
beq inflateCodes
|
||
|
|
||
|
; Decompress a block reading Huffman trees first
|
||
|
|
||
|
; Build the tree for temporary codes
|
||
|
jsr buildTempHuffmanTree
|
||
|
|
||
|
; Use temporary codes to get lengths of literal/length and distance codes
|
||
|
ldx #0
|
||
|
; sec
|
||
|
inflateDynamicBlock_decodeLength:
|
||
|
php
|
||
|
stx inflateDynamicBlock_lengthIndex
|
||
|
; Fetch a temporary code
|
||
|
jsr fetchPrimaryCode
|
||
|
; Temporary code 0..15: put this length
|
||
|
tax
|
||
|
bpl inflateDynamicBlock_verbatimLength
|
||
|
; Temporary code 16: repeat last length 3 + getBits(2) times
|
||
|
; Temporary code 17: put zero length 3 + getBits(3) times
|
||
|
; Temporary code 18: put zero length 11 + getBits(7) times
|
||
|
jsr getBits
|
||
|
; sec
|
||
|
adc #1
|
||
|
cpx #GET_7_BITS
|
||
|
;; scc:adc #7
|
||
|
BCC S1
|
||
|
adc #7
|
||
|
S1:
|
||
|
tay
|
||
|
lda #0
|
||
|
cpx #GET_3_BITS
|
||
|
;; scs:lda inflateDynamicBlock_lastLength
|
||
|
BCS S2
|
||
|
lda inflateDynamicBlock_lastLength
|
||
|
S2:
|
||
|
inflateDynamicBlock_verbatimLength:
|
||
|
iny
|
||
|
ldx inflateDynamicBlock_lengthIndex
|
||
|
plp
|
||
|
inflateDynamicBlock_storeLength:
|
||
|
bcc inflateDynamicBlock_controlSymbolCodeLength
|
||
|
;; sta literalSymbolCodeLength,x+
|
||
|
sta literalSymbolCodeLength,x
|
||
|
INX
|
||
|
cpx #1
|
||
|
inflateDynamicBlock_storeNext:
|
||
|
dey
|
||
|
bne inflateDynamicBlock_storeLength
|
||
|
sta inflateDynamicBlock_lastLength
|
||
|
; jmp inflateDynamicBlock_decodeLength
|
||
|
beq inflateDynamicBlock_decodeLength
|
||
|
inflateDynamicBlock_controlSymbolCodeLength:
|
||
|
cpx inflateCodes_primaryCodes
|
||
|
;; scc:ora #DISTANCE_TREE
|
||
|
BCC S3
|
||
|
ora #DISTANCE_TREE
|
||
|
S3:
|
||
|
;; sta controlSymbolCodeLength,x+
|
||
|
sta controlSymbolCodeLength,x
|
||
|
INX
|
||
|
|
||
|
cpx inflateDynamicBlock_allCodes
|
||
|
bcc inflateDynamicBlock_storeNext
|
||
|
dey
|
||
|
; ldy #0
|
||
|
; jmp inflateCodes
|
||
|
|
||
|
; Decompress a block
|
||
|
inflateCodes:
|
||
|
jsr buildHuffmanTree
|
||
|
inflateCodes_loop:
|
||
|
jsr fetchPrimaryCode
|
||
|
bcc inflateStoreByte
|
||
|
tax
|
||
|
beq inflate_nextBlock
|
||
|
; Copy sequence from look-behind buffer
|
||
|
; ldy #0
|
||
|
sty getBits_base
|
||
|
cmp #9
|
||
|
bcc inflateCodes_setSequenceLength
|
||
|
tya
|
||
|
; lda #0
|
||
|
cpx #1+28
|
||
|
bcs inflateCodes_setSequenceLength
|
||
|
dex
|
||
|
txa
|
||
|
;; lsr @
|
||
|
lsr A
|
||
|
ror getBits_base
|
||
|
inc getBits_base
|
||
|
;; lsr @
|
||
|
lsr A
|
||
|
rol getBits_base
|
||
|
jsr getAMinus1BitsMax8
|
||
|
; sec
|
||
|
adc #0
|
||
|
inflateCodes_setSequenceLength:
|
||
|
sta inflateCodes_lengthMinus2
|
||
|
ldx #DISTANCE_TREE
|
||
|
jsr fetchCode
|
||
|
; sec
|
||
|
sbc inflateCodes_primaryCodes
|
||
|
tax
|
||
|
cmp #4
|
||
|
bcc inflateCodes_setOffsetLowByte
|
||
|
inc getBits_base
|
||
|
;; lsr @
|
||
|
lsr A
|
||
|
jsr getAMinus1BitsMax8
|
||
|
inflateCodes_setOffsetLowByte:
|
||
|
eor #$ff
|
||
|
sta inflateCodes_sourcePointer
|
||
|
lda getBits_base
|
||
|
cpx #10
|
||
|
bcc inflateCodes_setOffsetHighByte
|
||
|
lda getNPlus1Bits_mask-10,x
|
||
|
jsr getBits
|
||
|
clc
|
||
|
inflateCodes_setOffsetHighByte:
|
||
|
eor #$ff
|
||
|
; clc
|
||
|
adc outputPointer+1
|
||
|
sta inflateCodes_sourcePointer+1
|
||
|
jsr copyByte
|
||
|
jsr copyByte
|
||
|
inflateCodes_copyByte:
|
||
|
jsr copyByte
|
||
|
dec inflateCodes_lengthMinus2
|
||
|
bne inflateCodes_copyByte
|
||
|
; jmp inflateCodes_loop
|
||
|
beq inflateCodes_loop
|
||
|
|
||
|
buildTempHuffmanTree:
|
||
|
; ldy #0
|
||
|
tya
|
||
|
inflateDynamicBlock_clearCodeLengths:
|
||
|
sta literalSymbolCodeLength,y
|
||
|
sta literalSymbolCodeLength+TOTAL_SYMBOLS-256,y
|
||
|
iny
|
||
|
bne inflateDynamicBlock_clearCodeLengths
|
||
|
; numberOfPrimaryCodes = 257 + getBits(5)
|
||
|
; numberOfDistanceCodes = 1 + getBits(5)
|
||
|
; numberOfTemporaryCodes = 4 + getBits(4)
|
||
|
ldx #3
|
||
|
inflateDynamicBlock_getHeader:
|
||
|
lda inflateDynamicBlock_headerBits-1,x
|
||
|
jsr getBits
|
||
|
; sec
|
||
|
adc inflateDynamicBlock_headerBase-1,x
|
||
|
sta inflateDynamicBlock_tempCodes-1,x
|
||
|
sta inflateDynamicBlock_headerBase+1
|
||
|
dex
|
||
|
bne inflateDynamicBlock_getHeader
|
||
|
|
||
|
; Get lengths of temporary codes in the order stored in tempCodeLengthOrder
|
||
|
; ldx #0
|
||
|
inflateDynamicBlock_getTempCodeLengths:
|
||
|
lda #GET_3_BITS
|
||
|
jsr getBits
|
||
|
ldy tempCodeLengthOrder,x
|
||
|
sta literalSymbolCodeLength,y
|
||
|
ldy #0
|
||
|
inx
|
||
|
cpx inflateDynamicBlock_tempCodes
|
||
|
bcc inflateDynamicBlock_getTempCodeLengths
|
||
|
|
||
|
; Build Huffman trees basing on code lengths (in bits)
|
||
|
; stored in the *SymbolCodeLength arrays
|
||
|
buildHuffmanTree:
|
||
|
; Clear nBitCode_totalCount, nBitCode_literalCount, nBitCode_controlCount
|
||
|
tya
|
||
|
; lda #0
|
||
|
;; sta:rne nBitCode_clearFrom,y+
|
||
|
R1:
|
||
|
sta nBitCode_clearFrom,y
|
||
|
INY
|
||
|
BNE R1
|
||
|
; Count number of codes of each length
|
||
|
; ldy #0
|
||
|
buildHuffmanTree_countCodeLengths:
|
||
|
ldx literalSymbolCodeLength,y
|
||
|
inc nBitCode_literalCount,x
|
||
|
inc nBitCode_totalCount,x
|
||
|
cpy #CONTROL_SYMBOLS
|
||
|
bcs buildHuffmanTree_noControlSymbol
|
||
|
ldx controlSymbolCodeLength,y
|
||
|
inc nBitCode_controlCount,x
|
||
|
inc nBitCode_totalCount,x
|
||
|
buildHuffmanTree_noControlSymbol:
|
||
|
iny
|
||
|
bne buildHuffmanTree_countCodeLengths
|
||
|
; Calculate offsets of symbols sorted by code length
|
||
|
; lda #0
|
||
|
ldx #-3*TREE_SIZE
|
||
|
buildHuffmanTree_calculateOffsets:
|
||
|
sta nBitCode_literalOffset+3*TREE_SIZE-$100,x
|
||
|
;; add nBitCode_literalCount+3*TREE_SIZE-$100,x
|
||
|
CLC
|
||
|
ADC nBitCode_literalCount+3*TREE_SIZE-$100,x
|
||
|
inx
|
||
|
bne buildHuffmanTree_calculateOffsets
|
||
|
; Put symbols in their place in the sorted array
|
||
|
; ldy #0
|
||
|
buildHuffmanTree_assignCode:
|
||
|
tya
|
||
|
ldx literalSymbolCodeLength,y
|
||
|
;; ldy:inc nBitCode_literalOffset,x
|
||
|
ldy nBitCode_literalOffset,x
|
||
|
inc nBitCode_literalOffset,x
|
||
|
sta codeToLiteralSymbol,y
|
||
|
tay
|
||
|
cpy #CONTROL_SYMBOLS
|
||
|
bcs buildHuffmanTree_noControlSymbol2
|
||
|
ldx controlSymbolCodeLength,y
|
||
|
;; ldy:inc nBitCode_controlOffset,x
|
||
|
ldy nBitCode_controlOffset,x
|
||
|
inc nBitCode_controlOffset,x
|
||
|
sta codeToControlSymbol,y
|
||
|
tay
|
||
|
buildHuffmanTree_noControlSymbol2:
|
||
|
iny
|
||
|
bne buildHuffmanTree_assignCode
|
||
|
rts
|
||
|
|
||
|
; Read Huffman code using the primary tree
|
||
|
fetchPrimaryCode:
|
||
|
ldx #PRIMARY_TREE
|
||
|
; Read a code from input basing on the tree specified in X,
|
||
|
; return low byte of this code in A,
|
||
|
; return C flag reset for literal code, set for length code
|
||
|
fetchCode:
|
||
|
; ldy #0
|
||
|
tya
|
||
|
fetchCode_nextBit:
|
||
|
jsr getBit
|
||
|
;; rol @
|
||
|
rol A
|
||
|
inx
|
||
|
;; sub nBitCode_totalCount,x
|
||
|
SEC
|
||
|
SBC nBitCode_totalCount,x
|
||
|
bcs fetchCode_nextBit
|
||
|
; clc
|
||
|
adc nBitCode_controlCount,x
|
||
|
bcs fetchCode_control
|
||
|
; clc
|
||
|
adc nBitCode_literalOffset,x
|
||
|
tax
|
||
|
lda codeToLiteralSymbol,x
|
||
|
clc
|
||
|
rts
|
||
|
fetchCode_control:
|
||
|
;; add nBitCode_controlOffset-1,x
|
||
|
CLC
|
||
|
ADC nBitCode_controlOffset-1,x
|
||
|
tax
|
||
|
lda codeToControlSymbol,x
|
||
|
sec
|
||
|
rts
|
||
|
|
||
|
; Read A minus 1 bits, but no more than 8
|
||
|
getAMinus1BitsMax8:
|
||
|
rol getBits_base
|
||
|
tax
|
||
|
cmp #9
|
||
|
bcs getByte
|
||
|
lda getNPlus1Bits_mask-2,x
|
||
|
getBits:
|
||
|
jsr getBits_loop
|
||
|
getBits_normalizeLoop:
|
||
|
lsr getBits_base
|
||
|
;; ror @
|
||
|
ror A
|
||
|
bcc getBits_normalizeLoop
|
||
|
rts
|
||
|
|
||
|
; Read 16 bits
|
||
|
getWord:
|
||
|
jsr getByte
|
||
|
tax
|
||
|
; Read 8 bits
|
||
|
getByte:
|
||
|
lda #$80
|
||
|
getBits_loop:
|
||
|
jsr getBit
|
||
|
;; ror @
|
||
|
ror A
|
||
|
bcc getBits_loop
|
||
|
rts
|
||
|
|
||
|
; Read one bit, return in the C flag
|
||
|
getBit:
|
||
|
lsr getBit_buffer
|
||
|
bne getBit_return
|
||
|
pha
|
||
|
; ldy #0
|
||
|
lda (inputPointer),y
|
||
|
;; inw inputPointer
|
||
|
INC inputPointer
|
||
|
BNE S4
|
||
|
INC inputPointer+1
|
||
|
S4:
|
||
|
sec
|
||
|
;; ror @
|
||
|
ror A
|
||
|
sta getBit_buffer
|
||
|
pla
|
||
|
getBit_return:
|
||
|
rts
|
||
|
|
||
|
; Copy a previously written byte
|
||
|
copyByte:
|
||
|
ldy outputPointer
|
||
|
lda (inflateCodes_sourcePointer),y
|
||
|
ldy #0
|
||
|
; Write a byte
|
||
|
storeByte:
|
||
|
sta (outputPointer),y
|
||
|
inc outputPointer
|
||
|
bne storeByte_return
|
||
|
inc outputPointer+1
|
||
|
inc inflateCodes_sourcePointer+1
|
||
|
storeByte_return:
|
||
|
rts
|
||
|
|
||
|
getNPlus1Bits_mask:
|
||
|
.byte GET_1_BIT,GET_2_BITS,GET_3_BITS,GET_4_BITS,GET_5_BITS,GET_6_BITS,GET_7_BITS
|
||
|
|
||
|
tempCodeLengthOrder:
|
||
|
.byte GET_2_BITS,GET_3_BITS,GET_7_BITS,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15
|
||
|
|
||
|
inflateDynamicBlock_headerBits:
|
||
|
.byte GET_4_BITS,GET_5_BITS,GET_5_BITS
|
||
|
inflateDynamicBlock_headerBase:
|
||
|
.byte 3,0,0 ; second byte is modified at runtime!
|
||
|
|
||
|
.org inflate_data
|
||
|
|
||
|
; Data for building trees
|
||
|
|
||
|
literalSymbolCodeLength:
|
||
|
.org *+256
|
||
|
controlSymbolCodeLength:
|
||
|
.org *+CONTROL_SYMBOLS
|
||
|
|
||
|
; Huffman trees
|
||
|
|
||
|
nBitCode_clearFrom:
|
||
|
nBitCode_totalCount:
|
||
|
.org *+2*TREE_SIZE
|
||
|
nBitCode_literalCount:
|
||
|
.org *+TREE_SIZE
|
||
|
nBitCode_controlCount:
|
||
|
.org *+2*TREE_SIZE
|
||
|
nBitCode_literalOffset:
|
||
|
.org *+TREE_SIZE
|
||
|
nBitCode_controlOffset:
|
||
|
.org *+2*TREE_SIZE
|
||
|
|
||
|
codeToLiteralSymbol:
|
||
|
.org *+256
|
||
|
codeToControlSymbol:
|
||
|
.org *+CONTROL_SYMBOLS
|
||
|
|
||
|
END:
|
||
|
*/
|
||
|
unsigned char inflatecode[] = {
|
||
|
0xA0,0x00,0x84,0x04,0x84,0x05,0xA9,0x84,
|
||
|
0x20,0xA3,0xBB,0x4A,0x08,0xAA,0xD0,0x1F,
|
||
|
0x84,0x04,0x20,0xAC,0xBB,0x20,0xAC,0xBB,
|
||
|
0x85,0x05,0xB0,0x08,0x20,0xB0,0xBB,0x20,
|
||
|
0xD2,0xBB,0x90,0x75,0xE8,0xD0,0xF5,0xE6,
|
||
|
0x05,0xD0,0xF1,0x28,0x90,0xD6,0x60,0xA9,
|
||
|
0x04,0xC0,0x90,0x2A,0x99,0x00,0xBC,0xC0,
|
||
|
0x3E,0xB0,0x0D,0xA9,0x15,0xC0,0x20,0xB0,
|
||
|
0x04,0xC0,0x18,0x69,0xF2,0x99,0x00,0xBD,
|
||
|
0xC8,0xD0,0xE4,0xA9,0x20,0x85,0x09,0xCA,
|
||
|
0xF0,0x44,0x20,0xF5,0xBA,0xA2,0x00,0x08,
|
||
|
0x86,0x06,0x20,0x73,0xBB,0xAA,0x10,0x14,
|
||
|
0x20,0xA3,0xBB,0x69,0x01,0xE0,0xC0,0x90,
|
||
|
0x02,0x69,0x07,0xA8,0xA9,0x00,0xE0,0x84,
|
||
|
0xB0,0x02,0xA5,0x07,0xC8,0xA6,0x06,0x28,
|
||
|
0x90,0x0D,0x9D,0x00,0xBC,0xE8,0xE0,0x01,
|
||
|
0x88,0xD0,0xF5,0x85,0x07,0xF0,0xD0,0xE4,
|
||
|
0x09,0x90,0x02,0x09,0x10,0x9D,0x00,0xBD,
|
||
|
0xE8,0xE4,0x08,0x90,0xEB,0x88,0x20,0x24,
|
||
|
0xBB,0x20,0x73,0xBB,0x90,0x81,0xAA,0xF0,
|
||
|
0x8A,0x84,0x05,0xC9,0x09,0x90,0x14,0x98,
|
||
|
0xE0,0x1D,0xB0,0x0F,0xCA,0x8A,0x4A,0x66,
|
||
|
0x05,0xE6,0x05,0x4A,0x26,0x05,0x20,0x99,
|
||
|
0xBB,0x69,0x00,0x85,0x08,0xA2,0x10,0x20,
|
||
|
0x75,0xBB,0xE5,0x09,0xAA,0xC9,0x04,0x90,
|
||
|
0x06,0xE6,0x05,0x4A,0x20,0x99,0xBB,0x49,
|
||
|
0xFF,0x85,0x06,0xA5,0x05,0xE0,0x0A,0x90,
|
||
|
0x07,0xBD,0xD3,0xBB,0x20,0xA3,0xBB,0x18,
|
||
|
0x49,0xFF,0x65,0x03,0x85,0x07,0x20,0xCC,
|
||
|
0xBB,0x20,0xCC,0xBB,0x20,0xCC,0xBB,0xC6,
|
||
|
0x08,0xD0,0xF9,0xF0,0xA4,0x98,0x99,0x00,
|
||
|
0xBC,0x99,0x3E,0xBC,0xC8,0xD0,0xF7,0xA2,
|
||
|
0x03,0xBD,0xF6,0xBB,0x20,0xA3,0xBB,0x7D,
|
||
|
0xF9,0xBB,0x95,0x06,0x8D,0xFB,0xBB,0xCA,
|
||
|
0xD0,0xEF,0xA9,0x84,0x20,0xA3,0xBB,0xBC,
|
||
|
0xE4,0xBB,0x99,0x00,0xBC,0xA0,0x00,0xE8,
|
||
|
0xE4,0x07,0x90,0xEE,0x98,0x99,0x3E,0xBD,
|
||
|
0xC8,0xD0,0xFA,0xBE,0x00,0xBC,0xFE,0x5E,
|
||
|
0xBD,0xFE,0x3E,0xBD,0xC0,0x3E,0xB0,0x09,
|
||
|
0xBE,0x00,0xBD,0xFE,0x6E,0xBD,0xFE,0x3E,
|
||
|
0xBD,0xC8,0xD0,0xE7,0xA2,0xD0,0x9D,0xBE,
|
||
|
0xBC,0x18,0x7D,0x8E,0xBC,0xE8,0xD0,0xF6,
|
||
|
0x98,0xBE,0x00,0xBC,0xBC,0x8E,0xBD,0xFE,
|
||
|
0x8E,0xBD,0x99,0xBE,0xBD,0xA8,0xC0,0x3E,
|
||
|
0xB0,0x0D,0xBE,0x00,0xBD,0xBC,0x9E,0xBD,
|
||
|
0xFE,0x9E,0xBD,0x99,0xBE,0xBE,0xA8,0xC8,
|
||
|
0xD0,0xDE,0x60,0xA2,0x00,0x98,0x20,0xB9,
|
||
|
0xBB,0x2A,0xE8,0x38,0xFD,0x3E,0xBD,0xB0,
|
||
|
0xF5,0x7D,0x6E,0xBD,0xB0,0x09,0x7D,0x8E,
|
||
|
0xBD,0xAA,0xBD,0xBE,0xBD,0x18,0x60,0x18,
|
||
|
0x7D,0x9D,0xBD,0xAA,0xBD,0xBE,0xBE,0x38,
|
||
|
0x60,0x26,0x05,0xAA,0xC9,0x09,0xB0,0x10,
|
||
|
0xBD,0xDB,0xBB,0x20,0xB2,0xBB,0x46,0x05,
|
||
|
0x6A,0x90,0xFB,0x60,0x20,0xB0,0xBB,0xAA,
|
||
|
0xA9,0x80,0x20,0xB9,0xBB,0x6A,0x90,0xFA,
|
||
|
0x60,0x46,0x04,0xD0,0x0E,0x48,0xB1,0x00,
|
||
|
0xE6,0x00,0xD0,0x02,0xE6,0x01,0x38,0x6A,
|
||
|
0x85,0x04,0x68,0x60,0xA4,0x02,0xB1,0x06,
|
||
|
0xA0,0x00,0x91,0x02,0xE6,0x02,0xD0,0x04,
|
||
|
0xE6,0x03,0xE6,0x07,0x60,0x81,0x82,0x84,
|
||
|
0x88,0x90,0xA0,0xC0,0x82,0x84,0xC0,0x00,
|
||
|
0x08,0x07,0x09,0x06,0x0A,0x05,0x0B,0x04,
|
||
|
0x0C,0x03,0x0D,0x02,0x0E,0x01,0x0F,0x88,
|
||
|
0x90,0x90,0x03,0x00,0x00
|
||
|
};
|
||
|
/*
|
||
|
;fastload9600.s
|
||
|
|
||
|
org = $BE80 ; should be $BE80
|
||
|
cout = $FDED ; character out sub
|
||
|
crout = $FD8E ; CR out sub
|
||
|
prbyte = $FDDA
|
||
|
warm = $FF69 ; back to monitor
|
||
|
tapein = $C060
|
||
|
pointer = $06
|
||
|
endbas = $80C
|
||
|
;target = $1000
|
||
|
target = $801
|
||
|
chksum = $00
|
||
|
inflate = $BA00
|
||
|
inf_zp = $0
|
||
|
|
||
|
start:
|
||
|
.org endbas
|
||
|
move:
|
||
|
ldx #0
|
||
|
move1: lda moved,x
|
||
|
sta fast,x
|
||
|
inx
|
||
|
bne move1 ; move 256 bytes
|
||
|
; ldx #0
|
||
|
move2: lda moved+256,x
|
||
|
sta fast+256,x
|
||
|
inx
|
||
|
bpl move2 ; only 128 bytes to move
|
||
|
jmp fast
|
||
|
moved:
|
||
|
.org org
|
||
|
fast:
|
||
|
lda #<loadm
|
||
|
ldy #>loadm
|
||
|
jsr print
|
||
|
|
||
|
lda #$ff
|
||
|
sta chksum
|
||
|
|
||
|
lda ld_beg ; setup point to target
|
||
|
sta store+1
|
||
|
lda ld_beg+1
|
||
|
sta store+2
|
||
|
|
||
|
wait: bit tapein
|
||
|
bpl wait
|
||
|
waithi: bit tapein ; Wait for input to go high.
|
||
|
bmi waithi
|
||
|
pre: lda #1 ; Load sentinel bit
|
||
|
ldx #0 ; Clear data index
|
||
|
clc ; Clear carry (byte complete flag)
|
||
|
data: bcc waitlo ; Skip if byte not complete
|
||
|
store: sta store,x ; Store data byte
|
||
|
|
||
|
eor chksum
|
||
|
sta chksum
|
||
|
|
||
|
lda #1 ; Re-load sentinel bit
|
||
|
waitlo: bit tapein ; Wait for input to go low
|
||
|
bpl waitlo
|
||
|
bcc poll9 ; Poll at +9 cycles if no store
|
||
|
inx ; Stored, so increment data index
|
||
|
bne poll13 ; Poll at +13 cycles if no carry
|
||
|
inc store+2 ; Increment data page
|
||
|
bne poll21 ; (always) poll at +21 cycles
|
||
|
|
||
|
one: sec ; one bit detected
|
||
|
rol ; shift it into A
|
||
|
jmp data ; and go handle data (C = sentinel)
|
||
|
|
||
|
zero: clc ; zero bit detected
|
||
|
rol ; shift it into A
|
||
|
jmp data ; and go handle data (C = sentinel)
|
||
|
|
||
|
poll9: bit tapein
|
||
|
bpl zero ; zero bit (short)(9-15 cycles)
|
||
|
poll13: bit tapein ; (2 cycles early if branched here)
|
||
|
bpl zero ; zero bit (15-21 cycles)
|
||
|
poll21: bit tapein
|
||
|
bpl zero ; zero bit (21-27 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; zero bit (27-33 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; zero bit (33-39 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; zero bit (39-45 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; zero bit (45-51 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; zero bit (51-57 cycles)
|
||
|
bit tapein
|
||
|
bpl zero ; one bit (57-63 cycles)
|
||
|
bit tapein
|
||
|
bpl one ; one bit (63-69 cycles)
|
||
|
bit tapein
|
||
|
bpl one ; one bit (69-75 cycles)
|
||
|
bit tapein
|
||
|
bpl one ; one bit (75-81 cycles)
|
||
|
bit tapein
|
||
|
bpl one ; pre pulse (81-87 cycles)
|
||
|
bit tapein
|
||
|
bpl pre ; pre pulse (87-93 cycles)
|
||
|
bit tapein
|
||
|
bpl pre ; pre pulse (93-99 cycles)
|
||
|
bit tapein
|
||
|
bpl pre ; pre pulse (99-105 cycles)
|
||
|
|
||
|
endcode:
|
||
|
txa ; write end of file location + 1
|
||
|
clc
|
||
|
adc store+1
|
||
|
sta store+1
|
||
|
bcc endcheck
|
||
|
inc store+2
|
||
|
endcheck:
|
||
|
lda ld_end
|
||
|
cmp store+1
|
||
|
bne error
|
||
|
lda ld_end+1
|
||
|
cmp store+2
|
||
|
bne error
|
||
|
sumcheck:
|
||
|
lda chksum
|
||
|
bne sumerror
|
||
|
lda inf_flag ; if inf_flag = 0 runit
|
||
|
beq runit
|
||
|
inf:
|
||
|
jsr crout
|
||
|
lda #<infm
|
||
|
ldy #>infm
|
||
|
jsr print
|
||
|
|
||
|
lda inf_src ;src lsb
|
||
|
sta inf_zp+0
|
||
|
lda inf_src+1 ;src msb
|
||
|
sta inf_zp+1
|
||
|
lda inf_dst ;dst lsb
|
||
|
sta inf_zp+2
|
||
|
lda inf_dst+1 ;dst msb
|
||
|
sta inf_zp+3
|
||
|
|
||
|
jsr inflate
|
||
|
|
||
|
lda inf_end ;dst end +1 lsb
|
||
|
cmp inf_zp+2
|
||
|
bne error
|
||
|
lda inf_end+1 ;dst end +1 msb
|
||
|
cmp inf_zp+3
|
||
|
bne error
|
||
|
runit:
|
||
|
lda warm_flag ; if warm_flag = 1 warm boot
|
||
|
bne warmit
|
||
|
jmp (runcode)
|
||
|
warmit:
|
||
|
jmp warm ; run it
|
||
|
sumerror:
|
||
|
jsr crout
|
||
|
lda #<chkm
|
||
|
ldy #>chkm
|
||
|
jsr print
|
||
|
error:
|
||
|
lda #<errm
|
||
|
ldy #>errm
|
||
|
jsr print
|
||
|
jmp warm
|
||
|
print:
|
||
|
sta pointer
|
||
|
sty pointer+1
|
||
|
ldy #0
|
||
|
lda (pointer),y ; load initial char
|
||
|
print1: ora #$80
|
||
|
jsr cout
|
||
|
iny
|
||
|
lda (pointer),y
|
||
|
bne print1
|
||
|
rts
|
||
|
chkm: .asciiz "CHKSUM "
|
||
|
errm: .asciiz "ERROR"
|
||
|
infm: .asciiz "INFLATING "
|
||
|
ld_beg:
|
||
|
.org *+2
|
||
|
ld_end:
|
||
|
.org *+2
|
||
|
inf_src:
|
||
|
.org *+2
|
||
|
runcode:
|
||
|
inf_dst:
|
||
|
.org *+2
|
||
|
inf_end:
|
||
|
.org *+2
|
||
|
inf_flag:
|
||
|
.org *+1
|
||
|
warm_flag:
|
||
|
.org *+1
|
||
|
loadm:
|
||
|
;.asciiz "LOADING "
|
||
|
|
||
|
end:
|
||
|
|
||
|
*/
|
||
|
unsigned char fastload9600[] = {
|
||
|
0xA2,0x00,0xBD,0x23,
|
||
|
0x08,0x9D,0x80,0xBE,0xE8,0xD0,0xF7,0xBD,
|
||
|
0x23,0x09,0x9D,0x80,0xBF,0xE8,0x10,0xF7,
|
||
|
0x4C,0x80,0xBE,0xA9,0xC6,0xA0,0xBF,0x20,
|
||
|
0x8E,0xBF,0xA9,0xFF,0x85,0x00,0xAD,0xBA,
|
||
|
0xBF,0x8D,0xA9,0xBE,0xAD,0xBB,0xBF,0x8D,
|
||
|
0xAA,0xBE,0x2C,0x60,0xC0,0x10,0xFB,0x2C,
|
||
|
0x60,0xC0,0x30,0xFB,0xA9,0x01,0xA2,0x00,
|
||
|
0x18,0x90,0x09,0x9D,0xA8,0xBE,0x45,0x00,
|
||
|
0x85,0x00,0xA9,0x01,0x2C,0x60,0xC0,0x10,
|
||
|
0xFB,0x90,0x12,0xE8,0xD0,0x14,0xEE,0xAA,
|
||
|
0xBE,0xD0,0x14,0x38,0x2A,0x4C,0xA6,0xBE,
|
||
|
0x18,0x2A,0x4C,0xA6,0xBE,0x2C,0x60,0xC0,
|
||
|
0x10,0xF6,0x2C,0x60,0xC0,0x10,0xF1,0x2C,
|
||
|
0x60,0xC0,0x10,0xEC,0x2C,0x60,0xC0,0x10,
|
||
|
0xE7,0x2C,0x60,0xC0,0x10,0xE2,0x2C,0x60,
|
||
|
0xC0,0x10,0xDD,0x2C,0x60,0xC0,0x10,0xD8,
|
||
|
0x2C,0x60,0xC0,0x10,0xD3,0x2C,0x60,0xC0,
|
||
|
0x10,0xCE,0x2C,0x60,0xC0,0x10,0xC4,0x2C,
|
||
|
0x60,0xC0,0x10,0xBF,0x2C,0x60,0xC0,0x10,
|
||
|
0xBA,0x2C,0x60,0xC0,0x10,0xB5,0x2C,0x60,
|
||
|
0xC0,0x10,0x91,0x2C,0x60,0xC0,0x10,0x8C,
|
||
|
0x2C,0x60,0xC0,0x10,0x87,0x8A,0x18,0x6D,
|
||
|
0xA9,0xBE,0x8D,0xA9,0xBE,0x90,0x03,0xEE,
|
||
|
0xAA,0xBE,0xAD,0xBC,0xBF,0xCD,0xA9,0xBE,
|
||
|
0xD0,0x55,0xAD,0xBD,0xBF,0xCD,0xAA,0xBE,
|
||
|
0xD0,0x4D,0xA5,0x00,0xD0,0x3F,0xAD,0xC4,
|
||
|
0xBF,0xF0,0x2F,0x20,0x8E,0xFD,0xA9,0xAF,
|
||
|
0xA0,0xBF,0x20,0x8E,0xBF,0xAD,0xBE,0xBF,
|
||
|
0x85,0x00,0xAD,0xBF,0xBF,0x85,0x01,0xAD,
|
||
|
0xC0,0xBF,0x85,0x02,0xAD,0xC1,0xBF,0x85,
|
||
|
0x03,0x20,0x00,0xBA,0xAD,0xC2,0xBF,0xC5,
|
||
|
0x02,0xD0,0x1C,0xAD,0xC3,0xBF,0xC5,0x03,
|
||
|
0xD0,0x15,0xAD,0xC5,0xBF,0xD0,0x03,0x6C,
|
||
|
0xC0,0xBF,0x4C,0x69,0xFF,0x20,0x8E,0xFD,
|
||
|
0xA9,0xA1,0xA0,0xBF,0x20,0x8E,0xBF,0xA9,
|
||
|
0xA9,0xA0,0xBF,0x20,0x8E,0xBF,0x4C,0x69,
|
||
|
0xFF,0x85,0x06,0x84,0x07,0xA0,0x00,0xB1,
|
||
|
0x06,0x09,0x80,0x20,0xED,0xFD,0xC8,0xB1,
|
||
|
0x06,0xD0,0xF6,0x60,0x43,0x48,0x4B,0x53,
|
||
|
0x55,0x4D,0x20,0x00,0x45,0x52,0x52,0x4F,
|
||
|
0x52,0x00,0x49,0x4E,0x46,0x4C,0x41,0x54,
|
||
|
0x49,0x4E,0x47,0x20,0x00
|
||
|
};
|
||
|
/*
|
||
|
;fastload8000.s
|
||
|
|
||
|
org = $BE80 ; should be $BE80
|
||
|
cout = $FDED ; character out sub
|
||
|
crout = $FD8E ; CR out sub
|
||
|
prbyte = $FDDA
|
||
|
warm = $FF69 ; back to monitor
|
||
|
tapein = $C060
|
||
|
pointer = $06
|
||
|
endbas = $80C
|
||
|
;target = $1000
|
||
|
target = $801
|
||
|
chksum = $00
|
||
|
inflate = $BA00
|
||
|
inf_zp = $0
|
||
|
|
||
|
start:
|
||
|
.org endbas
|
||
|
move:
|
||
|
ldx #0
|
||
|
move1: lda moved,x
|
||
|
sta fast,x
|
||
|
inx
|
||
|
bne move1 ; move 256 bytes
|
||
|
; ldx #0
|
||
|
move2: lda moved+256,x
|
||
|
sta fast+256,x
|
||
|
inx
|
||
|
bpl move2 ; only 128 bytes to move
|
||
|
jmp fast
|
||
|
moved:
|
||
|
.org org
|
||
|
fast:
|
||
|
lda #<loadm
|
||
|
ldy #>loadm
|
||
|
jsr print
|
||
|
|
||
|
lda ld_beg ; load begin LSB location
|
||
|
sta store+1 ; store it
|
||
|
lda ld_beg+1 ; load begin MSB location
|
||
|
sta store+2 ; store it
|
||
|
|
||
|
ldx #0 ; set X to 0
|
||
|
lda #1 ; set A to 0
|
||
|
|
||
|
nsync: bit tapein ; 4 cycles, sync bit ; first pulse
|
||
|
bpl nsync ; 2 + 1 cycles
|
||
|
|
||
|
main: ldy #0 ; 2 set Y to 0
|
||
|
|
||
|
psync: bit tapein ;
|
||
|
bmi psync
|
||
|
|
||
|
ploop: iny ; 2 cycles
|
||
|
bit tapein ; 4 cycles
|
||
|
bpl ploop ; 2 +1 if branch, +1 if in another page
|
||
|
; total ~9 cycles
|
||
|
|
||
|
cpy #$40 ; 2 cycles if Y - $40 > 0 endcode (770Hz)
|
||
|
bpl endcode ; 2(3)
|
||
|
|
||
|
cpy #$15 ; 2 cycles if Y - $15 > 0 main (2000Hz)
|
||
|
bpl main ; 2(3)
|
||
|
|
||
|
cpy #$07 ; 2, if Y<, then clear carry, if Y>= set carry
|
||
|
store: rol store+1,x ; 7, roll carry bit into store
|
||
|
ldy #0 ; 2
|
||
|