OpenCores
URL https://opencores.org/ocsvn/hdl-deflate/hdl-deflate/trunk

Subversion Repositories hdl-deflate

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /hdl-deflate
    from Rev 5 to Rev 6
    ↔ Reverse comparison
  •

Rev 5 → Rev 6

/trunk/deflate.py
18,6 → 18,12
IDLE, RESET, WRITE, READ, STARTC, STARTD = range(6)
 
COMPRESS = True
DECOMPRESS = False
DECOMPRESS = True
 
DYNAMIC = False
DYNAMIC = True
 
MATCH10 = False
MATCH10 = True
 
27,8 → 33,15
CWINDOW = 32 # Search window for compression
 
OBSIZE = 8192 # Size of output buffer (BRAM)
IBSIZE = 4 * CWINDOW # 2048 # Size of input buffer (LUT-RAM)
OBSIZE = 32768 # Size of output buffer for ANY input (BRAM)
 
# Size of input buffer (LUT-RAM)
IBSIZE = 16 * CWINDOW # This size gives method 2 (dynamic tree) for testbench
IBSIZE = 2 * CWINDOW # Minimal window
 
LMAX = 24 # Size of progress and I/O counters
 
 
if OBSIZE > IBSIZE:
LBSIZE = int(log2(OBSIZE))
else:
35,13 → 48,16
LBSIZE = int(log2(IBSIZE))
 
LIBSIZE = int(log2(IBSIZE))
LOBSIZE = int(log2(OBSIZE))
 
IBS = (1 << LIBSIZE) - 1
OBS = (1 << LOBSIZE) - 1
 
d_state = enum('IDLE', 'HEADER', 'BL', 'READBL', 'REPEAT', 'DISTTREE', 'INIT3',
'HF1', 'HF1INIT', 'HF2', 'HF3', 'HF4', 'HF4_2', 'HF4_3',
'STATIC', 'D_NEXT', 'D_NEXT_2',
'D_INFLATE', 'SPREAD', 'NEXT', 'INFLATE', 'COPY', 'CSTATIC',
'SEARCH', 'DISTANCE', 'CHECKSUM') # , encoding='one_hot')
'SEARCH', 'SEARCHF', 'DISTANCE', 'CHECKSUM') # , encoding='one_hot')
 
CodeLengthOrder = (16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14,
1, 15)
58,10 → 74,49
 
ExtraDistanceBits = (0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
 
out_codes = (
0x00c, 0x08c, 0x04c, 0x0cc, 0x02c, 0x0ac, 0x06c, 0x0ec,
0x01c, 0x09c, 0x05c, 0x0dc, 0x03c, 0x0bc, 0x07c, 0x0fc,
0x002, 0x082, 0x042, 0x0c2, 0x022, 0x0a2, 0x062, 0x0e2,
0x012, 0x092, 0x052, 0x0d2, 0x032, 0x0b2, 0x072, 0x0f2,
0x00a, 0x08a, 0x04a, 0x0ca, 0x02a, 0x0aa, 0x06a, 0x0ea,
0x01a, 0x09a, 0x05a, 0x0da, 0x03a, 0x0ba, 0x07a, 0x0fa,
0x006, 0x086, 0x046, 0x0c6, 0x026, 0x0a6, 0x066, 0x0e6,
0x016, 0x096, 0x056, 0x0d6, 0x036, 0x0b6, 0x076, 0x0f6,
0x00e, 0x08e, 0x04e, 0x0ce, 0x02e, 0x0ae, 0x06e, 0x0ee,
0x01e, 0x09e, 0x05e, 0x0de, 0x03e, 0x0be, 0x07e, 0x0fe,
0x001, 0x081, 0x041, 0x0c1, 0x021, 0x0a1, 0x061, 0x0e1,
0x011, 0x091, 0x051, 0x0d1, 0x031, 0x0b1, 0x071, 0x0f1,
0x009, 0x089, 0x049, 0x0c9, 0x029, 0x0a9, 0x069, 0x0e9,
0x019, 0x099, 0x059, 0x0d9, 0x039, 0x0b9, 0x079, 0x0f9,
0x005, 0x085, 0x045, 0x0c5, 0x025, 0x0a5, 0x065, 0x0e5,
0x015, 0x095, 0x055, 0x0d5, 0x035, 0x0b5, 0x075, 0x0f5,
0x00d, 0x08d, 0x04d, 0x0cd, 0x02d, 0x0ad, 0x06d, 0x0ed,
0x01d, 0x09d, 0x05d, 0x0dd, 0x03d, 0x0bd, 0x07d, 0x0fd,
0x013, 0x113, 0x093, 0x193, 0x053, 0x153, 0x0d3, 0x1d3,
0x033, 0x133, 0x0b3, 0x1b3, 0x073, 0x173, 0x0f3, 0x1f3,
0x00b, 0x10b, 0x08b, 0x18b, 0x04b, 0x14b, 0x0cb, 0x1cb,
0x02b, 0x12b, 0x0ab, 0x1ab, 0x06b, 0x16b, 0x0eb, 0x1eb,
0x01b, 0x11b, 0x09b, 0x19b, 0x05b, 0x15b, 0x0db, 0x1db,
0x03b, 0x13b, 0x0bb, 0x1bb, 0x07b, 0x17b, 0x0fb, 0x1fb,
0x007, 0x107, 0x087, 0x187, 0x047, 0x147, 0x0c7, 0x1c7,
0x027, 0x127, 0x0a7, 0x1a7, 0x067, 0x167, 0x0e7, 0x1e7,
0x017, 0x117, 0x097, 0x197, 0x057, 0x157, 0x0d7, 0x1d7,
0x037, 0x137, 0x0b7, 0x1b7, 0x077, 0x177, 0x0f7, 0x1f7,
0x00f, 0x10f, 0x08f, 0x18f, 0x04f, 0x14f, 0x0cf, 0x1cf,
0x02f, 0x12f, 0x0af, 0x1af, 0x06f, 0x16f, 0x0ef, 0x1ef,
0x01f, 0x11f, 0x09f, 0x19f, 0x05f, 0x15f, 0x0df, 0x1df,
0x03f, 0x13f, 0x0bf, 0x1bf, 0x07f, 0x17f, 0x0ff, 0x1ff,
0x000, 0x040, 0x020, 0x060, 0x010, 0x050, 0x030, 0x070,
0x008, 0x048, 0x028, 0x068, 0x018, 0x058, 0x038, 0x078,
0x004, 0x044, 0x024, 0x064, 0x014, 0x054, 0x034, 0x074,
0x003, 0x083, 0x043, 0x0c3, 0x023, 0x0a3, 0x063, 0x0e3
)
 
 
@block
def deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress, o_byte, i_addr,
clk, reset):
def deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress, o_byte,
i_waddr, i_raddr, clk, reset):
 
""" Deflate (de)compress
 
72,17 → 127,18
iram = [Signal(intbv()[8:]) for _ in range(IBSIZE)]
oram = [Signal(intbv()[8:]) for _ in range(OBSIZE)]
 
oaddr = Signal(intbv()[LBSIZE:])
oraddr = Signal(intbv()[LBSIZE:])
oaddr = Signal(modbv()[LOBSIZE:])
oraddr = Signal(modbv()[LOBSIZE:])
obyte = Signal(intbv()[8:])
orbyte = Signal(intbv()[8:])
 
iraddr = Signal(intbv()[LIBSIZE:])
# iraddr = Signal(modbv()[LIBSIZE:])
 
isize = Signal(intbv()[LBSIZE:])
isize = Signal(intbv()[LMAX:])
state = Signal(d_state.IDLE)
method = Signal(intbv()[3:])
final = Signal(bool())
wtick = Signal(bool())
do_compress = Signal(bool())
 
numLiterals = Signal(intbv()[9:])
98,22 → 154,32
# MaxToken = 285
InvalidToken = 300
 
CODEBITS = 10 # MaxCodeLength
BITBITS = 9
CODEBITS = MaxCodeLength
BITBITS = 4
 
codeLength = [Signal(intbv()[4:]) for _ in range(MaxBitLength+2)]
codeLength = [Signal(intbv()[4:]) for _ in range(MaxBitLength+32)]
bits = Signal(intbv()[4:])
bitLengthCount = [Signal(intbv()[9:]) for _ in range(MaxCodeLength+1)]
nextCode = [Signal(intbv()[CODEBITS:]) for _ in range(MaxCodeLength)]
reverse = Signal(intbv()[CODEBITS:])
code_bits = [Signal(intbv()[9:]) for _ in range(MaxBitLength)]
nextCode = [Signal(intbv()[CODEBITS+1:]) for _ in range(MaxCodeLength+1)]
reverse = Signal(modbv()[CODEBITS:])
# code_bits = [Signal(intbv()[MaxCodeLength:]) for _ in range(MaxBitLength)]
distanceLength = [Signal(intbv()[4:]) for _ in range(32)]
 
leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(512)]
lwaddr = Signal(intbv()[9:])
# lraddr = Signal(intbv()[9:])
d_leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(128)]
# rleaf = Signal(intbv()[CODEBITS + BITBITS:])
if DECOMPRESS:
if DYNAMIC:
leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(16384)]
d_leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(4096)]
else:
leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(512)]
d_leaves = [Signal(bool())]
# leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(32768)]
# d_leaves = [Signal(intbv()[CODEBITS + BITBITS:]) for _ in range(32768)]
else:
leaves = [Signal(bool())]
d_leaves = [Signal(bool())]
lwaddr = Signal(intbv()[MaxCodeLength:])
lraddr = Signal(intbv()[MaxCodeLength:])
rleaf = Signal(intbv()[CODEBITS + BITBITS:])
wleaf = Signal(intbv()[CODEBITS + BITBITS:])
leaf = Signal(intbv()[CODEBITS + BITBITS:])
 
124,8 → 190,8
d_instantMaxBit = Signal(intbv()[InstantMaxBit:])
instantMask = Signal(intbv()[MaxCodeLength:])
d_instantMask = Signal(intbv()[MaxCodeLength:])
spread = Signal(intbv()[10:])
step = Signal(intbv()[10:])
spread = Signal(intbv()[InstantMaxBit:])
step = Signal(intbv()[InstantMaxBit:])
 
static = Signal(bool())
 
133,23 → 199,24
lastToken = Signal(intbv()[15:])
howOften = Signal(intbv()[9:])
 
cur_i = Signal(intbv()[LBSIZE:])
cur_i = Signal(intbv()[LMAX:])
spread_i = Signal(intbv()[9:])
cur_HF1 = Signal(intbv()[10:])
cur_HF1 = Signal(intbv()[MaxCodeLength+1:])
cur_static = Signal(intbv()[9:])
cur_cstatic = Signal(intbv()[LBSIZE:])
cur_search = Signal(intbv(min=-CWINDOW,max=IBSIZE))
cur_cstatic = Signal(intbv()[LMAX:])
# cur_search = Signal(intbv(min=-CWINDOW,max=IBSIZE))
cur_search = Signal(intbv(min=-1,max=1<<LMAX))
cur_dist = Signal(intbv(min=-CWINDOW,max=IBSIZE))
# cur_next = Signal(intbv()[5:])
cur_next = Signal(bool())
cur_next = Signal(intbv()[4:])
# cur_next = Signal(bool())
 
length = Signal(intbv()[LBSIZE:])
offset = Signal(intbv()[LBSIZE:])
length = Signal(modbv()[LOBSIZE:])
offset = Signal(intbv()[LOBSIZE:])
 
di = Signal(intbv()[LBSIZE:])
old_di = Signal(intbv()[LBSIZE:])
di = Signal(modbv()[LMAX:])
old_di = Signal(intbv()[LMAX:])
dio = Signal(intbv()[3:])
do = Signal(intbv()[LBSIZE:])
do = Signal(intbv()[LMAX:])
doo = Signal(intbv()[3:])
 
b1 = Signal(intbv()[8:])
163,6 → 230,7
 
b14 = ConcatSignal(b1, b2, b3, b4)
b14._markUsed()
b15 = ConcatSignal(b1, b2, b3, b4, b5)
 
if MATCH10:
b6 = Signal(intbv()[8:])
202,7 → 270,7
@always(clk.posedge)
def oramread():
orbyte.next = oram[oraddr]
# rleaf.next = leaves[lraddr]
rleaf.next = leaves[lraddr]
 
@block
def matcher3(o_m, mi):
231,7 → 299,8
old_di.next = 0
else:
if isize < 4:
pass
nb.next = 0
old_di.next = 0
elif i_mode == STARTC or i_mode == STARTD:
nb.next = 0
old_di.next = 0
240,25 → 309,23
if do_compress:
print("FILL", di, old_di, nb, b1, b2, b3, b4)
"""
if FAST: # and nb == 4:
if FAST: # and do_compress:
shift = (di - old_di) * 8
"""
if shift != 0:
print("shift", shift, cwindow, b1, b2, b3, b4)
"""
if shift <= 32:
cwindow.next = (cwindow << shift) | (b14 >> (32 - shift))
elif shift == 40:
cwindow.next = (cwindow << shift) | (b14 << 8) | b5
elif MATCH10:
if MATCH10:
cwindow.next = (cwindow << shift) | (b110 >> (80 - shift))
else:
cwindow.next = (cwindow << shift) | (b15 >> (40 - shift))
 
if old_di == di:
nb.next = 4
# wtick.next = True
 
old_di.next = di
 
# iraddr.next = di
# print("B1", iram[di & IBS])
b1.next = iram[di & IBS]
b2.next = iram[di+1 & IBS]
b3.next = iram[di+2 & IBS]
270,77 → 337,6
b8.next = iram[di+7 & IBS]
b9.next = iram[di+8 & IBS]
b10.next = iram[di+9 & IBS]
"""
@always(clk.posedge)
def fill_buf():
if not reset:
print("FILL RESET")
nb.next = 0
old_di.next = 0
b1.next = 0
b2.next = 0
b3.next = 0
b4.next = 0
else:
if isize < 4:
pass
elif i_mode == STARTC or i_mode == STARTD:
nb.next = 0
elif not filled and nb == 4 and di - old_di <= 4:
delta = di - old_di
if delta == 1:
# print("delta == 1")
if FAST:
cwindow.next = (cwindow << 8) | b1
b1.next = b2
b2.next = b3
b3.next = b4
b4.next = iram[di+3 & IBS]
# nb.next = 4
elif delta == 2:
print("delta == 2")
if FAST:
cwindow.next = (cwindow << 16) | (b14 >> 16)
b1.next = b3
b2.next = b4
b3.next = iram[di+2 & IBS]
nb.next = 3
elif delta == 3:
print("delta == 3")
if FAST:
cwindow.next = (cwindow << 24) | (b14 >> 8)
b1.next = b4
b2.next = iram[di+1 & IBS]
nb.next = 2
elif delta == 4:
print("delta == 4")
if FAST:
cwindow.next = (cwindow << 32) | (b14)
b1.next = iram[di & IBS]
nb.next = 1
else:
pass
elif not filled or nb == 0:
print("nb = 0")
b1.next = iram[di & IBS]
nb.next = 1
elif not filled or nb == 1:
print("nb = 1")
b2.next = iram[di+1 & IBS]
nb.next = 2
elif not filled or nb == 2:
print("nb = 2")
# raise Error("nb == 2")
b3.next = iram[di+2 & IBS]
nb.next = 3
elif not filled or nb == 3:
print("nb = 3")
b4.next = iram[di+3 & IBS]
nb.next = 4
else:
pass
old_di.next = di
"""
 
def get4(boffset, width):
if nb != 4:
403,6 → 399,8
if b >= 1 << nb:
raise Error("too few bits")
print("too few bits")
if nb > 15:
raise Error("nb too large")
r = (((b >> 14) & 0x1) << 0) | (((b >> 13) & 0x1) << 1) | \
(((b >> 12) & 0x1) << 2) | (((b >> 11) & 0x1) << 3) | \
(((b >> 10) & 0x1) << 4) | (((b >> 9) & 0x1) << 5) | \
429,21 → 427,12
 
@always(clk.posedge)
def io_logic():
o_byte.next = oram[i_raddr & OBS]
if i_mode == WRITE:
 
# print("WRITE:", i_addr, i_data)
iram[i_addr & IBS].next = i_data
isize.next = i_addr
iram[i_waddr & IBS].next = i_data
isize.next = i_waddr
 
elif i_mode == READ:
 
# o_data.next = oram[i_addr]
# oraddr.next = i_addr
o_byte.next = oram[i_addr]
 
else:
pass
 
@always(clk.posedge)
def logic():
if not reset:
472,7 → 461,7
cur_static.next = 0
state.next = d_state.STATIC
 
elif i_mode == STARTD:
elif DECOMPRESS and i_mode == STARTD:
 
do_compress.next = False
o_done.next = False
491,7 → 480,9
 
elif state == d_state.HEADER:
 
if not filled:
if not DECOMPRESS:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
516,6 → 507,9
print("method", hm)
# print(di, dio, nb, b1, b2, b3, b4, hm, isize)
if hm == 2:
if not DYNAMIC:
print("dynamic tree mode disabled")
raise Error("dynamic tree mode disabled")
state.next = d_state.BL
numCodeLength.next = 0
numLiterals.next = 0
570,17 → 564,20
obyte.next = put(0x3, 3)
put_adv(0x3, 3)
elif flush:
print("flush", do, ob1)
# print("flush", do, ob1)
no_adv = 1
oaddr.next = do
obyte.next = ob1
do_flush()
elif cur_cstatic >= isize - 10 and i_mode != IDLE:
print("P", cur_cstatic, isize)
no_adv = 1
elif cur_cstatic - 3 > isize:
if cur_cstatic - 3 == isize + 1:
print("Put EOF", do)
cs_i = EndOfBlock
outlen = codeLength[cs_i]
outbits = code_bits[cs_i]
outbits = out_codes[cs_i] # code_bits[cs_i]
print("EOF BITS:", cs_i, outlen, outbits)
oaddr.next = do
obyte.next = put(outbits, outlen)
597,32 → 594,34
oaddr.next = do
obyte.next = adler2 >> 8
do.next = do + 1
o_oprogress.next = do + 1
elif cur_cstatic - 3 == isize + 4:
print("c2")
oaddr.next = do
obyte.next = adler2 & 0xFF
do.next = do + 1
o_oprogress.next = do + 1
elif cur_cstatic - 3 == isize + 5:
print("c3")
oaddr.next = do
obyte.next = adler1 >> 8
do.next = do + 1
o_oprogress.next = do + 1
elif cur_cstatic - 3 == isize + 6:
print("c4")
oaddr.next = do
obyte.next = adler1 & 0xFF
o_oprogress.next = do + 1
elif cur_cstatic - 3 == isize + 7:
print("EOF finish", do)
o_done.next = True
o_oprogress.next = do + 1
state.next = d_state.IDLE
else:
print(cur_cstatic, isize)
raise Error("???")
else:
bdata = iram[di]
# Fix this when > 1 byte output:
# print("cs1", bdata)
bdata = iram[di & IBS]
o_iprogress.next = di # & IBS
adler1_next = (adler1 + bdata) % 65521
adler1.next = adler1_next
adler2.next = (adler2 + ladler1) % 65521
629,7 → 628,7
ladler1.next = adler1_next
# print("in: ", bdata, di, isize)
state.next = d_state.SEARCH
cur_search.next = di - 1
cur_search.next = di - 1 # & IBS
 
if not no_adv:
cur_cstatic.next = cur_cstatic + 1
640,6 → 639,16
pass
elif flush:
do_flush()
elif cur_i == 1024:
lencode = length + 254
# print("fast:", distance, di, isize, match)
outlen = codeLength[lencode]
outbits = out_codes[lencode] # code_bits[lencode]
# print("BITS:", outlen, outbits)
oaddr.next = do
obyte.next = put(outbits, outlen)
put_adv(outbits, outlen)
cur_i.next = 0
else:
# print("DISTANCE", di, do, cur_i, cur_dist)
nextdist = CopyDistance[cur_i+1]
679,6 → 688,56
else:
state.next = d_state.CSTATIC
 
elif state == d_state.SEARCHF:
 
if FAST and COMPRESS:
lfmatch = length
distance = lfmatch + 1
# print("FSEARCH", distance)
fmatch2 = di - lfmatch + 2
# Length is 3 code
lencode = 257
match = 3
 
if di < isize - 4 and \
iram[fmatch2 & IBS] == b4:
lencode = 258
match = 4
if di < isize - 5 and \
iram[fmatch2+1 & IBS] == b5:
lencode = 259
match = 5
if MATCH10 and di < isize - 6 and \
iram[fmatch2+2 & IBS] == b6:
lencode = 260
match = 6
if di < isize - 7 and \
iram[fmatch2+3 & IBS] == b7:
lencode = 261
match = 7
if di < isize - 8 and \
iram[fmatch2+4 & IBS] == b8:
lencode = 262
match = 8
if di < isize - 9 and \
iram[fmatch2+5 & IBS] == b9:
lencode = 263
match = 9
if di < isize - 10 and \
iram[fmatch2+6 & IBS] == b10:
lencode = 264
match = 10
 
# distance = di - cur_search
# print("d/l", di, distance, match)
cur_dist.next = distance
cur_i.next = 1024
# adv(match * 8)
di.next = di + match
cur_cstatic.next = cur_cstatic + match - 1
length.next = match
state.next = d_state.DISTANCE
 
elif state == d_state.SEARCH:
 
if not COMPRESS:
688,6 → 747,7
elif nb < 4:
pass
else:
# print("cs", cur_search, di, di - CWINDOW)
if cur_search >= 0 \
and cur_search >= di - CWINDOW \
and di < isize - 3:
698,7 → 758,7
for si in range(CWINDOW):
# print("test", di, si, di - si - 1)
if smatch[si]:
print("fmatch", si)
# print("fmatch", si)
fmatch = si
found = 1
break
706,61 → 766,10
cur_search.next = -1
# print("NO FSEARCH")
else:
distance = fmatch + 1
# print("FSEARCH", distance)
fmatch = di - fmatch + 2
# Length is 3 code
lencode = 257
match = 3
length.next = fmatch
state.next = d_state.SEARCHF
 
if di < isize - 4 and \
iram[fmatch & IBS] == b4:
lencode = 258
match = 4
if di < isize - 5 and \
iram[fmatch+1 & IBS] == b5:
lencode = 259
match = 5
if MATCH10 and di < isize - 6 and \
iram[fmatch+2 & IBS] == b6:
lencode = 260
match = 6
if di < isize - 7 and \
iram[fmatch+3 & IBS] == b7:
lencode = 261
match = 7
if di < isize - 8 and \
iram[fmatch+4 & IBS] == b8:
lencode = 262
match = 8
if di < isize - 9 and \
iram[fmatch+5 & IBS] == b9:
lencode = 263
match = 9
if di < isize - 10 and \
iram[fmatch+6 & IBS] == b10:
lencode = 264
match = 10
 
print("fast:", distance, di, isize, match)
outlen = codeLength[lencode]
outbits = code_bits[lencode]
# print("BITS:", outlen, outbits)
oaddr.next = do
obyte.next = put(outbits, outlen)
put_adv(outbits, outlen)
 
# distance = di - cur_search
# print("distance", distance)
cur_dist.next = distance
cur_i.next = 0
# adv(match * 8)
di.next = di + match
cur_cstatic.next = cur_cstatic + match - 1
length.next = match
state.next = d_state.DISTANCE
 
elif iram[cur_search & IBS] == b1 and \
elif not FAST and iram[cur_search & IBS] == b1 and \
iram[cur_search+1 & IBS] == b2 and \
iram[cur_search+2 & IBS] == b3:
# Length is 3 code
772,42 → 781,34
lencode = 258
match = 4
if di < isize - 5 and \
iram[cur_search+4 & IBS] == iram[di + 4 & IBS]:
iram[cur_search+4 & IBS] == b5:
lencode = 259
match = 5
if MATCH10 and di < isize - 6 and \
iram[cur_search+5 & IBS] == iram[di + 5 & IBS]:
iram[cur_search+5 & IBS] == b6:
lencode = 260
match = 6
if di < isize - 7 and \
iram[cur_search+6 & IBS] == iram[di + 6 & IBS]:
iram[cur_search+6 & IBS] == b7:
lencode = 261
match = 7
if di < isize - 8 and \
iram[cur_search+7 & IBS] == iram[di + 7 & IBS]:
iram[cur_search+7 & IBS] == b8:
lencode = 262
match = 8
if di < isize - 9 and \
iram[cur_search+8 & IBS] == iram[di + 8 & IBS]:
iram[cur_search+8 & IBS] == b9:
lencode = 263
match = 9
if di < isize - 10 and \
iram[cur_search+9 & IBS] == iram[di + 9 & IBS]:
iram[cur_search+9 & IBS] == b10:
lencode = 264
match = 10
 
print("found:", cur_search, di, isize, match)
outlen = codeLength[lencode]
outbits = code_bits[lencode]
# print("BITS:", outlen, outbits)
oaddr.next = do
obyte.next = put(outbits, outlen)
put_adv(outbits, outlen)
 
distance = di - cur_search
# print("distance", distance)
cur_dist.next = distance
cur_i.next = 0
cur_i.next = 1024 # 0
# adv(match * 8)
di.next = di + match
cur_cstatic.next = cur_cstatic + match - 1
817,11 → 818,11
cur_search.next = cur_search - 1
else:
# print("NO MATCH")
bdata = iram[di]
bdata = b1 # iram[di]
# adv(8)
di.next = di + 1
outlen = codeLength[bdata]
outbits = code_bits[bdata]
outbits = out_codes[bdata] # code_bits[bdata]
# print("CBITS:", bdata, outlen, outbits)
oaddr.next = do
obyte.next = put(outbits, outlen)
839,32 → 840,22
for stat_i in range(280, 288):
codeLength[stat_i].next = 8
numCodeLength.next = 288
cur_HF1.next = 0
state.next = d_state.HF1
"""
if cur_static < 288:
if cur_static < 144:
codeLength[cur_static].next = 8
elif cur_static < 256:
codeLength[cur_static].next = 9
elif cur_static < 280:
codeLength[cur_static].next = 7
else:
codeLength[cur_static].next = 8
cur_static.next = cur_static + 1
if do_compress:
state.next = d_state.CSTATIC
else:
numCodeLength.next = 288
cur_HF1.next = 0
state.next = d_state.HF1
"""
 
elif state == d_state.BL:
 
if not filled:
if not DECOMPRESS or not DYNAMIC:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
elif numLiterals == 0:
print(di, isize)
numLiterals.next = 257 + get4(0, 5)
print("NL:", 257 + get4(0, 5))
numDistance.next = 1 + get4(5, 5)
891,7 → 882,9
 
elif state == d_state.READBL:
 
if not filled:
if not DECOMPRESS or not DYNAMIC:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
937,31 → 930,34
 
elif state == d_state.INIT3:
 
if cur_i < MaxBitLength:
codeLength[cur_i].next = 0
cur_i.next = cur_i + 1
else:
numCodeLength.next = MaxBitLength
method.next = 3 # Start building bit tree
cur_HF1.next = 0
state.next = d_state.HF1
if not DECOMPRESS:
pass
elif cur_i < len(codeLength): # MaxBitLength:
codeLength[cur_i].next = 0
cur_i.next = cur_i + 1
else:
# numCodeLength.next = MaxBitLength
method.next = 3 # Start building bit tree
cur_HF1.next = 0
state.next = d_state.HF1
 
elif state == d_state.DISTTREE:
 
print("DISTTREE")
for dist_i in range(32):
codeLength[dist_i].next = distanceLength[dist_i]
# print(dist_i, distanceLength[dist_i])
numCodeLength.next = 32
method.next = 4 # Start building dist tree
# cur_i.next = 0
cur_HF1.next = 0
state.next = d_state.HF1
if DECOMPRESS and DYNAMIC:
print("DISTTREE")
for dist_i in range(32):
codeLength[dist_i].next = distanceLength[dist_i]
# print(dist_i, distanceLength[dist_i])
numCodeLength.next = 32
method.next = 4 # Start building dist tree
cur_HF1.next = 0
state.next = d_state.HF1
 
elif state == d_state.REPEAT:
 
# print("HOWOFTEN: ", numCodeLength, howOften)
if howOften != 0:
if not DECOMPRESS:
pass
elif howOften != 0:
codeLength[numCodeLength].next = lastToken
howOften.next = howOften - 1
numCodeLength.next = numCodeLength + 1
973,29 → 969,32
 
elif state == d_state.HF1:
 
if cur_HF1 < len(bitLengthCount):
bitLengthCount[cur_HF1].next = 0
if cur_HF1 < len(d_leaves):
d_leaves[cur_HF1].next = 0
if method != 4 and cur_HF1 < len(leaves):
lwaddr.next = cur_HF1
wleaf.next = 0
# leaves[cur_HF1].next = 0
limit = len(leaves)
if method == 4:
limit = len(d_leaves)
if cur_HF1 < limit:
cur_HF1.next = cur_HF1 + 1
else:
print("DID HF1 INIT")
cur_i.next = 0
state.next = d_state.HF1INIT
if DECOMPRESS:
if cur_HF1 < len(bitLengthCount):
bitLengthCount[cur_HF1].next = 0
if cur_HF1 < len(d_leaves) and DYNAMIC:
d_leaves[cur_HF1].next = 0
if method != 4 and cur_HF1 < len(leaves):
lwaddr.next = cur_HF1
wleaf.next = 0
# leaves[cur_HF1].next = 0
limit = len(leaves)
if method == 4 and DYNAMIC:
limit = len(d_leaves)
if cur_HF1 < limit:
cur_HF1.next = cur_HF1 + 1
else:
print("DID HF1 INIT")
cur_i.next = 0
state.next = d_state.HF1INIT
 
elif state == d_state.HF1INIT:
# get frequencies of each bit length and ignore 0's
 
# print("HF1")
if cur_i < numCodeLength:
if not DECOMPRESS:
pass
elif cur_i < numCodeLength:
j = codeLength[cur_i]
bitLengthCount[j].next = bitLengthCount[j] + 1
# print(cur_i, j, bitLengthCount[j] + 1)
1014,7 → 1013,9
# shortest and longest codes
 
# print("HF2")
if cur_i <= MaxCodeLength:
if not DECOMPRESS:
pass
elif cur_i <= MaxCodeLength:
if bitLengthCount[cur_i] != 0:
if cur_i < minBits:
minBits.next = cur_i
1028,7 → 1029,7
else:
print(minBits, maxBits)
t = InstantMaxBit
if method == 4:
if method == 4 and DYNAMIC:
if t > int(d_maxBits):
t = int(d_maxBits)
d_instantMaxBit.next = t
1050,36 → 1051,40
# find bit code for first element of each bitLength group
 
# print("HF3")
amb = maxBits
if method == 4:
amb = d_maxBits
if cur_i <= amb:
ncode = ((code + bitLengthCount[cur_i - 1]) << 1)
code.next = ncode
nextCode[cur_i].next = ncode
# print(cur_i, ncode)
cur_i.next = cur_i + 1
else:
state.next = d_state.HF4
cur_i.next = 0
spread_i.next = 0
print("to HF4")
if DECOMPRESS:
amb = maxBits
if method == 4 and DYNAMIC:
amb = d_maxBits
if cur_i <= amb:
ncode = ((code + bitLengthCount[cur_i - 1]) << 1)
code.next = ncode
nextCode[cur_i].next = ncode
# print(cur_i, ncode)
cur_i.next = cur_i + 1
else:
state.next = d_state.HF4
cur_i.next = 0
spread_i.next = 0
print("to HF4")
 
elif state == d_state.HF4_2:
 
canonical = nextCode[bits]
nextCode[bits].next = nextCode[bits] + 1
if bits > MaxCodeLength:
raise Error("too many bits: %d" % bits)
# print(canonical, bits)
reverse.next = rev_bits(canonical, bits)
# print("LEAF: ", spread_i, bits, reverse, canonical)
leaf.next = makeLeaf(spread_i, bits)
state.next = d_state.HF4_3
if DECOMPRESS:
canonical = nextCode[bits]
nextCode[bits].next = nextCode[bits] + 1
if bits > MaxCodeLength:
raise Error("too many bits: %d" % bits)
# print(canonical, bits)
reverse.next = rev_bits(canonical, bits)
# print("LEAF: ", spread_i, bits, reverse, canonical)
leaf.next = makeLeaf(spread_i, bits)
state.next = d_state.HF4_3
 
elif state == d_state.HF4_3:
 
if method == 4:
if not DECOMPRESS:
pass
elif method == 4 and DYNAMIC:
d_leaves[reverse].next = leaf # makeLeaf(spread_i, bits)
if bits <= d_instantMaxBit:
if reverse + (1 << bits) <= d_instantMask:
1096,7 → 1101,7
wleaf.next = leaf
lwaddr.next = reverse
# leaves[reverse].next = leaf # makeLeaf(spread_i, bits)
code_bits[spread_i].next = reverse
# code_bits[spread_i].next = reverse
if bits <= instantMaxBit:
if reverse + (1 << bits) <= instantMask:
step.next = 1 << bits
1112,23 → 1117,26
elif state == d_state.HF4:
# create binary codes for each literal
 
if spread_i < numCodeLength:
if not DECOMPRESS:
pass
elif spread_i < numCodeLength:
bits_next = codeLength[spread_i]
if bits_next != 0:
bits.next = bits_next
state.next = d_state.HF4_2
else:
# print("SKIP UNUSED")
spread_i.next = spread_i + 1
else:
if do_compress:
state.next = d_state.CSTATIC
cur_cstatic.next = 0
elif method == 3:
elif method == 3 and DYNAMIC:
state.next = d_state.DISTTREE
elif method == 4:
elif method == 4 and DYNAMIC:
print("DEFLATE m2!")
state.next = d_state.NEXT
elif method == 2:
elif method == 2 and DYNAMIC:
numCodeLength.next = 0
state.next = d_state.NEXT
else:
1138,27 → 1146,30
 
elif state == d_state.SPREAD:
 
if method == 4:
# print(spread, spread_i)
d_leaves[spread].next = makeLeaf(
spread_i, codeLength[spread_i])
else:
lwaddr.next = spread
wleaf.next = makeLeaf(spread_i, codeLength[spread_i])
# leaves[spread].next = makeLeaf(spread_i, codeLength[spread_i])
# print("SPREAD:", spread, step, instantMask)
aim = instantMask
if method == 4:
aim = d_instantMask
if spread > aim - step:
spread_i.next = spread_i + 1
state.next = d_state.HF4
else:
spread.next = spread + step
if DECOMPRESS:
if method == 4 and DYNAMIC:
# print(spread, spread_i)
d_leaves[spread].next = makeLeaf(
spread_i, codeLength[spread_i])
else:
lwaddr.next = spread
wleaf.next = makeLeaf(spread_i, codeLength[spread_i])
# leaves[spread].next = makeLeaf(spread_i, codeLength[spread_i])
# print("SPREAD:", spread, step, instantMask)
aim = instantMask
if method == 4 and DYNAMIC:
aim = d_instantMask
if spread > aim - step:
spread_i.next = spread_i + 1
state.next = d_state.HF4
else:
spread.next = spread + step
 
elif state == d_state.NEXT:
 
if not filled:
if not DECOMPRESS:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
1165,21 → 1176,36
elif cur_next == 0:
# print("INIT:", di, dio, instantMaxBit, maxBits)
cto = get4(0, maxBits)
cur_next.next = 1 # instantMaxBit
mask = (1 << instantMaxBit) - 1
# lraddr.next = (cto & mask)
leaf.next = leaves[cto & mask]
lraddr.next = (cto & mask)
# leaf.next = leaves[cto & mask]
filled.next = False
cur_next.next = instantMaxBit + 1
# print(cur_next, mask, leaf, maxBits)
# elif get_bits(leaf) >= cur_next:
elif get_bits(rleaf) >= cur_next:
print("CACHE MISS", cur_next)
cto = get4(0, maxBits)
mask = (1 << cur_next) - 1
lraddr.next = (cto & mask)
# leaf.next = leaves[cto & mask]
filled.next = False
cur_next.next = cur_next + 1
else:
if get_bits(leaf) < 1:
# if get_bits(leaf) < 1:
if get_bits(rleaf) < 1:
print("< 1 bits: ")
raise Error("< 1 bits: ")
adv(get_bits(leaf))
#adv(get_bits(leaf))
adv(get_bits(rleaf))
"""
if get_code(leaf) == 0:
print("leaf 0")
code.next = get_code(leaf)
print("leaf 0", di, isize)
"""
#code.next = get_code(leaf)
code.next = get_code(rleaf)
# print("ADV:", di, get_bits(leaf), get_code(leaf))
if method == 2:
if method == 2 and DYNAMIC:
state.next = d_state.READBL
else:
state.next = d_state.INFLATE
1186,123 → 1212,163
 
elif state == d_state.D_NEXT:
 
if not filled:
if not DECOMPRESS or not DYNAMIC:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
else:
elif cur_next == 0:
# print("D_INIT:", di, dio, d_instantMaxBit, d_maxBits)
if d_instantMaxBit > InstantMaxBit:
raise Error("???")
token = code - 257
# print("token: ", token)
extraLength = ExtraLengthBits[token]
# print("extra length bits:", extraLength)
# print("d_maxBits", d_maxBits, d_instantMaxBit)
cto = get4(extraLength, d_maxBits)
mask = (1 << d_instantMaxBit) - 1
leaf.next = d_leaves[cto & mask]
# state.next = d_state.D_NEXT_2
cur_next.next = instantMaxBit + 1
elif get_bits(leaf) >= cur_next:
print("DCACHE MISS", cur_next)
token = code - 257
# print("token: ", token)
extraLength = ExtraLengthBits[token]
cto = get4(extraLength, d_maxBits)
mask = (1 << cur_next) - 1
leaf.next = d_leaves[cto & mask]
cur_next.next = cur_next + 1
else:
state.next = d_state.D_NEXT_2
 
elif state == d_state.D_NEXT_2:
 
if get_bits(leaf) == 0:
raise Error("0 bits")
token = code - 257
# print("E2:", token, leaf)
tlength = CopyLength[token]
# print("tlength:", tlength)
extraLength = ExtraLengthBits[token]
# print("extra length bits:", extraLength)
tlength += get4(0, extraLength)
# print("extra length:", tlength)
distanceCode = get_code(leaf)
# print("distance code:", distanceCode)
distance = CopyDistance[distanceCode]
# print("distance:", distance)
moreBits = ExtraDistanceBits[distanceCode >> 1]
# print("more bits:", moreBits)
# print("bits:", get_bits(leaf))
mored = get4(extraLength + get_bits(leaf), moreBits)
# print("mored:", mored)
distance += mored
# print("distance more:", distance)
adv(moreBits + extraLength + get_bits(leaf))
# print("offset:", do - distance)
# print("FAIL?: ", di, dio, do, b1, b2, b3, b4)
offset.next = do - distance
length.next = tlength
# cur_next.next = 0
cur_i.next = 0
oraddr.next = do - distance
state.next = d_state.COPY
if DECOMPRESS and DYNAMIC:
if get_bits(leaf) == 0:
raise Error("0 bits")
token = code - 257
# print("E2:", token, leaf)
tlength = CopyLength[token]
# print("tlength:", tlength)
extraLength = ExtraLengthBits[token]
# print("extra length bits:", extraLength)
tlength += get4(0, extraLength)
# print("extra length:", tlength)
distanceCode = get_code(leaf)
# print("distance code:", distanceCode)
distance = CopyDistance[distanceCode]
# print("distance:", distance)
moreBits = ExtraDistanceBits[distanceCode >> 1]
# print("more bits:", moreBits)
# print("bits:", get_bits(leaf))
mored = get4(extraLength + get_bits(leaf), moreBits)
# print("mored:", mored)
distance += mored
# print("distance more:", distance, do, di, isize)
if distance > do:
print(distance, do)
raise Error("distance too big")
adv(moreBits + extraLength + get_bits(leaf))
# print("offset:", do - distance)
# print("FAIL?: ", di, dio, do, b1, b2, b3, b4)
offset.next = (do - distance) & OBS
length.next = tlength
# cur_next.next = 0
cur_i.next = 0
oraddr.next = do - distance
state.next = d_state.COPY
 
elif state == d_state.INFLATE:
 
if not filled:
filled.next = True
elif nb < 4: # nb <= 2 or (nb == 3 and dio > 1):
# print("EXTRA FETCH", nb, dio)
pass # fetch more bytes
elif di > isize: # - 3: # checksum is 4 bytes
if not DECOMPRESS:
pass
elif not filled:
filled.next = True
elif nb < 4: # nb <= 2 or (nb == 3 and dio > 1):
# print("EXTRA FETCH", nb, dio)
pass # fetch more bytes
elif di >= isize - 4 and not i_mode == IDLE:
pass # fetch more bytes
elif do >= i_raddr + OBSIZE: # - 10:
# print("HOLDB")
# filled.next = False
pass
elif di > isize - 3: # checksum is 4 bytes
state.next = d_state.IDLE
o_done.next = True
print("NO EOF ", di)
raise Error("NO EOF!")
elif code == EndOfBlock:
print("EOF:", di, do)
if not final:
state.next = d_state.HEADER
filled.next = False
print("New Block!")
else:
o_done.next = True
state.next = d_state.IDLE
o_done.next = True
print("NO EOF ", di)
raise Error("NO EOF!")
elif code == EndOfBlock:
print("EOF:", di, do)
if not final:
state.next = d_state.HEADER
else:
o_done.next = True
o_oprogress.next = do
state.next = d_state.IDLE
else:
if code < EndOfBlock:
# print("B:", code, di, do)
oaddr.next = do
obyte.next = code
o_oprogress.next = do + 1
do.next = do + 1
cur_next.next = 0
state.next = d_state.NEXT
# raise Error("DF!")
elif code == InvalidToken:
raise Error("invalid token")
else:
if code < EndOfBlock:
# print("B:", code, di, do)
oaddr.next = do
obyte.next = code
o_oprogress.next = do + 1
do.next = do + 1
cur_next.next = 0
state.next = d_state.NEXT
# raise Error("DF!")
elif code == InvalidToken:
raise Error("invalid token")
if static:
token = code - 257
# print("E:", token)
tlength = CopyLength[token]
# print("tlength", tlength)
extraLength = ExtraLengthBits[token]
# print("extralengthbits", extraLength)
tlength += get4(0, extraLength)
# print("tlength extra", tlength)
t = get4(extraLength, 5)
distanceCode = rev_bits(t, 5)
# print("dcode", distanceCode)
distance = CopyDistance[distanceCode]
# print("distance", distance)
moreBits = ExtraDistanceBits[distanceCode
>> 1]
distance += get4(extraLength + 5, moreBits)
# print("distance2", distance)
adv(extraLength + 5 + moreBits)
# print("adv", extraLength + 5 + moreBits)
offset.next = do - distance
length.next = tlength
cur_i.next = 0
oraddr.next = do - distance
state.next = d_state.COPY
else:
if static:
token = code - 257
# print("E:", token)
tlength = CopyLength[token]
# print("tlength", tlength)
extraLength = ExtraLengthBits[token]
# print("extralengthbits", extraLength)
tlength += get4(0, extraLength)
# print("tlength extra", tlength)
t = get4(extraLength, 5)
distanceCode = rev_bits(t, 5)
# print("dcode", distanceCode)
distance = CopyDistance[distanceCode]
# print("distance", distance)
moreBits = ExtraDistanceBits[distanceCode
>> 1]
distance += get4(extraLength + 5, moreBits)
# print("distance2", distance)
adv(extraLength + 5 + moreBits)
# print("adv", extraLength + 5 + moreBits)
offset.next = do - distance
length.next = tlength
cur_i.next = 0
oraddr.next = do - distance
state.next = d_state.COPY
else:
# raise Error("TO DO")
state.next = d_state.D_NEXT
cur_next.next = 0
if not DYNAMIC:
print("DYNAMIC mode disabled")
raise Error("DYNAMIC mode disabled")
state.next = d_state.D_NEXT
cur_next.next = 0
 
elif state == d_state.COPY:
 
if not filled:
if not DECOMPRESS:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
elif cur_i == 0 and do + length >= i_raddr + OBSIZE: # - 10:
# print("HOLDW", length, offset, cur_i, do, i_raddr)
pass
elif di >= isize - 2:
# print("HOLD2")
pass
elif method == 0:
if cur_i < length:
oaddr.next = do
1312,12 → 1378,15
do.next = do + 1
o_oprogress.next = do + 1
elif not final:
adv(16)
state.next = d_state.HEADER
filled.next = False
print("new block")
else:
o_oprogress.next = do # + 1
o_done.next = True
state.next = d_state.IDLE
elif cur_i < length + 2:
# print("L/O", length, offset)
oraddr.next = offset + cur_i
if cur_i == 1:
copy1.next = orbyte
1326,10 → 1395,10
copy2.next = orbyte
if cur_i > 1:
# Special 1 byte offset handling:
if offset + cur_i == do + 1:
if (offset + cur_i) & OBS == (do + 1) & OBS:
obyte.next = copy1
elif cur_i == 3 or offset + cur_i != do:
obyte.next = orbyte
elif cur_i == 3 or (offset + cur_i) & OBS != do & OBS:
obyte.next = orbyte
# Special 2 byte offset handling:
elif cur_i > 2:
if cur_i & 1:
1359,8 → 1428,9
 
if __name__ == "__main__":
d = deflate(Signal(intbv()[3:]), Signal(bool(0)),
Signal(intbv()[8:]), Signal(intbv()[LBSIZE:]),
Signal(intbv()[LBSIZE:]),
Signal(intbv()[8:]), Signal(intbv()[LBSIZE:]),
Signal(intbv()[8:]), Signal(intbv()[LMAX:]),
Signal(intbv()[LMAX:]),
Signal(intbv()[8:]),
Signal(modbv()[LIBSIZE:]), Signal(modbv()[LBSIZE:]),
Signal(bool(0)), ResetSignal(1, 0, True))
d.convert()
/trunk/deflate.v
1,6 → 1,6
// File: deflate.v
// Generated by MyHDL 0.10
// Date: Sun Dec 23 19:31:53 2018
// Date: Tue Jan 1 11:29:55 2019
 
 
`timescale 1ns/10ps
12,7 → 12,8
o_iprogress,
o_oprogress,
o_byte,
i_addr,
i_waddr,
i_raddr,
clk,
reset
);
24,13 → 25,14
output o_done;
reg o_done;
input [7:0] i_data;
output [12:0] o_iprogress;
reg [12:0] o_iprogress;
output [12:0] o_oprogress;
reg [12:0] o_oprogress;
output [23:0] o_iprogress;
reg [23:0] o_iprogress;
output [23:0] o_oprogress;
reg [23:0] o_oprogress;
output [7:0] o_byte;
reg [7:0] o_byte;
input [12:0] i_addr;
input [5:0] i_waddr;
input [14:0] i_raddr;
input clk;
input reset;
 
40,14 → 42,15
reg [4:0] state;
reg [8:0] spread_i;
reg [9:0] spread;
reg [9:0] reverse;
reg [18:0] rleaf;
reg [14:0] reverse;
reg [7:0] orbyte;
reg [12:0] oraddr;
reg [12:0] old_di;
reg [12:0] offset;
reg [14:0] oraddr;
reg [23:0] old_di;
reg [14:0] offset;
reg [7:0] obyte;
reg [7:0] ob1;
reg [12:0] oaddr;
reg [14:0] oaddr;
reg [8:0] numLiterals;
reg [5:0] numDistance;
reg [8:0] numCodeLength;
55,12 → 58,13
reg [4:0] minBits;
reg [2:0] method;
reg [4:0] maxBits;
reg [8:0] lwaddr;
reg [12:0] length;
reg [14:0] lwaddr;
reg [14:0] lraddr;
reg [14:0] length;
reg [18:0] leaf;
reg [14:0] lastToken;
reg [15:0] ladler1;
reg [12:0] isize;
reg [23:0] isize;
reg [9:0] instantMaxBit;
reg [14:0] instantMask;
reg [8:0] howOften;
69,19 → 73,19
reg filled;
reg [2:0] doo;
reg do_compress;
reg [12:0] do;
reg [23:0] do;
reg [2:0] dio;
reg [12:0] di;
reg [23:0] di;
reg [4:0] d_maxBits;
reg [9:0] d_instantMaxBit;
reg [14:0] d_instantMask;
reg [8:0] cur_static;
reg signed [7:0] cur_search;
reg cur_next;
reg [12:0] cur_i;
reg signed [7:0] cur_dist;
reg [12:0] cur_cstatic;
reg [9:0] cur_HF1;
reg signed [24:0] cur_search;
reg [3:0] cur_next;
reg [23:0] cur_i;
reg signed [6:0] cur_dist;
reg [23:0] cur_cstatic;
reg [15:0] cur_HF1;
reg [7:0] copy2;
reg [7:0] copy1;
reg [14:0] code;
96,6 → 100,7
reg [7:0] b4;
reg [7:0] b3;
reg [7:0] b2;
wire [39:0] b15;
wire [31:0] b14;
wire [79:0] b110;
reg [7:0] b10;
103,14 → 108,13
reg [15:0] adler2;
reg [15:0] adler1;
reg [255:0] cwindow;
reg [7:0] oram [0:8192-1];
reg [9:0] nextCode [0:15-1];
reg [7:0] oram [0:32768-1];
reg [15:0] nextCode [0:16-1];
reg [18:0] leaves [0:512-1];
reg [7:0] iram [0:128-1];
reg [7:0] iram [0:64-1];
reg [3:0] distanceLength [0:32-1];
reg [18:0] d_leaves [0:128-1];
reg [8:0] code_bits [0:288-1];
reg [3:0] codeLength [0:290-1];
reg d_leaves [0:1-1];
reg [3:0] codeLength [0:320-1];
reg [8:0] bitLengthCount [0:16-1];
wire smatch [0:32-1];
 
118,6 → 122,11
assign b41[24-1:16] = b3;
assign b41[16-1:8] = b2;
assign b41[8-1:0] = b1;
assign b15[40-1:32] = b1;
assign b15[32-1:24] = b2;
assign b15[24-1:16] = b3;
assign b15[16-1:8] = b4;
assign b15[8-1:0] = b5;
assign b14[32-1:24] = b1;
assign b14[24-1:16] = b2;
assign b14[16-1:8] = b3;
137,7 → 146,7
input width;
integer width;
integer nshift;
begin: MYHDL113_RETURN
begin: MYHDL115_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
151,7 → 160,7
function integer MYHDL4_get4;
input boffset;
input width;
begin: MYHDL114_RETURN
begin: MYHDL116_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
158,7 → 167,7
$finish;
end
MYHDL4_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL114_RETURN;
disable MYHDL116_RETURN;
end
endfunction
 
166,7 → 175,7
input boffset;
input width;
integer width;
begin: MYHDL115_RETURN
begin: MYHDL117_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
173,7 → 182,7
$finish;
end
MYHDL5_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL115_RETURN;
disable MYHDL117_RETURN;
end
endfunction
 
181,7 → 190,7
input width;
integer width;
integer nshift;
begin: MYHDL116_RETURN
begin: MYHDL118_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
196,7 → 205,7
input width;
integer width;
integer nshift;
begin: MYHDL117_RETURN
begin: MYHDL119_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
212,7 → 221,7
integer boffset;
input width;
integer width;
begin: MYHDL118_RETURN
begin: MYHDL120_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
219,7 → 228,7
$finish;
end
MYHDL8_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL118_RETURN;
disable MYHDL120_RETURN;
end
endfunction
 
227,7 → 236,7
input width;
integer width;
integer nshift;
begin: MYHDL119_RETURN
begin: MYHDL121_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
243,7 → 252,7
integer d;
input width;
integer width;
begin: MYHDL120_RETURN
begin: MYHDL122_RETURN
if ((width > 9)) begin
$finish;
end
251,7 → 260,7
$finish;
end
MYHDL10_put = ((ob1 | (d << doo)) & 255);
disable MYHDL120_RETURN;
disable MYHDL122_RETURN;
end
endfunction
 
263,7 → 272,7
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL121_RETURN
begin: MYHDL123_RETURN
if ((width > 9)) begin
$finish;
end
289,7 → 298,7
endtask
 
task MYHDL12_do_flush;
begin: MYHDL122_RETURN
begin: MYHDL124_RETURN
flush <= 1'b0;
ob1 <= 0;
o_oprogress <= (do + 1);
298,40 → 307,42
endtask
 
function integer MYHDL13_put;
input [9-1:0] d;
input d;
integer d;
input [4-1:0] width;
begin: MYHDL123_RETURN
begin: MYHDL125_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
MYHDL13_put = ((ob1 | (d << doo)) & 255);
disable MYHDL123_RETURN;
MYHDL13_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL125_RETURN;
end
endfunction
 
task MYHDL14_put_adv;
input [9-1:0] d;
input d;
integer d;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL124_RETURN
begin: MYHDL126_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
pshift = ((doo + width) > 8);
if (pshift) begin
carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, doo})));
ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
ob1 <= $signed(d >>> ($signed({1'b0, width}) - carry));
end
else begin
ob1 <= (ob1 | (d << doo));
ob1 <= ($signed({1'b0, ob1}) | (d << $signed({1'b0, doo})));
end
do <= (do + pshift);
o_oprogress <= (do + pshift);
344,7 → 355,7
endtask
 
task MYHDL15_do_flush;
begin: MYHDL125_RETURN
begin: MYHDL127_RETURN
flush <= 1'b0;
ob1 <= 0;
o_oprogress <= (do + 1);
352,30 → 363,11
end
endtask
 
function integer MYHDL16_rev_bits;
input [13-1:0] b;
input nb;
integer nb;
integer r;
begin: MYHDL126_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
$write("\n");
end
r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
r = r >>> (15 - $signed({1'b0, nb}));
MYHDL16_rev_bits = r;
disable MYHDL126_RETURN;
end
endfunction
 
function integer MYHDL17_put;
function integer MYHDL16_put;
input d;
integer d;
input width;
integer width;
begin: MYHDL127_RETURN
input [4-1:0] width;
begin: MYHDL128_RETURN
if ((width > 9)) begin
$finish;
end
382,20 → 374,19
if ((d > ((1 << width) - 1))) begin
$finish;
end
MYHDL17_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL127_RETURN;
MYHDL16_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL128_RETURN;
end
endfunction
 
task MYHDL18_put_adv;
task MYHDL17_put_adv;
input d;
integer d;
input width;
integer width;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL128_RETURN
begin: MYHDL129_RETURN
if ((width > 9)) begin
$finish;
end
402,10 → 393,10
if ((d > ((1 << width) - 1))) begin
$finish;
end
pshift = (($signed({1'b0, doo}) + width) > 8);
pshift = ((doo + width) > 8);
if (pshift) begin
carry = (width - (8 - $signed({1'b0, doo})));
ob1 <= $signed(d >>> (width - carry));
carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, doo})));
ob1 <= $signed(d >>> ($signed({1'b0, width}) - carry));
end
else begin
ob1 <= ($signed({1'b0, ob1}) | (d << $signed({1'b0, doo})));
412,7 → 403,7
end
do <= (do + pshift);
o_oprogress <= (do + pshift);
doo_next = (($signed({1'b0, doo}) + width) & 7);
doo_next = ((doo + width) & 7);
if ((doo_next == 0)) begin
flush <= 1'b1;
end
420,70 → 411,49
end
endtask
 
function integer MYHDL21_put;
input [9-1:0] d;
input [4-1:0] width;
begin: MYHDL129_RETURN
if ((width > 9)) begin
function integer MYHDL18_rev_bits;
input [24-1:0] b;
input nb;
integer nb;
integer r;
begin: MYHDL130_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
$write("\n");
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((nb > 15)) begin
$finish;
end
MYHDL21_put = ((ob1 | (d << doo)) & 255);
disable MYHDL129_RETURN;
r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
r = r >>> (15 - $signed({1'b0, nb}));
MYHDL18_rev_bits = r;
disable MYHDL130_RETURN;
end
endfunction
 
task MYHDL22_put_adv;
input [9-1:0] d;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL130_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
$finish;
end
pshift = ((doo + width) > 8);
if (pshift) begin
carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, doo})));
ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
end
else begin
ob1 <= (ob1 | (d << doo));
end
do <= (do + pshift);
o_oprogress <= (do + pshift);
doo_next = ((doo + width) & 7);
if ((doo_next == 0)) begin
flush <= 1'b1;
end
doo <= doo_next;
end
endtask
 
function integer MYHDL23_put;
input [9-1:0] d;
input [4-1:0] width;
function integer MYHDL19_put;
input d;
integer d;
input width;
integer width;
begin: MYHDL131_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
MYHDL23_put = ((ob1 | (d << doo)) & 255);
MYHDL19_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL131_RETURN;
end
endfunction
 
task MYHDL24_put_adv;
input [9-1:0] d;
input [4-1:0] width;
task MYHDL20_put_adv;
input d;
integer d;
input width;
integer width;
reg pshift;
integer carry;
integer doo_next;
491,20 → 461,20
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
pshift = ((doo + width) > 8);
pshift = (($signed({1'b0, doo}) + width) > 8);
if (pshift) begin
carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, doo})));
ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
carry = (width - (8 - $signed({1'b0, doo})));
ob1 <= $signed(d >>> (width - carry));
end
else begin
ob1 <= (ob1 | (d << doo));
ob1 <= ($signed({1'b0, ob1}) | (d << $signed({1'b0, doo})));
end
do <= (do + pshift);
o_oprogress <= (do + pshift);
doo_next = ((doo + width) & 7);
doo_next = (($signed({1'b0, doo}) + width) & 7);
if ((doo_next == 0)) begin
flush <= 1'b1;
end
512,23 → 482,25
end
endtask
 
function integer MYHDL25_put;
input [9-1:0] d;
function integer MYHDL23_put;
input d;
integer d;
input [4-1:0] width;
begin: MYHDL133_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
MYHDL25_put = ((ob1 | (d << doo)) & 255);
MYHDL23_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL133_RETURN;
end
endfunction
 
task MYHDL26_put_adv;
input [9-1:0] d;
task MYHDL24_put_adv;
input d;
integer d;
input [4-1:0] width;
reg pshift;
integer carry;
537,16 → 509,16
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
if ((d > ((1 << width) - 1))) begin
$finish;
end
pshift = ((doo + width) > 8);
if (pshift) begin
carry = ($signed({1'b0, width}) - (8 - $signed({1'b0, doo})));
ob1 <= $signed($signed({1'b0, d}) >>> ($signed({1'b0, width}) - carry));
ob1 <= $signed(d >>> ($signed({1'b0, width}) - carry));
end
else begin
ob1 <= (ob1 | (d << doo));
ob1 <= ($signed({1'b0, ob1}) | (d << $signed({1'b0, doo})));
end
do <= (do + pshift);
o_oprogress <= (do + pshift);
558,7 → 530,7
end
endtask
 
function integer MYHDL35_get4;
function integer MYHDL33_get4;
input boffset;
input width;
integer width;
568,12 → 540,12
$write("\n");
$finish;
end
MYHDL35_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL33_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL135_RETURN;
end
endfunction
 
function integer MYHDL36_get4;
function integer MYHDL34_get4;
input boffset;
input width;
integer width;
583,12 → 555,12
$write("\n");
$finish;
end
MYHDL36_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL34_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL136_RETURN;
end
endfunction
 
function integer MYHDL37_get4;
function integer MYHDL35_get4;
input boffset;
integer boffset;
input width;
599,12 → 571,12
$write("\n");
$finish;
end
MYHDL37_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL35_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL137_RETURN;
end
endfunction
 
function integer MYHDL38_get4;
function integer MYHDL36_get4;
input boffset;
integer boffset;
input width;
615,12 → 587,12
$write("\n");
$finish;
end
MYHDL38_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL36_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL138_RETURN;
end
endfunction
 
function integer MYHDL39_get4;
function integer MYHDL37_get4;
input boffset;
integer boffset;
input width;
631,12 → 603,12
$write("\n");
$finish;
end
MYHDL39_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL37_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL139_RETURN;
end
endfunction
 
function integer MYHDL40_get4;
function integer MYHDL38_get4;
input boffset;
integer boffset;
input width;
647,12 → 619,12
$write("\n");
$finish;
end
MYHDL40_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL38_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL140_RETURN;
end
endfunction
 
task MYHDL41_adv;
task MYHDL39_adv;
input width;
integer width;
integer nshift;
667,7 → 639,7
end
endtask
 
function integer MYHDL42_get4;
function integer MYHDL40_get4;
input boffset;
input width;
integer width;
677,12 → 649,12
$write("\n");
$finish;
end
MYHDL42_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL40_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL142_RETURN;
end
endfunction
 
task MYHDL43_adv;
task MYHDL41_adv;
input width;
integer width;
integer nshift;
697,7 → 669,7
end
endtask
 
function integer MYHDL44_get4;
function integer MYHDL42_get4;
input boffset;
input width;
integer width;
707,12 → 679,12
$write("\n");
$finish;
end
MYHDL44_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL42_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL144_RETURN;
end
endfunction
 
function integer MYHDL45_get4;
function integer MYHDL43_get4;
input boffset;
input width;
integer width;
722,12 → 694,12
$write("\n");
$finish;
end
MYHDL45_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL43_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL145_RETURN;
end
endfunction
 
function integer MYHDL46_get4;
function integer MYHDL44_get4;
input boffset;
input width;
integer width;
737,12 → 709,12
$write("\n");
$finish;
end
MYHDL46_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL44_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL146_RETURN;
end
endfunction
 
task MYHDL47_adv;
task MYHDL45_adv;
input width;
integer width;
integer nshift;
757,8 → 729,8
end
endtask
 
function integer MYHDL54_rev_bits;
input [10-1:0] b;
function integer MYHDL52_rev_bits;
input [16-1:0] b;
input [4-1:0] nb;
integer r;
begin: MYHDL148_RETURN
767,59 → 739,62
$write("too few bits");
$write("\n");
end
if ((nb > 15)) begin
$finish;
end
r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
r = r >>> (15 - $signed({1'b0, nb}));
MYHDL54_rev_bits = r;
MYHDL52_rev_bits = r;
disable MYHDL148_RETURN;
end
endfunction
 
function integer MYHDL55_makeLeaf;
function integer MYHDL53_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL149_RETURN
if ((lcode >= (1 << 10))) begin
if ((lcode >= (1 << 15))) begin
$finish;
end
if ((lbits >= (1 << 9))) begin
if ((lbits >= (1 << 4))) begin
$finish;
end
MYHDL55_makeLeaf = ((lcode << 9) | lbits);
MYHDL53_makeLeaf = ((lcode << 4) | lbits);
disable MYHDL149_RETURN;
end
endfunction
 
function integer MYHDL56_makeLeaf;
function integer MYHDL54_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL150_RETURN
if ((lcode >= (1 << 10))) begin
if ((lcode >= (1 << 15))) begin
$finish;
end
if ((lbits >= (1 << 9))) begin
if ((lbits >= (1 << 4))) begin
$finish;
end
MYHDL56_makeLeaf = ((lcode << 9) | lbits);
MYHDL54_makeLeaf = ((lcode << 4) | lbits);
disable MYHDL150_RETURN;
end
endfunction
 
function integer MYHDL57_makeLeaf;
function integer MYHDL55_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL151_RETURN
if ((lcode >= (1 << 10))) begin
if ((lcode >= (1 << 15))) begin
$finish;
end
if ((lbits >= (1 << 9))) begin
if ((lbits >= (1 << 4))) begin
$finish;
end
MYHDL57_makeLeaf = ((lcode << 9) | lbits);
MYHDL55_makeLeaf = ((lcode << 4) | lbits);
disable MYHDL151_RETURN;
end
endfunction
 
function integer MYHDL58_get4;
function integer MYHDL56_get4;
input boffset;
input [5-1:0] width;
begin: MYHDL152_RETURN
828,32 → 803,54
$write("\n");
$finish;
end
MYHDL58_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
MYHDL56_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL152_RETURN;
end
endfunction
 
function integer MYHDL59_get_bits;
function integer MYHDL57_get_bits;
input [19-1:0] aleaf;
begin: MYHDL153_RETURN
MYHDL59_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
MYHDL57_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL153_RETURN;
end
endfunction
 
function integer MYHDL60_get_bits;
input [19-1:0] aleaf;
function integer MYHDL58_get4;
input boffset;
input [5-1:0] width;
begin: MYHDL154_RETURN
MYHDL60_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL58_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL154_RETURN;
end
endfunction
 
function integer MYHDL59_get_bits;
input [19-1:0] aleaf;
begin: MYHDL155_RETURN
MYHDL59_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL155_RETURN;
end
endfunction
 
function integer MYHDL60_get_bits;
input [19-1:0] aleaf;
begin: MYHDL156_RETURN
MYHDL60_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL156_RETURN;
end
endfunction
 
task MYHDL61_adv;
input width;
integer width;
integer nshift;
begin: MYHDL155_RETURN
begin: MYHDL157_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
866,103 → 863,118
 
function integer MYHDL62_get_code;
input [19-1:0] aleaf;
begin: MYHDL156_RETURN
MYHDL62_get_code = (aleaf >>> 9);
disable MYHDL156_RETURN;
begin: MYHDL158_RETURN
MYHDL62_get_code = (aleaf >>> 4);
disable MYHDL158_RETURN;
end
endfunction
 
function integer MYHDL63_get_code;
function integer MYHDL63_get4;
input boffset;
integer boffset;
input [5-1:0] width;
begin: MYHDL159_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL63_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL159_RETURN;
end
endfunction
 
function integer MYHDL64_get_bits;
input [19-1:0] aleaf;
begin: MYHDL157_RETURN
MYHDL63_get_code = (aleaf >>> 9);
disable MYHDL157_RETURN;
begin: MYHDL160_RETURN
MYHDL64_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL160_RETURN;
end
endfunction
 
function integer MYHDL64_get4;
function integer MYHDL65_get4;
input boffset;
integer boffset;
input [5-1:0] width;
begin: MYHDL158_RETURN
begin: MYHDL161_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL64_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL158_RETURN;
MYHDL65_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL161_RETURN;
end
endfunction
 
function integer MYHDL65_get_bits;
function integer MYHDL66_get_bits;
input [19-1:0] aleaf;
begin: MYHDL159_RETURN
MYHDL65_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL159_RETURN;
begin: MYHDL162_RETURN
MYHDL66_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL162_RETURN;
end
endfunction
 
function integer MYHDL66_get4;
function integer MYHDL67_get4;
input boffset;
input width;
integer width;
begin: MYHDL160_RETURN
begin: MYHDL163_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL66_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL160_RETURN;
MYHDL67_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL163_RETURN;
end
endfunction
 
function integer MYHDL67_get_code;
function integer MYHDL68_get_code;
input [19-1:0] aleaf;
begin: MYHDL161_RETURN
MYHDL67_get_code = (aleaf >>> 9);
disable MYHDL161_RETURN;
begin: MYHDL164_RETURN
MYHDL68_get_code = (aleaf >>> 4);
disable MYHDL164_RETURN;
end
endfunction
 
function integer MYHDL68_get_bits;
function integer MYHDL69_get_bits;
input [19-1:0] aleaf;
begin: MYHDL162_RETURN
MYHDL68_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL162_RETURN;
begin: MYHDL165_RETURN
MYHDL69_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL165_RETURN;
end
endfunction
 
function integer MYHDL69_get4;
function integer MYHDL70_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL163_RETURN
begin: MYHDL166_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL69_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL163_RETURN;
MYHDL70_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL166_RETURN;
end
endfunction
 
function integer MYHDL70_get_bits;
function integer MYHDL71_get_bits;
input [19-1:0] aleaf;
begin: MYHDL164_RETURN
MYHDL70_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL164_RETURN;
begin: MYHDL167_RETURN
MYHDL71_get_bits = ($signed({1'b0, aleaf}) & ((1 << 4) - 1));
disable MYHDL167_RETURN;
end
endfunction
 
task MYHDL71_adv;
task MYHDL72_adv;
input width;
integer width;
integer nshift;
begin: MYHDL165_RETURN
begin: MYHDL168_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
973,77 → 985,80
end
endtask
 
function integer MYHDL72_get4;
function integer MYHDL73_get4;
input boffset;
input width;
integer width;
begin: MYHDL166_RETURN
begin: MYHDL169_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL72_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL166_RETURN;
MYHDL73_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL169_RETURN;
end
endfunction
 
function integer MYHDL73_get4;
function integer MYHDL74_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL167_RETURN
begin: MYHDL170_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL73_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL167_RETURN;
MYHDL74_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL170_RETURN;
end
endfunction
 
function integer MYHDL74_rev_bits;
function integer MYHDL75_rev_bits;
input b;
integer b;
input nb;
integer nb;
integer r;
begin: MYHDL168_RETURN
begin: MYHDL171_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
$write("\n");
end
if ((nb > 15)) begin
$finish;
end
r = (((((((((((((((((b >>> 14) & 1) << 0) | (((b >>> 13) & 1) << 1)) | (((b >>> 12) & 1) << 2)) | (((b >>> 11) & 1) << 3)) | (((b >>> 10) & 1) << 4)) | (((b >>> 9) & 1) << 5)) | (((b >>> 8) & 1) << 6)) | (((b >>> 7) & 1) << 7)) | (((b >>> 6) & 1) << 8)) | (((b >>> 5) & 1) << 9)) | (((b >>> 4) & 1) << 10)) | (((b >>> 3) & 1) << 11)) | (((b >>> 2) & 1) << 12)) | (((b >>> 1) & 1) << 13)) | (((b >>> 0) & 1) << 14));
r = r >>> (15 - $signed({1'b0, nb}));
MYHDL74_rev_bits = r;
disable MYHDL168_RETURN;
MYHDL75_rev_bits = r;
disable MYHDL171_RETURN;
end
endfunction
 
function integer MYHDL75_get4;
function integer MYHDL76_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL169_RETURN
begin: MYHDL172_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL75_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL169_RETURN;
MYHDL76_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL172_RETURN;
end
endfunction
 
task MYHDL76_adv;
task MYHDL77_adv;
input width;
integer width;
integer nshift;
begin: MYHDL170_RETURN
begin: MYHDL173_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
1054,11 → 1069,11
end
endtask
 
task MYHDL77_adv;
task MYHDL78_adv;
input width;
integer width;
integer nshift;
begin: MYHDL171_RETURN
begin: MYHDL174_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
1069,20 → 1084,28
end
endtask
 
task MYHDL79_adv;
input width;
integer width;
integer nshift;
begin: MYHDL175_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
di <= ($signed({1'b0, di}) + nshift);
if ((nshift != 0)) begin
filled <= 1'b0;
end
end
endtask
 
 
always @(posedge clk) begin: DEFLATE_IO_LOGIC
case (i_mode)
'h2: begin
iram[(i_addr & 127)] <= i_data;
isize <= i_addr;
end
'h3: begin
o_byte <= oram[i_addr];
end
default: begin
// pass
end
endcase
o_byte <= oram[(i_raddr & 32767)];
if ((i_mode == 2)) begin
iram[(i_waddr & 63)] <= i_data;
isize <= i_waddr;
end
end
 
 
1092,20 → 1115,22
reg no_adv;
integer cs_i;
reg [4-1:0] outlen;
reg [9-1:0] outbits;
integer outbits;
reg [8-1:0] bdata;
integer adler1_next;
integer lencode;
integer nextdist;
integer copydist;
integer extra_dist;
integer extra_bits;
integer outcode;
reg [15-1:0] lfmatch;
integer distance;
integer fmatch2;
integer match;
reg found;
integer fmatch;
integer si;
integer distance;
integer lencode;
integer match;
integer stat_i;
integer clo_i;
integer n_adv;
1118,7 → 1143,7
integer hf2_i;
reg [5-1:0] amb;
integer ncode;
reg [10-1:0] canonical;
reg [16-1:0] canonical;
reg [4-1:0] bits_next;
reg [15-1:0] aim;
integer cto;
1154,7 → 1179,7
cur_static <= 0;
state <= 5'b01110;
end
else if ((i_mode == 5)) begin
else if ((1'b1 && (i_mode == 5))) begin
do_compress <= 1'b0;
o_done <= 1'b0;
o_iprogress <= 0;
1171,7 → 1196,10
end
end
5'b00001: begin
if ((!filled)) begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
1219,6 → 1247,11
$write("\n");
case (hm)
'h2: begin
if ((!1'b0)) begin
$write("dynamic tree mode disabled");
$write("\n");
$finish;
end
state <= 5'b00010;
numCodeLength <= 0;
numLiterals <= 0;
1284,17 → 1317,20
MYHDL11_put_adv(3, 3);
end
else if (flush) begin
$write("flush");
$write(" ");
$write("%h", do);
$write(" ");
$write("%h", ob1);
$write("\n");
no_adv = 1;
oaddr <= do;
obyte <= ob1;
MYHDL12_do_flush;
end
else if ((($signed({1'b0, cur_cstatic}) >= ($signed({1'b0, isize}) - 10)) && (i_mode != 0))) begin
$write("P");
$write(" ");
$write("%h", cur_cstatic);
$write(" ");
$write("%h", isize);
$write("\n");
no_adv = 1;
end
else if ((($signed({1'b0, cur_cstatic}) - 3) > isize)) begin
if ((($signed({1'b0, cur_cstatic}) - 3) == (isize + 1))) begin
$write("Put EOF");
1303,7 → 1339,296
$write("\n");
cs_i = 256;
outlen = codeLength[cs_i];
outbits = code_bits[cs_i];
case (cs_i)
0: outbits = 12;
1: outbits = 140;
2: outbits = 76;
3: outbits = 204;
4: outbits = 44;
5: outbits = 172;
6: outbits = 108;
7: outbits = 236;
8: outbits = 28;
9: outbits = 156;
10: outbits = 92;
11: outbits = 220;
12: outbits = 60;
13: outbits = 188;
14: outbits = 124;
15: outbits = 252;
16: outbits = 2;
17: outbits = 130;
18: outbits = 66;
19: outbits = 194;
20: outbits = 34;
21: outbits = 162;
22: outbits = 98;
23: outbits = 226;
24: outbits = 18;
25: outbits = 146;
26: outbits = 82;
27: outbits = 210;
28: outbits = 50;
29: outbits = 178;
30: outbits = 114;
31: outbits = 242;
32: outbits = 10;
33: outbits = 138;
34: outbits = 74;
35: outbits = 202;
36: outbits = 42;
37: outbits = 170;
38: outbits = 106;
39: outbits = 234;
40: outbits = 26;
41: outbits = 154;
42: outbits = 90;
43: outbits = 218;
44: outbits = 58;
45: outbits = 186;
46: outbits = 122;
47: outbits = 250;
48: outbits = 6;
49: outbits = 134;
50: outbits = 70;
51: outbits = 198;
52: outbits = 38;
53: outbits = 166;
54: outbits = 102;
55: outbits = 230;
56: outbits = 22;
57: outbits = 150;
58: outbits = 86;
59: outbits = 214;
60: outbits = 54;
61: outbits = 182;
62: outbits = 118;
63: outbits = 246;
64: outbits = 14;
65: outbits = 142;
66: outbits = 78;
67: outbits = 206;
68: outbits = 46;
69: outbits = 174;
70: outbits = 110;
71: outbits = 238;
72: outbits = 30;
73: outbits = 158;
74: outbits = 94;
75: outbits = 222;
76: outbits = 62;
77: outbits = 190;
78: outbits = 126;
79: outbits = 254;
80: outbits = 1;
81: outbits = 129;
82: outbits = 65;
83: outbits = 193;
84: outbits = 33;
85: outbits = 161;
86: outbits = 97;
87: outbits = 225;
88: outbits = 17;
89: outbits = 145;
90: outbits = 81;
91: outbits = 209;
92: outbits = 49;
93: outbits = 177;
94: outbits = 113;
95: outbits = 241;
96: outbits = 9;
97: outbits = 137;
98: outbits = 73;
99: outbits = 201;
100: outbits = 41;
101: outbits = 169;
102: outbits = 105;
103: outbits = 233;
104: outbits = 25;
105: outbits = 153;
106: outbits = 89;
107: outbits = 217;
108: outbits = 57;
109: outbits = 185;
110: outbits = 121;
111: outbits = 249;
112: outbits = 5;
113: outbits = 133;
114: outbits = 69;
115: outbits = 197;
116: outbits = 37;
117: outbits = 165;
118: outbits = 101;
119: outbits = 229;
120: outbits = 21;
121: outbits = 149;
122: outbits = 85;
123: outbits = 213;
124: outbits = 53;
125: outbits = 181;
126: outbits = 117;
127: outbits = 245;
128: outbits = 13;
129: outbits = 141;
130: outbits = 77;
131: outbits = 205;
132: outbits = 45;
133: outbits = 173;
134: outbits = 109;
135: outbits = 237;
136: outbits = 29;
137: outbits = 157;
138: outbits = 93;
139: outbits = 221;
140: outbits = 61;
141: outbits = 189;
142: outbits = 125;
143: outbits = 253;
144: outbits = 19;
145: outbits = 275;
146: outbits = 147;
147: outbits = 403;
148: outbits = 83;
149: outbits = 339;
150: outbits = 211;
151: outbits = 467;
152: outbits = 51;
153: outbits = 307;
154: outbits = 179;
155: outbits = 435;
156: outbits = 115;
157: outbits = 371;
158: outbits = 243;
159: outbits = 499;
160: outbits = 11;
161: outbits = 267;
162: outbits = 139;
163: outbits = 395;
164: outbits = 75;
165: outbits = 331;
166: outbits = 203;
167: outbits = 459;
168: outbits = 43;
169: outbits = 299;
170: outbits = 171;
171: outbits = 427;
172: outbits = 107;
173: outbits = 363;
174: outbits = 235;
175: outbits = 491;
176: outbits = 27;
177: outbits = 283;
178: outbits = 155;
179: outbits = 411;
180: outbits = 91;
181: outbits = 347;
182: outbits = 219;
183: outbits = 475;
184: outbits = 59;
185: outbits = 315;
186: outbits = 187;
187: outbits = 443;
188: outbits = 123;
189: outbits = 379;
190: outbits = 251;
191: outbits = 507;
192: outbits = 7;
193: outbits = 263;
194: outbits = 135;
195: outbits = 391;
196: outbits = 71;
197: outbits = 327;
198: outbits = 199;
199: outbits = 455;
200: outbits = 39;
201: outbits = 295;
202: outbits = 167;
203: outbits = 423;
204: outbits = 103;
205: outbits = 359;
206: outbits = 231;
207: outbits = 487;
208: outbits = 23;
209: outbits = 279;
210: outbits = 151;
211: outbits = 407;
212: outbits = 87;
213: outbits = 343;
214: outbits = 215;
215: outbits = 471;
216: outbits = 55;
217: outbits = 311;
218: outbits = 183;
219: outbits = 439;
220: outbits = 119;
221: outbits = 375;
222: outbits = 247;
223: outbits = 503;
224: outbits = 15;
225: outbits = 271;
226: outbits = 143;
227: outbits = 399;
228: outbits = 79;
229: outbits = 335;
230: outbits = 207;
231: outbits = 463;
232: outbits = 47;
233: outbits = 303;
234: outbits = 175;
235: outbits = 431;
236: outbits = 111;
237: outbits = 367;
238: outbits = 239;
239: outbits = 495;
240: outbits = 31;
241: outbits = 287;
242: outbits = 159;
243: outbits = 415;
244: outbits = 95;
245: outbits = 351;
246: outbits = 223;
247: outbits = 479;
248: outbits = 63;
249: outbits = 319;
250: outbits = 191;
251: outbits = 447;
252: outbits = 127;
253: outbits = 383;
254: outbits = 255;
255: outbits = 511;
256: outbits = 0;
257: outbits = 64;
258: outbits = 32;
259: outbits = 96;
260: outbits = 16;
261: outbits = 80;
262: outbits = 48;
263: outbits = 112;
264: outbits = 8;
265: outbits = 72;
266: outbits = 40;
267: outbits = 104;
268: outbits = 24;
269: outbits = 88;
270: outbits = 56;
271: outbits = 120;
272: outbits = 4;
273: outbits = 68;
274: outbits = 36;
275: outbits = 100;
276: outbits = 20;
277: outbits = 84;
278: outbits = 52;
279: outbits = 116;
280: outbits = 3;
281: outbits = 131;
282: outbits = 67;
283: outbits = 195;
284: outbits = 35;
285: outbits = 163;
286: outbits = 99;
default: outbits = 227;
endcase
$write("EOF BITS:");
$write(" ");
$write("%0d", cs_i);
1310,7 → 1635,7
$write(" ");
$write("%h", outlen);
$write(" ");
$write("%h", outbits);
$write("%0d", outbits);
$write("\n");
oaddr <= do;
obyte <= MYHDL13_put(outbits, outlen);
1332,6 → 1657,7
oaddr <= do;
obyte <= (adler2 >>> 8);
do <= (do + 1);
o_oprogress <= (do + 1);
end
else if ((($signed({1'b0, cur_cstatic}) - 3) == (isize + 4))) begin
$write("c2");
1339,6 → 1665,7
oaddr <= do;
obyte <= (adler2 & 255);
do <= (do + 1);
o_oprogress <= (do + 1);
end
else if ((($signed({1'b0, cur_cstatic}) - 3) == (isize + 5))) begin
$write("c3");
1346,6 → 1673,7
oaddr <= do;
obyte <= (adler1 >>> 8);
do <= (do + 1);
o_oprogress <= (do + 1);
end
else if ((($signed({1'b0, cur_cstatic}) - 3) == (isize + 6))) begin
$write("c4");
1352,6 → 1680,7
$write("\n");
oaddr <= do;
obyte <= (adler1 & 255);
o_oprogress <= (do + 1);
end
else if ((($signed({1'b0, cur_cstatic}) - 3) == (isize + 7))) begin
$write("EOF finish");
1359,7 → 1688,6
$write("%h", do);
$write("\n");
o_done <= 1'b1;
o_oprogress <= (do + 1);
state <= 5'b00000;
end
else begin
1371,7 → 1699,8
end
end
else begin
bdata = iram[di];
bdata = iram[(di & 63)];
o_iprogress <= di;
adler1_next = ((adler1 + bdata) % 65521);
adler1 <= adler1_next;
adler2 <= ((adler2 + ladler1) % 65521);
1383,7 → 1712,7
cur_cstatic <= (cur_cstatic + 1);
end
end
5'b11000: begin
5'b11001: begin
if ((!1'b1)) begin
// pass
end
1390,6 → 1719,304
else if (flush) begin
MYHDL15_do_flush;
end
else if ((cur_i == 1024)) begin
lencode = (length + 254);
outlen = codeLength[lencode];
case (lencode)
0: outbits = 12;
1: outbits = 140;
2: outbits = 76;
3: outbits = 204;
4: outbits = 44;
5: outbits = 172;
6: outbits = 108;
7: outbits = 236;
8: outbits = 28;
9: outbits = 156;
10: outbits = 92;
11: outbits = 220;
12: outbits = 60;
13: outbits = 188;
14: outbits = 124;
15: outbits = 252;
16: outbits = 2;
17: outbits = 130;
18: outbits = 66;
19: outbits = 194;
20: outbits = 34;
21: outbits = 162;
22: outbits = 98;
23: outbits = 226;
24: outbits = 18;
25: outbits = 146;
26: outbits = 82;
27: outbits = 210;
28: outbits = 50;
29: outbits = 178;
30: outbits = 114;
31: outbits = 242;
32: outbits = 10;
33: outbits = 138;
34: outbits = 74;
35: outbits = 202;
36: outbits = 42;
37: outbits = 170;
38: outbits = 106;
39: outbits = 234;
40: outbits = 26;
41: outbits = 154;
42: outbits = 90;
43: outbits = 218;
44: outbits = 58;
45: outbits = 186;
46: outbits = 122;
47: outbits = 250;
48: outbits = 6;
49: outbits = 134;
50: outbits = 70;
51: outbits = 198;
52: outbits = 38;
53: outbits = 166;
54: outbits = 102;
55: outbits = 230;
56: outbits = 22;
57: outbits = 150;
58: outbits = 86;
59: outbits = 214;
60: outbits = 54;
61: outbits = 182;
62: outbits = 118;
63: outbits = 246;
64: outbits = 14;
65: outbits = 142;
66: outbits = 78;
67: outbits = 206;
68: outbits = 46;
69: outbits = 174;
70: outbits = 110;
71: outbits = 238;
72: outbits = 30;
73: outbits = 158;
74: outbits = 94;
75: outbits = 222;
76: outbits = 62;
77: outbits = 190;
78: outbits = 126;
79: outbits = 254;
80: outbits = 1;
81: outbits = 129;
82: outbits = 65;
83: outbits = 193;
84: outbits = 33;
85: outbits = 161;
86: outbits = 97;
87: outbits = 225;
88: outbits = 17;
89: outbits = 145;
90: outbits = 81;
91: outbits = 209;
92: outbits = 49;
93: outbits = 177;
94: outbits = 113;
95: outbits = 241;
96: outbits = 9;
97: outbits = 137;
98: outbits = 73;
99: outbits = 201;
100: outbits = 41;
101: outbits = 169;
102: outbits = 105;
103: outbits = 233;
104: outbits = 25;
105: outbits = 153;
106: outbits = 89;
107: outbits = 217;
108: outbits = 57;
109: outbits = 185;
110: outbits = 121;
111: outbits = 249;
112: outbits = 5;
113: outbits = 133;
114: outbits = 69;
115: outbits = 197;
116: outbits = 37;
117: outbits = 165;
118: outbits = 101;
119: outbits = 229;
120: outbits = 21;
121: outbits = 149;
122: outbits = 85;
123: outbits = 213;
124: outbits = 53;
125: outbits = 181;
126: outbits = 117;
127: outbits = 245;
128: outbits = 13;
129: outbits = 141;
130: outbits = 77;
131: outbits = 205;
132: outbits = 45;
133: outbits = 173;
134: outbits = 109;
135: outbits = 237;
136: outbits = 29;
137: outbits = 157;
138: outbits = 93;
139: outbits = 221;
140: outbits = 61;
141: outbits = 189;
142: outbits = 125;
143: outbits = 253;
144: outbits = 19;
145: outbits = 275;
146: outbits = 147;
147: outbits = 403;
148: outbits = 83;
149: outbits = 339;
150: outbits = 211;
151: outbits = 467;
152: outbits = 51;
153: outbits = 307;
154: outbits = 179;
155: outbits = 435;
156: outbits = 115;
157: outbits = 371;
158: outbits = 243;
159: outbits = 499;
160: outbits = 11;
161: outbits = 267;
162: outbits = 139;
163: outbits = 395;
164: outbits = 75;
165: outbits = 331;
166: outbits = 203;
167: outbits = 459;
168: outbits = 43;
169: outbits = 299;
170: outbits = 171;
171: outbits = 427;
172: outbits = 107;
173: outbits = 363;
174: outbits = 235;
175: outbits = 491;
176: outbits = 27;
177: outbits = 283;
178: outbits = 155;
179: outbits = 411;
180: outbits = 91;
181: outbits = 347;
182: outbits = 219;
183: outbits = 475;
184: outbits = 59;
185: outbits = 315;
186: outbits = 187;
187: outbits = 443;
188: outbits = 123;
189: outbits = 379;
190: outbits = 251;
191: outbits = 507;
192: outbits = 7;
193: outbits = 263;
194: outbits = 135;
195: outbits = 391;
196: outbits = 71;
197: outbits = 327;
198: outbits = 199;
199: outbits = 455;
200: outbits = 39;
201: outbits = 295;
202: outbits = 167;
203: outbits = 423;
204: outbits = 103;
205: outbits = 359;
206: outbits = 231;
207: outbits = 487;
208: outbits = 23;
209: outbits = 279;
210: outbits = 151;
211: outbits = 407;
212: outbits = 87;
213: outbits = 343;
214: outbits = 215;
215: outbits = 471;
216: outbits = 55;
217: outbits = 311;
218: outbits = 183;
219: outbits = 439;
220: outbits = 119;
221: outbits = 375;
222: outbits = 247;
223: outbits = 503;
224: outbits = 15;
225: outbits = 271;
226: outbits = 143;
227: outbits = 399;
228: outbits = 79;
229: outbits = 335;
230: outbits = 207;
231: outbits = 463;
232: outbits = 47;
233: outbits = 303;
234: outbits = 175;
235: outbits = 431;
236: outbits = 111;
237: outbits = 367;
238: outbits = 239;
239: outbits = 495;
240: outbits = 31;
241: outbits = 287;
242: outbits = 159;
243: outbits = 415;
244: outbits = 95;
245: outbits = 351;
246: outbits = 223;
247: outbits = 479;
248: outbits = 63;
249: outbits = 319;
250: outbits = 191;
251: outbits = 447;
252: outbits = 127;
253: outbits = 383;
254: outbits = 255;
255: outbits = 511;
256: outbits = 0;
257: outbits = 64;
258: outbits = 32;
259: outbits = 96;
260: outbits = 16;
261: outbits = 80;
262: outbits = 48;
263: outbits = 112;
264: outbits = 8;
265: outbits = 72;
266: outbits = 40;
267: outbits = 104;
268: outbits = 24;
269: outbits = 88;
270: outbits = 56;
271: outbits = 120;
272: outbits = 4;
273: outbits = 68;
274: outbits = 36;
275: outbits = 100;
276: outbits = 20;
277: outbits = 84;
278: outbits = 52;
279: outbits = 116;
280: outbits = 3;
281: outbits = 131;
282: outbits = 67;
283: outbits = 195;
284: outbits = 35;
285: outbits = 163;
286: outbits = 99;
default: outbits = 227;
endcase
oaddr <= do;
obyte <= MYHDL16_put(outbits, outlen);
MYHDL17_put_adv(outbits, outlen);
cur_i <= 0;
end
else begin
case ((cur_i + 1))
0: nextdist = 1;
1477,12 → 2104,12
if ((extra_dist > ((1 << extra_bits) - 1))) begin
$finish;
end
outcode = (MYHDL16_rev_bits(cur_i, 5) | (extra_dist << 5));
outcode = (MYHDL18_rev_bits(cur_i, 5) | (extra_dist << 5));
oaddr <= do;
obyte <= MYHDL17_put(outcode, (5 + extra_bits));
MYHDL18_put_adv(outcode, (5 + extra_bits));
obyte <= MYHDL19_put(outcode, (5 + extra_bits));
MYHDL20_put_adv(outcode, (5 + extra_bits));
cur_i <= (($signed({1'b0, di}) - $signed({1'b0, length})) + 1);
state <= 5'b11001;
state <= 5'b11010;
end
else begin
cur_i <= (cur_i + 1);
1489,12 → 2116,12
end
end
end
5'b11001: begin
5'b11010: begin
if ((!1'b1)) begin
// pass
end
else if ((cur_i < di)) begin
bdata = iram[(cur_i & 127)];
bdata = iram[(cur_i & 63)];
adler1_next = ((adler1 + bdata) % 65521);
adler1 <= adler1_next;
adler2 <= ((adler2 + ladler1) % 65521);
1505,6 → 2132,49
state <= 5'b10110;
end
end
5'b11000: begin
if ((1'b1 && 1'b1)) begin
lfmatch = length;
distance = (lfmatch + 1);
fmatch2 = (($signed({1'b0, di}) - $signed({1'b0, lfmatch})) + 2);
lencode = 257;
match = 3;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 4)) && (iram[(fmatch2 & 63)] == b4))) begin
lencode = 258;
match = 4;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 5)) && (iram[((fmatch2 + 1) & 63)] == b5))) begin
lencode = 259;
match = 5;
if ((1'b1 && ($signed({1'b0, di}) < ($signed({1'b0, isize}) - 6)) && (iram[((fmatch2 + 2) & 63)] == b6))) begin
lencode = 260;
match = 6;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 7)) && (iram[((fmatch2 + 3) & 63)] == b7))) begin
lencode = 261;
match = 7;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 8)) && (iram[((fmatch2 + 4) & 63)] == b8))) begin
lencode = 262;
match = 8;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 9)) && (iram[((fmatch2 + 5) & 63)] == b9))) begin
lencode = 263;
match = 9;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 10)) && (iram[((fmatch2 + 6) & 63)] == b10))) begin
lencode = 264;
match = 10;
end
end
end
end
end
end
end
cur_dist <= distance;
cur_i <= 1024;
di <= (di + match);
cur_cstatic <= ((cur_cstatic + match) - 1);
length <= match;
state <= 5'b11001;
end
end
5'b10111: begin
if ((!1'b1)) begin
// pass
1517,20 → 2187,15
end
else begin
if (((cur_search >= 0) && (cur_search >= ($signed({1'b0, di}) - 32)) && ($signed({1'b0, di}) < ($signed({1'b0, isize}) - 3)))) begin
//
if (1'b1) begin
found = 0;
fmatch = 0;
begin: MYHDL19_BREAK
begin: MYHDL21_BREAK
for (si=0; si<32; si=si+1) begin
if (smatch[si]) begin
$write("fmatch");
$write(" ");
$write("%0d", si);
$write("\n");
fmatch = si;
found = 1;
disable MYHDL19_BREAK;
disable MYHDL21_BREAK;
end
end
end
1538,83 → 2203,32
cur_search <= (-1);
end
else begin
distance = (fmatch + 1);
fmatch = (($signed({1'b0, di}) - fmatch) + 2);
lencode = 257;
match = 3;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 4)) && (iram[(fmatch & 127)] == b4))) begin
lencode = 258;
match = 4;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 5)) && (iram[((fmatch + 1) & 127)] == b5))) begin
lencode = 259;
match = 5;
if ((1'b1 && ($signed({1'b0, di}) < ($signed({1'b0, isize}) - 6)) && (iram[((fmatch + 2) & 127)] == b6))) begin
lencode = 260;
match = 6;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 7)) && (iram[((fmatch + 3) & 127)] == b7))) begin
lencode = 261;
match = 7;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 8)) && (iram[((fmatch + 4) & 127)] == b8))) begin
lencode = 262;
match = 8;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 9)) && (iram[((fmatch + 5) & 127)] == b9))) begin
lencode = 263;
match = 9;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 10)) && (iram[((fmatch + 6) & 127)] == b10))) begin
lencode = 264;
match = 10;
end
end
end
end
end
end
end
$write("fast:");
$write(" ");
$write("%0d", distance);
$write(" ");
$write("%h", di);
$write(" ");
$write("%h", isize);
$write(" ");
$write("%0d", match);
$write("\n");
outlen = codeLength[lencode];
outbits = code_bits[lencode];
oaddr <= do;
obyte <= MYHDL21_put(outbits, outlen);
MYHDL22_put_adv(outbits, outlen);
cur_dist <= distance;
cur_i <= 0;
di <= (di + match);
cur_cstatic <= ((cur_cstatic + match) - 1);
length <= match;
length <= fmatch;
state <= 5'b11000;
end
end
else if (((iram[(cur_search & 127)] == b1) && (iram[((cur_search + 1) & 127)] == b2) && (iram[((cur_search + 2) & 127)] == b3))) begin
else if (((!1'b1) && (iram[(cur_search & 63)] == b1) && (iram[((cur_search + 1) & 63)] == b2) && (iram[((cur_search + 2) & 63)] == b3))) begin
lencode = 257;
match = 3;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 4)) && (iram[((cur_search + 3) & 127)] == b4))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 4)) && (iram[((cur_search + 3) & 63)] == b4))) begin
lencode = 258;
match = 4;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 5)) && (iram[((cur_search + 4) & 127)] == iram[((di + 4) & 127)]))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 5)) && (iram[((cur_search + 4) & 63)] == b5))) begin
lencode = 259;
match = 5;
if ((1'b1 && ($signed({1'b0, di}) < ($signed({1'b0, isize}) - 6)) && (iram[((cur_search + 5) & 127)] == iram[((di + 5) & 127)]))) begin
if ((1'b1 && ($signed({1'b0, di}) < ($signed({1'b0, isize}) - 6)) && (iram[((cur_search + 5) & 63)] == b6))) begin
lencode = 260;
match = 6;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 7)) && (iram[((cur_search + 6) & 127)] == iram[((di + 6) & 127)]))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 7)) && (iram[((cur_search + 6) & 63)] == b7))) begin
lencode = 261;
match = 7;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 8)) && (iram[((cur_search + 7) & 127)] == iram[((di + 7) & 127)]))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 8)) && (iram[((cur_search + 7) & 63)] == b8))) begin
lencode = 262;
match = 8;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 9)) && (iram[((cur_search + 8) & 127)] == iram[((di + 8) & 127)]))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 9)) && (iram[((cur_search + 8) & 63)] == b9))) begin
lencode = 263;
match = 9;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 10)) && (iram[((cur_search + 9) & 127)] == iram[((di + 9) & 127)]))) begin
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 10)) && (iram[((cur_search + 9) & 63)] == b10))) begin
lencode = 264;
match = 10;
end
1624,28 → 2238,13
end
end
end
$write("found:");
$write(" ");
$write("%h", cur_search);
$write(" ");
$write("%h", di);
$write(" ");
$write("%h", isize);
$write(" ");
$write("%0d", match);
$write("\n");
outlen = codeLength[lencode];
outbits = code_bits[lencode];
oaddr <= do;
obyte <= MYHDL23_put(outbits, outlen);
MYHDL24_put_adv(outbits, outlen);
distance = ($signed({1'b0, di}) - cur_search);
cur_dist <= distance;
cur_i <= 0;
cur_i <= 1024;
di <= (di + match);
cur_cstatic <= ((cur_cstatic + match) - 1);
length <= match;
state <= 5'b11000;
state <= 5'b11001;
end
else begin
cur_search <= (cur_search - 1);
1652,13 → 2251,302
end
end
else begin
bdata = iram[di];
bdata = b1;
di <= (di + 1);
outlen = codeLength[bdata];
outbits = code_bits[bdata];
case (bdata)
0: outbits = 12;
1: outbits = 140;
2: outbits = 76;
3: outbits = 204;
4: outbits = 44;
5: outbits = 172;
6: outbits = 108;
7: outbits = 236;
8: outbits = 28;
9: outbits = 156;
10: outbits = 92;
11: outbits = 220;
12: outbits = 60;
13: outbits = 188;
14: outbits = 124;
15: outbits = 252;
16: outbits = 2;
17: outbits = 130;
18: outbits = 66;
19: outbits = 194;
20: outbits = 34;
21: outbits = 162;
22: outbits = 98;
23: outbits = 226;
24: outbits = 18;
25: outbits = 146;
26: outbits = 82;
27: outbits = 210;
28: outbits = 50;
29: outbits = 178;
30: outbits = 114;
31: outbits = 242;
32: outbits = 10;
33: outbits = 138;
34: outbits = 74;
35: outbits = 202;
36: outbits = 42;
37: outbits = 170;
38: outbits = 106;
39: outbits = 234;
40: outbits = 26;
41: outbits = 154;
42: outbits = 90;
43: outbits = 218;
44: outbits = 58;
45: outbits = 186;
46: outbits = 122;
47: outbits = 250;
48: outbits = 6;
49: outbits = 134;
50: outbits = 70;
51: outbits = 198;
52: outbits = 38;
53: outbits = 166;
54: outbits = 102;
55: outbits = 230;
56: outbits = 22;
57: outbits = 150;
58: outbits = 86;
59: outbits = 214;
60: outbits = 54;
61: outbits = 182;
62: outbits = 118;
63: outbits = 246;
64: outbits = 14;
65: outbits = 142;
66: outbits = 78;
67: outbits = 206;
68: outbits = 46;
69: outbits = 174;
70: outbits = 110;
71: outbits = 238;
72: outbits = 30;
73: outbits = 158;
74: outbits = 94;
75: outbits = 222;
76: outbits = 62;
77: outbits = 190;
78: outbits = 126;
79: outbits = 254;
80: outbits = 1;
81: outbits = 129;
82: outbits = 65;
83: outbits = 193;
84: outbits = 33;
85: outbits = 161;
86: outbits = 97;
87: outbits = 225;
88: outbits = 17;
89: outbits = 145;
90: outbits = 81;
91: outbits = 209;
92: outbits = 49;
93: outbits = 177;
94: outbits = 113;
95: outbits = 241;
96: outbits = 9;
97: outbits = 137;
98: outbits = 73;
99: outbits = 201;
100: outbits = 41;
101: outbits = 169;
102: outbits = 105;
103: outbits = 233;
104: outbits = 25;
105: outbits = 153;
106: outbits = 89;
107: outbits = 217;
108: outbits = 57;
109: outbits = 185;
110: outbits = 121;
111: outbits = 249;
112: outbits = 5;
113: outbits = 133;
114: outbits = 69;
115: outbits = 197;
116: outbits = 37;
117: outbits = 165;
118: outbits = 101;
119: outbits = 229;
120: outbits = 21;
121: outbits = 149;
122: outbits = 85;
123: outbits = 213;
124: outbits = 53;
125: outbits = 181;
126: outbits = 117;
127: outbits = 245;
128: outbits = 13;
129: outbits = 141;
130: outbits = 77;
131: outbits = 205;
132: outbits = 45;
133: outbits = 173;
134: outbits = 109;
135: outbits = 237;
136: outbits = 29;
137: outbits = 157;
138: outbits = 93;
139: outbits = 221;
140: outbits = 61;
141: outbits = 189;
142: outbits = 125;
143: outbits = 253;
144: outbits = 19;
145: outbits = 275;
146: outbits = 147;
147: outbits = 403;
148: outbits = 83;
149: outbits = 339;
150: outbits = 211;
151: outbits = 467;
152: outbits = 51;
153: outbits = 307;
154: outbits = 179;
155: outbits = 435;
156: outbits = 115;
157: outbits = 371;
158: outbits = 243;
159: outbits = 499;
160: outbits = 11;
161: outbits = 267;
162: outbits = 139;
163: outbits = 395;
164: outbits = 75;
165: outbits = 331;
166: outbits = 203;
167: outbits = 459;
168: outbits = 43;
169: outbits = 299;
170: outbits = 171;
171: outbits = 427;
172: outbits = 107;
173: outbits = 363;
174: outbits = 235;
175: outbits = 491;
176: outbits = 27;
177: outbits = 283;
178: outbits = 155;
179: outbits = 411;
180: outbits = 91;
181: outbits = 347;
182: outbits = 219;
183: outbits = 475;
184: outbits = 59;
185: outbits = 315;
186: outbits = 187;
187: outbits = 443;
188: outbits = 123;
189: outbits = 379;
190: outbits = 251;
191: outbits = 507;
192: outbits = 7;
193: outbits = 263;
194: outbits = 135;
195: outbits = 391;
196: outbits = 71;
197: outbits = 327;
198: outbits = 199;
199: outbits = 455;
200: outbits = 39;
201: outbits = 295;
202: outbits = 167;
203: outbits = 423;
204: outbits = 103;
205: outbits = 359;
206: outbits = 231;
207: outbits = 487;
208: outbits = 23;
209: outbits = 279;
210: outbits = 151;
211: outbits = 407;
212: outbits = 87;
213: outbits = 343;
214: outbits = 215;
215: outbits = 471;
216: outbits = 55;
217: outbits = 311;
218: outbits = 183;
219: outbits = 439;
220: outbits = 119;
221: outbits = 375;
222: outbits = 247;
223: outbits = 503;
224: outbits = 15;
225: outbits = 271;
226: outbits = 143;
227: outbits = 399;
228: outbits = 79;
229: outbits = 335;
230: outbits = 207;
231: outbits = 463;
232: outbits = 47;
233: outbits = 303;
234: outbits = 175;
235: outbits = 431;
236: outbits = 111;
237: outbits = 367;
238: outbits = 239;
239: outbits = 495;
240: outbits = 31;
241: outbits = 287;
242: outbits = 159;
243: outbits = 415;
244: outbits = 95;
245: outbits = 351;
246: outbits = 223;
247: outbits = 479;
248: outbits = 63;
249: outbits = 319;
250: outbits = 191;
251: outbits = 447;
252: outbits = 127;
253: outbits = 383;
254: outbits = 255;
255: outbits = 511;
256: outbits = 0;
257: outbits = 64;
258: outbits = 32;
259: outbits = 96;
260: outbits = 16;
261: outbits = 80;
262: outbits = 48;
263: outbits = 112;
264: outbits = 8;
265: outbits = 72;
266: outbits = 40;
267: outbits = 104;
268: outbits = 24;
269: outbits = 88;
270: outbits = 56;
271: outbits = 120;
272: outbits = 4;
273: outbits = 68;
274: outbits = 36;
275: outbits = 100;
276: outbits = 20;
277: outbits = 84;
278: outbits = 52;
279: outbits = 116;
280: outbits = 3;
281: outbits = 131;
282: outbits = 67;
283: outbits = 195;
284: outbits = 35;
285: outbits = 163;
286: outbits = 99;
default: outbits = 227;
endcase
oaddr <= do;
obyte <= MYHDL25_put(outbits, outlen);
MYHDL26_put_adv(outbits, outlen);
obyte <= MYHDL23_put(outbits, outlen);
MYHDL24_put_adv(outbits, outlen);
state <= 5'b10110;
end
end
1677,25 → 2565,19
codeLength[stat_i] <= 8;
end
numCodeLength <= 288;
cur_HF1 <= 0;
state <= 5'b00111;
// if cur_static < 288:
// if cur_static < 144:
// codeLength[cur_static].next = 8
// elif cur_static < 256:
// codeLength[cur_static].next = 9
// elif cur_static < 280:
// codeLength[cur_static].next = 7
// else:
// codeLength[cur_static].next = 8
// cur_static.next = cur_static + 1
// else:
// numCodeLength.next = 288
// cur_HF1.next = 0
// state.next = d_state.HF1
if (do_compress) begin
state <= 5'b10110;
end
else begin
cur_HF1 <= 0;
state <= 5'b00111;
end
end
5'b00010: begin
if ((!filled)) begin
if (((!1'b1) || (!1'b0))) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
1702,23 → 2584,27
// pass
end
else if ((numLiterals == 0)) begin
numLiterals <= (257 + MYHDL35_get4(0, 5));
$write("%h", di);
$write(" ");
$write("%h", isize);
$write("\n");
numLiterals <= (257 + MYHDL33_get4(0, 5));
$write("NL:");
$write(" ");
$write("%0d", (257 + MYHDL36_get4(0, 5)));
$write("%0d", (257 + MYHDL34_get4(0, 5)));
$write("\n");
numDistance <= (1 + MYHDL37_get4(5, 5));
numDistance <= (1 + MYHDL35_get4(5, 5));
$write("ND:");
$write(" ");
$write("%0d", (1 + MYHDL38_get4(5, 5)));
$write("%0d", (1 + MYHDL36_get4(5, 5)));
$write("\n");
b_numCodeLength <= (4 + MYHDL39_get4(10, 4));
b_numCodeLength <= (4 + MYHDL37_get4(10, 4));
$write("NCL:");
$write(" ");
$write("%0d", (4 + MYHDL40_get4(10, 4)));
$write("%0d", (4 + MYHDL38_get4(10, 4)));
$write("\n");
numCodeLength <= 0;
MYHDL41_adv(14);
MYHDL39_adv(14);
end
else begin
if ((numCodeLength < 19)) begin
1744,8 → 2630,8
default: clo_i = 15;
endcase
if ((numCodeLength < b_numCodeLength)) begin
codeLength[clo_i] <= MYHDL42_get4(0, 3);
MYHDL43_adv(3);
codeLength[clo_i] <= MYHDL40_get4(0, 3);
MYHDL41_adv(3);
end
else begin
codeLength[clo_i] <= 0;
1760,7 → 2646,10
end
end
5'b00011: begin
if ((!filled)) begin
if (((!1'b1) || (!1'b0))) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
1773,16 → 2662,16
lastToken <= code;
end
else if ((code == 16)) begin
howOften <= (3 + MYHDL44_get4(0, 2));
howOften <= (3 + MYHDL42_get4(0, 2));
n_adv = 2;
end
else if ((code == 17)) begin
howOften <= (3 + MYHDL45_get4(0, 3));
howOften <= (3 + MYHDL43_get4(0, 3));
lastToken <= 0;
n_adv = 3;
end
else if ((code == 18)) begin
howOften <= (11 + MYHDL46_get4(0, 7));
howOften <= (11 + MYHDL44_get4(0, 7));
lastToken <= 0;
n_adv = 7;
end
1790,7 → 2679,7
$finish;
end
if ((n_adv != 0)) begin
MYHDL47_adv(n_adv);
MYHDL45_adv(n_adv);
end
state <= 5'b00100;
end
1808,348 → 2697,624
state <= 5'b00110;
end
end
default: begin
if ((state == 5'b00110)) begin
if ((cur_i < 288)) begin
codeLength[cur_i] <= 0;
cur_i <= (cur_i + 1);
5'b00110: begin
if ((!1'b1)) begin
// pass
end
else if ((cur_i < 320)) begin
codeLength[cur_i] <= 0;
cur_i <= (cur_i + 1);
end
else begin
method <= 3;
cur_HF1 <= 0;
state <= 5'b00111;
end
end
5'b00101: begin
if ((1'b1 && 1'b0)) begin
$write("DISTTREE");
$write("\n");
for (dist_i=0; dist_i<32; dist_i=dist_i+1) begin
codeLength[dist_i] <= distanceLength[dist_i];
end
numCodeLength <= 32;
method <= 4;
cur_HF1 <= 0;
state <= 5'b00111;
end
end
5'b00100: begin
if ((!1'b1)) begin
// pass
end
else if ((howOften != 0)) begin
codeLength[numCodeLength] <= lastToken;
howOften <= (howOften - 1);
numCodeLength <= (numCodeLength + 1);
end
else if ((numCodeLength < (numLiterals + numDistance))) begin
cur_next <= 0;
state <= 5'b10011;
end
else begin
state <= 5'b00011;
end
end
5'b00111: begin
if (1'b1) begin
if ((cur_HF1 < 16)) begin
bitLengthCount[cur_HF1] <= 0;
end
if (((cur_HF1 < 1) && 1'b0)) begin
d_leaves[cur_HF1] <= 0;
end
if (((method != 4) && (cur_HF1 < 512))) begin
lwaddr <= cur_HF1;
wleaf <= 0;
end
limit = 512;
if (((method == 4) && 1'b0)) begin
limit = 1;
end
if ((cur_HF1 < limit)) begin
cur_HF1 <= (cur_HF1 + 1);
end
else begin
numCodeLength <= 288;
method <= 3;
cur_HF1 <= 0;
state <= 5'b00111;
$write("DID HF1 INIT");
$write("\n");
cur_i <= 0;
state <= 5'b01000;
end
end
end
5'b01000: begin
if ((!1'b1)) begin
// pass
end
else if ((cur_i < numCodeLength)) begin
j = codeLength[cur_i];
bitLengthCount[j] <= (bitLengthCount[j] + 1);
cur_i <= (cur_i + 1);
end
else begin
case (state)
5'b00101: begin
$write("DISTTREE");
$write("\n");
for (dist_i=0; dist_i<32; dist_i=dist_i+1) begin
codeLength[dist_i] <= distanceLength[dist_i];
end
numCodeLength <= 32;
method <= 4;
cur_HF1 <= 0;
state <= 5'b00111;
bitLengthCount[0] <= 0;
state <= 5'b01001;
cur_i <= 1;
if ((method == 4)) begin
d_maxBits <= 0;
end
else begin
maxBits <= 0;
end
minBits <= 15;
end
end
5'b01001: begin
if ((!1'b1)) begin
// pass
end
else if ((cur_i <= 15)) begin
if ((bitLengthCount[cur_i] != 0)) begin
if ((cur_i < minBits)) begin
minBits <= cur_i;
end
5'b00100: begin
if ((howOften != 0)) begin
codeLength[numCodeLength] <= lastToken;
howOften <= (howOften - 1);
numCodeLength <= (numCodeLength + 1);
if ((method == 4)) begin
if ((cur_i > d_maxBits)) begin
d_maxBits <= cur_i;
end
else if ((numCodeLength < (numLiterals + numDistance))) begin
cur_next <= 0;
state <= 5'b10011;
end
else begin
state <= 5'b00011;
end
end
5'b00111: begin
if ((cur_HF1 < 16)) begin
bitLengthCount[cur_HF1] <= 0;
else begin
if ((cur_i > maxBits)) begin
maxBits <= cur_i;
end
if ((cur_HF1 < 128)) begin
d_leaves[cur_HF1] <= 0;
end
if (((method != 4) && (cur_HF1 < 512))) begin
lwaddr <= cur_HF1;
wleaf <= 0;
end
limit = 512;
if ((method == 4)) begin
limit = 128;
end
if ((cur_HF1 < limit)) begin
cur_HF1 <= (cur_HF1 + 1);
end
else begin
$write("DID HF1 INIT");
$write("\n");
cur_i <= 0;
state <= 5'b01000;
end
end
5'b01000: begin
if ((cur_i < numCodeLength)) begin
j = codeLength[cur_i];
bitLengthCount[j] <= (bitLengthCount[j] + 1);
cur_i <= (cur_i + 1);
end
else begin
bitLengthCount[0] <= 0;
state <= 5'b01001;
cur_i <= 1;
if ((method == 4)) begin
d_maxBits <= 0;
end
else begin
maxBits <= 0;
end
minBits <= 15;
end
end
cur_i <= (cur_i + 1);
end
else begin
$write("%h", minBits);
$write(" ");
$write("%h", maxBits);
$write("\n");
t = 10;
if (((method == 4) && 1'b0)) begin
if ((t > d_maxBits)) begin
t = d_maxBits;
end
5'b01001: begin
if ((cur_i <= 15)) begin
if ((bitLengthCount[cur_i] != 0)) begin
if ((cur_i < minBits)) begin
minBits <= cur_i;
end
if ((method == 4)) begin
if ((cur_i > d_maxBits)) begin
d_maxBits <= cur_i;
end
end
else begin
if ((cur_i > maxBits)) begin
maxBits <= cur_i;
end
end
end
cur_i <= (cur_i + 1);
end
else begin
$write("%h", minBits);
$write(" ");
$write("%h", maxBits);
$write("\n");
t = 10;
if ((method == 4)) begin
if ((t > d_maxBits)) begin
t = d_maxBits;
end
d_instantMaxBit <= t;
d_instantMask <= ((1 << t) - 1);
end
else begin
if ((t > maxBits)) begin
t = maxBits;
end
instantMaxBit <= t;
instantMask <= ((1 << t) - 1);
end
$write("%0d", ((1 << t) - 1));
$write("\n");
state <= 5'b01010;
cur_i <= minBits;
code <= 0;
for (hf2_i=0; hf2_i<15; hf2_i=hf2_i+1) begin
nextCode[hf2_i] <= 0;
end
$write("to HF3");
$write("\n");
end
d_instantMaxBit <= t;
d_instantMask <= ((1 << t) - 1);
end
else begin
if ((t > maxBits)) begin
t = maxBits;
end
5'b01010: begin
amb = maxBits;
if ((method == 4)) begin
amb = d_maxBits;
end
if ((cur_i <= amb)) begin
ncode = ((code + bitLengthCount[($signed({1'b0, cur_i}) - 1)]) << 1);
code <= ncode;
nextCode[cur_i] <= ncode;
cur_i <= (cur_i + 1);
end
else begin
state <= 5'b01011;
cur_i <= 0;
spread_i <= 0;
$write("to HF4");
$write("\n");
end
instantMaxBit <= t;
instantMask <= ((1 << t) - 1);
end
$write("%0d", ((1 << t) - 1));
$write("\n");
state <= 5'b01010;
cur_i <= minBits;
code <= 0;
for (hf2_i=0; hf2_i<16; hf2_i=hf2_i+1) begin
nextCode[hf2_i] <= 0;
end
$write("to HF3");
$write("\n");
end
end
5'b01010: begin
if (1'b1) begin
amb = maxBits;
if (((method == 4) && 1'b0)) begin
amb = d_maxBits;
end
if ((cur_i <= amb)) begin
ncode = ((code + bitLengthCount[($signed({1'b0, cur_i}) - 1)]) << 1);
code <= ncode;
nextCode[cur_i] <= ncode;
cur_i <= (cur_i + 1);
end
else begin
state <= 5'b01011;
cur_i <= 0;
spread_i <= 0;
$write("to HF4");
$write("\n");
end
end
end
5'b01100: begin
if (1'b1) begin
canonical = nextCode[bits];
nextCode[bits] <= (nextCode[bits] + 1);
if ((bits > 15)) begin
$finish;
end
reverse <= MYHDL52_rev_bits(canonical, bits);
leaf <= MYHDL53_makeLeaf(spread_i, bits);
state <= 5'b01101;
end
end
5'b01101: begin
if ((!1'b1)) begin
// pass
end
else if (((method == 4) && 1'b0)) begin
d_leaves[reverse] <= leaf;
if ((bits <= d_instantMaxBit)) begin
if (((reverse + (1 << bits)) <= d_instantMask)) begin
step <= (1 << bits);
spread <= (reverse + (1 << bits));
state <= 5'b10010;
end
5'b01100: begin
canonical = nextCode[bits];
nextCode[bits] <= (nextCode[bits] + 1);
if ((bits > 15)) begin
$finish;
end
reverse <= MYHDL54_rev_bits(canonical, bits);
leaf <= MYHDL55_makeLeaf(spread_i, bits);
state <= 5'b01101;
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
5'b01101: begin
if ((method == 4)) begin
d_leaves[reverse] <= leaf;
if ((bits <= d_instantMaxBit)) begin
if (((reverse + (1 << bits)) <= d_instantMask)) begin
step <= (1 << bits);
spread <= (reverse + (1 << bits));
state <= 5'b10010;
end
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
end
else begin
state <= 5'b01011;
spread_i <= (spread_i + 1);
end
end
else begin
wleaf <= leaf;
lwaddr <= reverse;
code_bits[spread_i] <= reverse;
if ((bits <= instantMaxBit)) begin
if (((reverse + (1 << bits)) <= instantMask)) begin
step <= (1 << bits);
spread <= (reverse + (1 << bits));
state <= 5'b10010;
end
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
end
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
end
end
else begin
state <= 5'b01011;
spread_i <= (spread_i + 1);
end
end
else begin
wleaf <= leaf;
lwaddr <= reverse;
if ((bits <= instantMaxBit)) begin
if (((reverse + (1 << bits)) <= instantMask)) begin
step <= (1 << bits);
spread <= (reverse + (1 << bits));
state <= 5'b10010;
end
5'b01011: begin
if ((spread_i < numCodeLength)) begin
bits_next = codeLength[spread_i];
if ((bits_next != 0)) begin
bits <= bits_next;
state <= 5'b01100;
end
else begin
spread_i <= (spread_i + 1);
end
end
else begin
if (do_compress) begin
state <= 5'b10110;
cur_cstatic <= 0;
end
else if ((method == 3)) begin
state <= 5'b00101;
end
else if ((method == 4)) begin
$write("DEFLATE m2!");
$write("\n");
state <= 5'b10011;
end
else if ((method == 2)) begin
numCodeLength <= 0;
state <= 5'b10011;
end
else begin
state <= 5'b10011;
end
cur_next <= 0;
cur_i <= 0;
end
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
5'b10010: begin
if ((method == 4)) begin
d_leaves[spread] <= MYHDL56_makeLeaf(spread_i, codeLength[spread_i]);
end
else begin
lwaddr <= spread;
wleaf <= MYHDL57_makeLeaf(spread_i, codeLength[spread_i]);
end
aim = instantMask;
if ((method == 4)) begin
aim = d_instantMask;
end
if (($signed({1'b0, spread}) > ($signed({1'b0, aim}) - $signed({1'b0, step})))) begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
else begin
spread <= (spread + step);
end
end
5'b10011: begin
if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((cur_next == 0)) begin
cto = MYHDL58_get4(0, maxBits);
cur_next <= 1;
mask = ((1 << instantMaxBit) - 1);
leaf <= leaves[(cto & mask)];
end
else begin
if ((MYHDL59_get_bits(leaf) < 1)) begin
$write("< 1 bits: ");
$write("\n");
$finish;
end
MYHDL61_adv(MYHDL60_get_bits(leaf));
if ((MYHDL62_get_code(leaf) == 0)) begin
$write("leaf 0");
$write("\n");
end
code <= MYHDL63_get_code(leaf);
if ((method == 2)) begin
state <= 5'b00011;
end
else begin
state <= 5'b10100;
end
end
end
5'b01111: begin
if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else begin
token = (code - 257);
case (token)
0: extraLength = 0;
1: extraLength = 0;
2: extraLength = 0;
3: extraLength = 0;
4: extraLength = 0;
5: extraLength = 0;
6: extraLength = 0;
7: extraLength = 0;
8: extraLength = 1;
9: extraLength = 1;
10: extraLength = 1;
11: extraLength = 1;
12: extraLength = 2;
13: extraLength = 2;
14: extraLength = 2;
15: extraLength = 2;
16: extraLength = 3;
17: extraLength = 3;
18: extraLength = 3;
19: extraLength = 3;
20: extraLength = 4;
21: extraLength = 4;
22: extraLength = 4;
23: extraLength = 4;
24: extraLength = 5;
25: extraLength = 5;
26: extraLength = 5;
27: extraLength = 5;
default: extraLength = 0;
endcase
cto = MYHDL64_get4(extraLength, d_maxBits);
mask = ((1 << d_instantMaxBit) - 1);
leaf <= d_leaves[(cto & mask)];
state <= 5'b10000;
end
end
5'b10000: begin
if ((MYHDL65_get_bits(leaf) == 0)) begin
$finish;
end
end
else begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
end
end
5'b01011: begin
if ((!1'b1)) begin
// pass
end
else if ((spread_i < numCodeLength)) begin
bits_next = codeLength[spread_i];
if ((bits_next != 0)) begin
bits <= bits_next;
state <= 5'b01100;
end
else begin
spread_i <= (spread_i + 1);
end
end
else begin
if (do_compress) begin
state <= 5'b10110;
cur_cstatic <= 0;
end
else if (((method == 3) && 1'b0)) begin
state <= 5'b00101;
end
else if (((method == 4) && 1'b0)) begin
$write("DEFLATE m2!");
$write("\n");
state <= 5'b10011;
end
else if (((method == 2) && 1'b0)) begin
numCodeLength <= 0;
state <= 5'b10011;
end
else begin
state <= 5'b10011;
end
cur_next <= 0;
cur_i <= 0;
end
end
5'b10010: begin
if (1'b1) begin
if (((method == 4) && 1'b0)) begin
d_leaves[spread] <= MYHDL54_makeLeaf(spread_i, codeLength[spread_i]);
end
else begin
lwaddr <= spread;
wleaf <= MYHDL55_makeLeaf(spread_i, codeLength[spread_i]);
end
aim = instantMask;
if (((method == 4) && 1'b0)) begin
aim = d_instantMask;
end
if (($signed({1'b0, spread}) > ($signed({1'b0, aim}) - $signed({1'b0, step})))) begin
spread_i <= (spread_i + 1);
state <= 5'b01011;
end
else begin
spread <= (spread + step);
end
end
end
5'b10011: begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((cur_next == 0)) begin
cto = MYHDL56_get4(0, maxBits);
mask = ((1 << instantMaxBit) - 1);
lraddr <= (cto & mask);
filled <= 1'b0;
cur_next <= (instantMaxBit + 1);
end
else if ((MYHDL57_get_bits(rleaf) >= cur_next)) begin
$write("CACHE MISS");
$write(" ");
$write("%h", cur_next);
$write("\n");
cto = MYHDL58_get4(0, maxBits);
mask = ((1 << cur_next) - 1);
lraddr <= (cto & mask);
filled <= 1'b0;
cur_next <= (cur_next + 1);
end
else begin
if ((MYHDL59_get_bits(rleaf) < 1)) begin
$write("< 1 bits: ");
$write("\n");
$finish;
end
MYHDL61_adv(MYHDL60_get_bits(rleaf));
// if get_code(leaf) == 0:
// print("leaf 0", di, isize)
code <= MYHDL62_get_code(rleaf);
if (((method == 2) && 1'b0)) begin
state <= 5'b00011;
end
else begin
state <= 5'b10100;
end
end
end
5'b01111: begin
if (((!1'b1) || (!1'b0))) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((cur_next == 0)) begin
if ((d_instantMaxBit > 10)) begin
$finish;
end
token = (code - 257);
case (token)
0: extraLength = 0;
1: extraLength = 0;
2: extraLength = 0;
3: extraLength = 0;
4: extraLength = 0;
5: extraLength = 0;
6: extraLength = 0;
7: extraLength = 0;
8: extraLength = 1;
9: extraLength = 1;
10: extraLength = 1;
11: extraLength = 1;
12: extraLength = 2;
13: extraLength = 2;
14: extraLength = 2;
15: extraLength = 2;
16: extraLength = 3;
17: extraLength = 3;
18: extraLength = 3;
19: extraLength = 3;
20: extraLength = 4;
21: extraLength = 4;
22: extraLength = 4;
23: extraLength = 4;
24: extraLength = 5;
25: extraLength = 5;
26: extraLength = 5;
27: extraLength = 5;
default: extraLength = 0;
endcase
cto = MYHDL63_get4(extraLength, d_maxBits);
mask = ((1 << d_instantMaxBit) - 1);
leaf <= d_leaves[(cto & mask)];
cur_next <= (instantMaxBit + 1);
end
else if ((MYHDL64_get_bits(leaf) >= cur_next)) begin
$write("DCACHE MISS");
$write(" ");
$write("%h", cur_next);
$write("\n");
token = (code - 257);
case (token)
0: extraLength = 0;
1: extraLength = 0;
2: extraLength = 0;
3: extraLength = 0;
4: extraLength = 0;
5: extraLength = 0;
6: extraLength = 0;
7: extraLength = 0;
8: extraLength = 1;
9: extraLength = 1;
10: extraLength = 1;
11: extraLength = 1;
12: extraLength = 2;
13: extraLength = 2;
14: extraLength = 2;
15: extraLength = 2;
16: extraLength = 3;
17: extraLength = 3;
18: extraLength = 3;
19: extraLength = 3;
20: extraLength = 4;
21: extraLength = 4;
22: extraLength = 4;
23: extraLength = 4;
24: extraLength = 5;
25: extraLength = 5;
26: extraLength = 5;
27: extraLength = 5;
default: extraLength = 0;
endcase
cto = MYHDL65_get4(extraLength, d_maxBits);
mask = ((1 << cur_next) - 1);
leaf <= d_leaves[(cto & mask)];
cur_next <= (cur_next + 1);
end
else begin
state <= 5'b10000;
end
end
5'b10000: begin
if ((1'b1 && 1'b0)) begin
if ((MYHDL66_get_bits(leaf) == 0)) begin
$finish;
end
token = (code - 257);
case (token)
0: tlength = 3;
1: tlength = 4;
2: tlength = 5;
3: tlength = 6;
4: tlength = 7;
5: tlength = 8;
6: tlength = 9;
7: tlength = 10;
8: tlength = 11;
9: tlength = 13;
10: tlength = 15;
11: tlength = 17;
12: tlength = 19;
13: tlength = 23;
14: tlength = 27;
15: tlength = 31;
16: tlength = 35;
17: tlength = 43;
18: tlength = 51;
19: tlength = 59;
20: tlength = 67;
21: tlength = 83;
22: tlength = 99;
23: tlength = 115;
24: tlength = 131;
25: tlength = 163;
26: tlength = 195;
27: tlength = 227;
default: tlength = 258;
endcase
case (token)
0: extraLength = 0;
1: extraLength = 0;
2: extraLength = 0;
3: extraLength = 0;
4: extraLength = 0;
5: extraLength = 0;
6: extraLength = 0;
7: extraLength = 0;
8: extraLength = 1;
9: extraLength = 1;
10: extraLength = 1;
11: extraLength = 1;
12: extraLength = 2;
13: extraLength = 2;
14: extraLength = 2;
15: extraLength = 2;
16: extraLength = 3;
17: extraLength = 3;
18: extraLength = 3;
19: extraLength = 3;
20: extraLength = 4;
21: extraLength = 4;
22: extraLength = 4;
23: extraLength = 4;
24: extraLength = 5;
25: extraLength = 5;
26: extraLength = 5;
27: extraLength = 5;
default: extraLength = 0;
endcase
tlength = tlength + MYHDL67_get4(0, extraLength);
distanceCode = MYHDL68_get_code(leaf);
case (distanceCode)
0: distance = 1;
1: distance = 2;
2: distance = 3;
3: distance = 4;
4: distance = 5;
5: distance = 7;
6: distance = 9;
7: distance = 13;
8: distance = 17;
9: distance = 25;
10: distance = 33;
11: distance = 49;
12: distance = 65;
13: distance = 97;
14: distance = 129;
15: distance = 193;
16: distance = 257;
17: distance = 385;
18: distance = 513;
19: distance = 769;
20: distance = 1025;
21: distance = 1537;
22: distance = 2049;
23: distance = 3073;
24: distance = 4097;
25: distance = 6145;
26: distance = 8193;
27: distance = 12289;
28: distance = 16385;
default: distance = 24577;
endcase
case ($signed(distanceCode >>> 1))
0: moreBits = 0;
1: moreBits = 0;
2: moreBits = 1;
3: moreBits = 2;
4: moreBits = 3;
5: moreBits = 4;
6: moreBits = 5;
7: moreBits = 6;
8: moreBits = 7;
9: moreBits = 8;
10: moreBits = 9;
11: moreBits = 10;
12: moreBits = 11;
13: moreBits = 12;
default: moreBits = 13;
endcase
mored = MYHDL70_get4((extraLength + MYHDL69_get_bits(leaf)), moreBits);
distance = distance + mored;
if ((distance > $signed({1'b0, do}))) begin
$write("%0d", distance);
$write(" ");
$write("%h", do);
$write("\n");
$finish;
end
MYHDL72_adv(((moreBits + extraLength) + MYHDL71_get_bits(leaf)));
offset <= (($signed({1'b0, do}) - distance) & 32767);
length <= tlength;
cur_i <= 0;
oraddr <= ($signed({1'b0, do}) - distance);
state <= 5'b10101;
end
end
5'b10100: begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((($signed({1'b0, di}) >= ($signed({1'b0, isize}) - 4)) && (!(i_mode == 0)))) begin
// pass
end
else if ((do >= (i_raddr + 32768))) begin
// pass
end
else if (($signed({1'b0, di}) > ($signed({1'b0, isize}) - 3))) begin
state <= 5'b00000;
o_done <= 1'b1;
$write("NO EOF ");
$write(" ");
$write("%h", di);
$write("\n");
$finish;
end
else if ((code == 256)) begin
$write("EOF:");
$write(" ");
$write("%h", di);
$write(" ");
$write("%h", do);
$write("\n");
if ((!final)) begin
state <= 5'b00001;
filled <= 1'b0;
$write("New Block!");
$write("\n");
end
else begin
o_done <= 1'b1;
state <= 5'b00000;
end
end
else begin
if ((code < 256)) begin
oaddr <= do;
obyte <= code;
o_oprogress <= (do + 1);
do <= (do + 1);
cur_next <= 0;
state <= 5'b10011;
end
else if ((code == 300)) begin
$finish;
end
else begin
if (static) begin
token = (code - 257);
case (token)
0: tlength = 3;
2213,8 → 3378,9
27: extraLength = 5;
default: extraLength = 0;
endcase
tlength = tlength + MYHDL66_get4(0, extraLength);
distanceCode = MYHDL67_get_code(leaf);
tlength = tlength + MYHDL73_get4(0, extraLength);
t = MYHDL74_get4(extraLength, 5);
distanceCode = MYHDL75_rev_bits(t, 5);
case (distanceCode)
0: distance = 1;
1: distance = 2;
2264,9 → 3430,8
13: moreBits = 12;
default: moreBits = 13;
endcase
mored = MYHDL69_get4((extraLength + MYHDL68_get_bits(leaf)), moreBits);
distance = distance + mored;
MYHDL71_adv(((moreBits + extraLength) + MYHDL70_get_bits(leaf)));
distance = distance + MYHDL76_get4((extraLength + 5), moreBits);
MYHDL77_adv(((extraLength + 5) + moreBits));
offset <= ($signed({1'b0, do}) - distance);
length <= tlength;
cur_i <= 0;
2273,260 → 3438,97
oraddr <= ($signed({1'b0, do}) - distance);
state <= 5'b10101;
end
default: begin
if ((state == 5'b10100)) begin
if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((di > isize)) begin
state <= 5'b00000;
o_done <= 1'b1;
$write("NO EOF ");
$write(" ");
$write("%h", di);
$write("\n");
$finish;
end
else if ((code == 256)) begin
$write("EOF:");
$write(" ");
$write("%h", di);
$write(" ");
$write("%h", do);
$write("\n");
if ((!final)) begin
state <= 5'b00001;
end
else begin
o_done <= 1'b1;
o_oprogress <= do;
state <= 5'b00000;
end
end
else begin
if ((code < 256)) begin
oaddr <= do;
obyte <= code;
o_oprogress <= (do + 1);
do <= (do + 1);
cur_next <= 0;
state <= 5'b10011;
end
else if ((code == 300)) begin
$finish;
end
else begin
if (static) begin
token = (code - 257);
case (token)
0: tlength = 3;
1: tlength = 4;
2: tlength = 5;
3: tlength = 6;
4: tlength = 7;
5: tlength = 8;
6: tlength = 9;
7: tlength = 10;
8: tlength = 11;
9: tlength = 13;
10: tlength = 15;
11: tlength = 17;
12: tlength = 19;
13: tlength = 23;
14: tlength = 27;
15: tlength = 31;
16: tlength = 35;
17: tlength = 43;
18: tlength = 51;
19: tlength = 59;
20: tlength = 67;
21: tlength = 83;
22: tlength = 99;
23: tlength = 115;
24: tlength = 131;
25: tlength = 163;
26: tlength = 195;
27: tlength = 227;
default: tlength = 258;
endcase
case (token)
0: extraLength = 0;
1: extraLength = 0;
2: extraLength = 0;
3: extraLength = 0;
4: extraLength = 0;
5: extraLength = 0;
6: extraLength = 0;
7: extraLength = 0;
8: extraLength = 1;
9: extraLength = 1;
10: extraLength = 1;
11: extraLength = 1;
12: extraLength = 2;
13: extraLength = 2;
14: extraLength = 2;
15: extraLength = 2;
16: extraLength = 3;
17: extraLength = 3;
18: extraLength = 3;
19: extraLength = 3;
20: extraLength = 4;
21: extraLength = 4;
22: extraLength = 4;
23: extraLength = 4;
24: extraLength = 5;
25: extraLength = 5;
26: extraLength = 5;
27: extraLength = 5;
default: extraLength = 0;
endcase
tlength = tlength + MYHDL72_get4(0, extraLength);
t = MYHDL73_get4(extraLength, 5);
distanceCode = MYHDL74_rev_bits(t, 5);
case (distanceCode)
0: distance = 1;
1: distance = 2;
2: distance = 3;
3: distance = 4;
4: distance = 5;
5: distance = 7;
6: distance = 9;
7: distance = 13;
8: distance = 17;
9: distance = 25;
10: distance = 33;
11: distance = 49;
12: distance = 65;
13: distance = 97;
14: distance = 129;
15: distance = 193;
16: distance = 257;
17: distance = 385;
18: distance = 513;
19: distance = 769;
20: distance = 1025;
21: distance = 1537;
22: distance = 2049;
23: distance = 3073;
24: distance = 4097;
25: distance = 6145;
26: distance = 8193;
27: distance = 12289;
28: distance = 16385;
default: distance = 24577;
endcase
case ($signed(distanceCode >>> 1))
0: moreBits = 0;
1: moreBits = 0;
2: moreBits = 1;
3: moreBits = 2;
4: moreBits = 3;
5: moreBits = 4;
6: moreBits = 5;
7: moreBits = 6;
8: moreBits = 7;
9: moreBits = 8;
10: moreBits = 9;
11: moreBits = 10;
12: moreBits = 11;
13: moreBits = 12;
default: moreBits = 13;
endcase
distance = distance + MYHDL75_get4((extraLength + 5), moreBits);
MYHDL76_adv(((extraLength + 5) + moreBits));
offset <= ($signed({1'b0, do}) - distance);
length <= tlength;
cur_i <= 0;
oraddr <= ($signed({1'b0, do}) - distance);
state <= 5'b10101;
end
else begin
state <= 5'b01111;
end
end
cur_next <= 0;
end
else begin
if ((!1'b0)) begin
$write("DYNAMIC mode disabled");
$write("\n");
$finish;
end
state <= 5'b01111;
end
end
cur_next <= 0;
end
end
5'b10101: begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if (((cur_i == 0) && ((do + length) >= (i_raddr + 32768)))) begin
// pass
end
else if (($signed({1'b0, di}) >= ($signed({1'b0, isize}) - 2))) begin
// pass
end
else if ((method == 0)) begin
if ((cur_i < length)) begin
oaddr <= do;
obyte <= b3;
MYHDL78_adv(8);
cur_i <= (cur_i + 1);
do <= (do + 1);
o_oprogress <= (do + 1);
end
else if ((!final)) begin
MYHDL79_adv(16);
state <= 5'b00001;
filled <= 1'b0;
$write("new block");
$write("\n");
end
else begin
o_done <= 1'b1;
state <= 5'b00000;
end
end
else if ((cur_i < (length + 2))) begin
oraddr <= (offset + cur_i);
if ((cur_i == 1)) begin
copy1 <= orbyte;
end
if ((cur_i == 3)) begin
copy2 <= orbyte;
end
if ((cur_i > 1)) begin
if ((((offset + cur_i) & 32767) == ((do + 1) & 32767))) begin
obyte <= copy1;
end
else if (((cur_i == 3) || (((offset + cur_i) & 32767) != (do & 32767)))) begin
obyte <= orbyte;
end
else if ((cur_i > 2)) begin
if ((cur_i & 1)) begin
obyte <= copy2;
end
else begin
if ((state == 5'b10101)) begin
if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
// pass
end
else if ((method == 0)) begin
if ((cur_i < length)) begin
oaddr <= do;
obyte <= b3;
MYHDL77_adv(8);
cur_i <= (cur_i + 1);
do <= (do + 1);
o_oprogress <= (do + 1);
end
else if ((!final)) begin
state <= 5'b00001;
end
else begin
o_oprogress <= do;
o_done <= 1'b1;
state <= 5'b00000;
end
end
else if ((cur_i < (length + 2))) begin
oraddr <= (offset + cur_i);
if ((cur_i == 1)) begin
copy1 <= orbyte;
end
if ((cur_i == 3)) begin
copy2 <= orbyte;
end
if ((cur_i > 1)) begin
if (((offset + cur_i) == (do + 1))) begin
obyte <= copy1;
end
else begin
if (((cur_i == 3) || ((offset + cur_i) != do))) begin
obyte <= orbyte;
end
else begin
if ((cur_i > 2)) begin
if ((cur_i & 1)) begin
obyte <= copy2;
end
else begin
obyte <= copy1;
end
end
else begin
obyte <= copy1;
end
end
end
oaddr <= do;
o_oprogress <= (do + 1);
do <= (do + 1);
end
cur_i <= (cur_i + 1);
end
else begin
cur_next <= 0;
state <= 5'b10011;
end
end
else begin
$write("unknown state?!");
$write("\n");
state <= 5'b00000;
end
obyte <= copy1;
end
end
endcase
else begin
obyte <= copy1;
end
oaddr <= do;
o_oprogress <= (do + 1);
do <= (do + 1);
end
cur_i <= (cur_i + 1);
end
else begin
cur_next <= 0;
state <= 5'b10011;
end
end
default: begin
$write("unknown state?!");
$write("\n");
state <= 5'b00000;
end
endcase
end
end
2546,7 → 3548,8
end
else begin
if ((isize < 4)) begin
// pass
nb <= 0;
old_di <= 0;
end
else if (((i_mode == 4) || (i_mode == 5))) begin
nb <= 0;
2559,31 → 3562,28
shift = (($signed({1'b0, di}) - $signed({1'b0, old_di})) * 8);
// if shift != 0:
// print("shift", shift, cwindow, b1, b2, b3, b4)
if ((shift <= 32)) begin
cwindow <= (($signed({1'b0, cwindow}) << shift) | $signed($signed({1'b0, b14}) >>> (32 - shift)));
if (1'b1) begin
cwindow <= (($signed({1'b0, cwindow}) << shift) | $signed($signed({1'b0, b110}) >>> (80 - shift)));
end
else if ((shift == 40)) begin
cwindow <= ((($signed({1'b0, cwindow}) << shift) | (b14 << 8)) | b5);
else begin
cwindow <= (($signed({1'b0, cwindow}) << shift) | $signed($signed({1'b0, b15}) >>> (40 - shift)));
end
else if (1'b1) begin
cwindow <= (($signed({1'b0, cwindow}) << shift) | $signed($signed({1'b0, b110}) >>> (80 - shift)));
end
end
if ((old_di == di)) begin
nb <= 4;
end
old_di <= di;
b1 <= iram[(di & 127)];
b2 <= iram[((di + 1) & 127)];
b3 <= iram[((di + 2) & 127)];
b4 <= iram[((di + 3) & 127)];
b5 <= iram[((di + 4) & 127)];
b1 <= iram[(di & 63)];
b2 <= iram[((di + 1) & 63)];
b3 <= iram[((di + 2) & 63)];
b4 <= iram[((di + 3) & 63)];
b5 <= iram[((di + 4) & 63)];
if (1'b1) begin
b6 <= iram[((di + 5) & 127)];
b7 <= iram[((di + 6) & 127)];
b8 <= iram[((di + 7) & 127)];
b9 <= iram[((di + 8) & 127)];
b10 <= iram[((di + 9) & 127)];
b6 <= iram[((di + 5) & 63)];
b7 <= iram[((di + 6) & 63)];
b8 <= iram[((di + 7) & 63)];
b9 <= iram[((di + 8) & 63)];
b10 <= iram[((di + 9) & 63)];
end
end
end
2598,6 → 3598,7
 
always @(posedge clk) begin: DEFLATE_ORAMREAD
orbyte <= oram[oraddr];
rleaf <= leaves[lraddr];
end
 
 
/trunk/test_deflate.py
8,9 → 8,9
always, always_seq, always_comb, enum, Error
 
from deflate import IDLE, WRITE, READ, STARTC, STARTD, LBSIZE, IBSIZE, \
CWINDOW, COMPRESS
CWINDOW, COMPRESS, DECOMPRESS, OBSIZE, LMAX, LIBSIZE
 
MAXW = 2 * CWINDOW
MAXW = CWINDOW
 
COSIMULATION = True
COSIMULATION = False
19,7 → 19,7
from deflate import deflate
else:
def deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
o_byte, i_addr, clk, reset):
o_byte, i_waddr, i_raddr, clk, reset):
print("Cosimulation")
cmd = "iverilog -o deflate " + \
"deflate.v " + \
29,38 → 29,38
i_mode=i_mode, o_done=o_done,
i_data=i_data, o_iprogress=o_iprogress,
o_oprogress=o_oprogress,
o_byte=o_byte, i_addr=i_addr,
o_byte=o_byte, i_waddr=i_waddr, i_raddr=i_raddr,
clk=clk, reset=reset)
 
 
def test_data(m):
print("MODE", m)
def test_data(m, tlen=100, limit=False):
print("MODE", m, tlen)
if m == 0:
str_data = " ".join(["Hello World! " + str(1) + " "
for i in range(100)])
for i in range(tlen)])
b_data = str_data.encode('utf-8')
elif m == 1:
str_data = " ".join([" Hello World! " + str(i) + " "
# str_data = " ".join(["Hello World! " + str(i) + " "
for i in range(5)])
for i in range(tlen)])
b_data = str_data.encode('utf-8')
elif m == 2:
str_data = " ".join(["Hi: " + str(random.randrange(0,0x1000)) + " "
for i in range(100)])
for i in range(tlen)])
b_data = str_data.encode('utf-8')
elif m == 3:
b_data = bytes([random.randrange(0,0x100) for i in range(100)])
b_data = bytes([random.randrange(0,0x100) for i in range(tlen)])
elif m == 4:
str_data = "".join([str(random.randrange(0,2))
for i in range(1000)])
for i in range(tlen)])
b_data = str_data.encode('utf-8')
else:
raise Error("unknown test mode")
# print(str_data)
b_data = b_data[:IBSIZE - 4 - 20]
if limit:
b_data = b_data[:IBSIZE - 4 - 10]
zl_data = zlib.compress(b_data)
print("From %d to %d bytes" % (len(b_data), len(zl_data)))
print(zl_data)
print(zl_data[:500])
return b_data, zl_data
 
 
69,7 → 69,7
def testMain(self):
 
def test_decompress(i_mode, o_done, i_data, o_iprogress,
o_oprogress, o_byte, i_addr, clk, reset):
o_oprogress, o_byte, i_waddr, i_raddr, clk, reset):
 
def tick():
clk.next = not clk
79,185 → 79,170
print("START TEST MODE", mode)
print("==========================")
 
b_data, zl_data = test_data(mode)
b_data, zl_data = test_data(mode, 25000)
 
reset.next = 0
tick()
yield delay(5)
reset.next = 1
tick()
yield delay(5)
 
print("STARTD")
i_mode.next = STARTD
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
 
print("WRITE")
i_mode.next = WRITE
i = 0
while i < len(zl_data):
if o_iprogress > i - MAXW:
# print("write", i)
i_data.next = zl_data[i]
i_addr.next = i
i = i + 1
else:
# print("Wait for space")
pass
if mode == 0:
reset.next = 0
tick()
yield delay(5)
reset.next = 1
tick()
yield delay(5)
i_mode.next = IDLE
print("Wrote input, wait for end of decompression")
 
# alternative without sliding window:
"""
print("WRITE")
i_mode.next = WRITE
for i in range(len(zl_data)):
i_data.next = zl_data[i]
i_addr.next = i
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
if DECOMPRESS:
print("==========STREAMING DECOMPRESS TEST=========")
 
print("STARTD")
i_mode.next = STARTD
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
"""
print("STREAM LENGTH", len(zl_data))
 
print(now())
while not o_done:
i_mode.next = IDLE
tick()
yield delay(5)
tick()
yield delay(5)
print(now())
 
last = o_oprogress
print("GOT", last)
i_mode.next = READ
d_data = []
for i in range(last):
i_addr.next = i
print("STARTD")
i_mode.next = STARTD
tick()
yield delay(5)
tick()
yield delay(5)
d_data.append(bytes([o_byte]))
i_mode.next = IDLE
 
d_data = b''.join(d_data)
print("WRITE")
i = 0
ri = 0
first = 1
sresult = []
start = now()
wait = 0
while True:
if ri >= 1000 and ri % 10000 == 0:
print(ri)
if ri < o_oprogress:
did_read = 1
# print("do read", ri, o_oprogress)
i_mode.next = READ
i_raddr.next = ri
tick()
yield delay(5)
tick()
yield delay(5)
ri = ri + 1
else:
did_read = 0
 
self.assertEqual(b_data, d_data, "decompress does NOT match")
print(len(d_data), len(zl_data))
if i < len(zl_data):
if o_iprogress > i - MAXW:
i_mode.next = WRITE
i_waddr.next = i
i_data.next = zl_data[i]
# print("write", i, zl_data[i])
i = i + 1
else:
# print("Wait for space", i)
wait += 1
else:
i_mode.next = IDLE
 
print("==========COMPRESS TEST=========")
tick()
yield delay(5)
tick()
yield delay(5)
 
i_mode.next = WRITE
for i in range(len(b_data)):
i_data.next = b_data[i]
i_addr.next = i
if did_read:
# print("read", ri, o_oprogress, o_byte)
sresult.append(bytes([o_byte]))
 
if o_done:
# print("DONE", o_oprogress, ri)
if o_oprogress == ri:
break;
 
i_mode.next = IDLE
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
 
print("IN/OUT/CYCLES/WAIT", len(zl_data), len(sresult),
(now() - start) // 10, wait)
sresult = b''.join(sresult)
self.assertEqual(b_data, sresult)
# self.assertEqual(b_data[:100000], sresult[:100000])
print("Decompress OK!")
 
print("==========STREAMING COMPRESS TEST=========")
 
print("STARTC")
i_mode.next = STARTC
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
 
print(now())
while not o_done:
tick()
yield delay(5)
tick()
yield delay(5)
print(now())
print("WRITE")
i = 0
ri = 0
slen = 25000
sresult = []
wait = 0
start = now()
while True:
if ri < o_oprogress:
did_read = 1
# print("do read", ri, o_oprogress)
i_mode.next = READ
i_raddr.next = ri
tick()
yield delay(5)
tick()
yield delay(5)
if ri % 10000 == 0:
print(ri)
ri = ri + 1
else:
did_read = 0
 
# raise Error("STOP")
if i < slen:
if o_iprogress > i - MAXW:
i_mode.next = WRITE
i_waddr.next = i
i_data.next = b_data[i % len(b_data)]
# print("write", i, b_data[i % len(b_data)])
i = i + 1
else:
# print("Wait for space", i)
wait += 1
else:
i_mode.next = IDLE
 
last = o_oprogress
print("last", last)
i_mode.next = READ
c_data = []
for i in range(last):
i_addr.next = i
tick()
yield delay(5)
tick()
yield delay(5)
c_data.append(bytes([o_byte]))
i_mode.next = IDLE
 
print("b_data:", len(b_data), b_data)
c_data = b''.join(c_data)
print("c_data:", len(c_data), c_data)
print("zl_data:", len(zl_data), zl_data)
if did_read:
# print("read", ri, o_oprogress, o_byte)
sresult.append(bytes([o_byte]))
 
print("zlib test:", zlib.decompress(c_data))
if o_done:
# print("DONE", o_oprogress, ri)
if o_oprogress == ri:
break;
 
print("WRITE COMPRESSED RESULT")
i_mode.next = WRITE
for i in range(len(c_data)):
i_data.next = c_data[i]
i_addr.next = i
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
 
print("STARTD after Compress")
i_mode.next = STARTD
tick()
yield delay(5)
tick()
yield delay(5)
i_mode.next = IDLE
print("IN/OUT/CYCLES/WAIT", slen, len(sresult),
(now() - start) // 10, wait)
sresult = b''.join(sresult)
print("zlib test:", zlib.decompress(sresult)[:60])
rlen = min(len(b_data), slen)
self.assertEqual(zlib.decompress(sresult)[:rlen], b_data[:rlen])
print("DONE!")
 
print(now())
while not o_done:
tick()
yield delay(5)
tick()
yield delay(5)
print(now())
 
last = o_oprogress
i_mode.next = READ
d_data = []
for i in range(last):
i_addr.next = i
tick()
yield delay(5)
tick()
yield delay(5)
d_data.append(bytes([o_byte]))
i_mode.next = IDLE
 
d_data = b''.join(d_data)
 
self.assertEqual(b_data, d_data, "decompress after compress does NOT match")
print(len(b_data), len(zl_data), len(c_data))
 
for loop in range(1):
for mode in range(5):
# for mode in range(2,3):
self.runTests(test_decompress)
 
def runTests(self, test):
268,18 → 253,19
 
i_data = Signal(intbv()[8:])
o_byte = Signal(intbv()[8:])
o_iprogress = Signal(intbv()[LBSIZE:])
o_oprogress = Signal(intbv()[LBSIZE:])
i_addr = Signal(intbv()[LBSIZE:])
o_iprogress = Signal(intbv()[LMAX:])
o_oprogress = Signal(intbv()[LMAX:])
i_waddr = Signal(modbv()[LMAX:])
i_raddr = Signal(modbv()[LMAX:])
 
clk = Signal(bool(0))
reset = ResetSignal(1, 0, True)
 
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
o_byte, i_addr, clk, reset)
o_byte, i_waddr, i_raddr, clk, reset)
 
check = test(i_mode, o_done, i_data, o_iprogress, o_oprogress,
o_byte, i_addr, clk, reset)
o_byte, i_waddr, i_raddr, clk, reset)
sim = Simulation(dut, check)
# traceSignals(dut)
sim.run(quiet=1)
290,7 → 276,7
@block
def test_deflate_bench(i_clk, o_led, led0_g, led1_b, led2_r):
 
u_data, c_data = test_data(1)
u_data, c_data = test_data(1, 100, IBSIZE)
 
CDATA = tuple(c_data)
UDATA = tuple(u_data)
301,15 → 287,16
i_data = Signal(intbv()[8:])
o_byte = Signal(intbv()[8:])
u_data = Signal(intbv()[8:])
o_iprogress = Signal(intbv()[LBSIZE:])
o_oprogress = Signal(intbv()[LBSIZE:])
resultlen = Signal(intbv()[LBSIZE:])
i_addr = Signal(intbv()[LBSIZE:])
o_iprogress = Signal(intbv()[LMAX:])
o_oprogress = Signal(intbv()[LMAX:])
resultlen = Signal(intbv()[LMAX:])
i_waddr = Signal(modbv()[LMAX:])
i_raddr = Signal(modbv()[LBSIZE:])
 
reset = ResetSignal(1, 0, True)
 
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
o_byte, i_addr, i_clk, reset)
o_byte, i_waddr, i_raddr, i_clk, reset)
 
tb_state = enum('RESET', 'START', 'WRITE', 'DECOMPRESS', 'WAIT', 'VERIFY',
'PAUSE', 'CWRITE', 'COMPRESS', 'CWAIT', 'CRESULT',
384,7 → 371,7
led2_r.next = not led2_r
i_mode.next = WRITE
i_data.next = CDATA[tbi]
i_addr.next = tbi
i_waddr.next = tbi
tbi.next = tbi + 1
else:
i_mode.next = IDLE
400,20 → 387,12
i_mode.next = IDLE
if i_mode == IDLE and o_done:
print("result len", o_oprogress)
if o_oprogress == 0x4F:
tstate.next = tb_state.HALT
resultlen.next = o_oprogress
tbi.next = 0
i_addr.next = 0
i_raddr.next = 0
i_mode.next = READ
wtick.next = True
tstate.next = tb_state.VERIFY
"""
if o_oprogress == 0x4F:
tstate.next = tb_state.HALT
else:
tstate.next = tb_state.FAIL
"""
 
elif tstate == tb_state.VERIFY:
# print("VERIFY", o_data)
441,7 → 420,7
else:
pass
# print(tbi, o_data)
i_addr.next = tbi + 1
i_raddr.next = tbi + 1
tbi.next = tbi + 1
wtick.next = True
else:
482,7 → 461,7
led1_b.next = not led1_b
i_mode.next = WRITE
i_data.next = UDATA[tbi]
i_addr.next = tbi
i_waddr.next = tbi
tbi.next = tbi + 1
else:
print("wrote bytes to compress", tbi)
503,7 → 482,7
print("result len", o_oprogress)
resultlen.next = o_oprogress
tbi.next = 0
i_addr.next = 0
i_raddr.next = 0
i_mode.next = READ
tstate.next = tb_state.CRESULT
wtick.next = True
517,13 → 496,13
if tbi > 0:
i_mode.next = WRITE
i_data.next = copy
i_addr.next = tbi - 1
i_waddr.next = tbi - 1
wtick.next = False
tbi.next = tbi + 1
elif tbi < resultlen:
i_mode.next = READ
led1_b.next = not led1_b
i_addr.next = tbi
i_raddr.next = tbi
copy.next = o_byte
wtick.next = True
else:
544,7 → 523,7
if i_mode == IDLE and o_done:
print("DONE DECOMPRESS VERIFY", o_oprogress)
tbi.next = 0
i_addr.next = 0
i_raddr.next = 0
i_mode.next = READ
wtick.next = True
tstate.next = tb_state.CVERIFY
566,7 → 545,7
raise Error("bad result")
tstate.next = tb_state.FAIL
tbi.next = tbi + 1
i_addr.next = tbi + 1
i_raddr.next = tbi + 1
wtick.next = True
else:
print(len(UDATA))

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.