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 
    /
    from Rev 4 to Rev 5
    ↔ Reverse comparison
  •

Rev 4 → Rev 5

/hdl-deflate/trunk/deflate.py
17,6 → 17,13
 
IDLE, RESET, WRITE, READ, STARTC, STARTD = range(6)
 
COMPRESS = True
MATCH10 = False
MATCH10 = True
 
FAST = False
FAST = True
 
CWINDOW = 32 # Search window for compression
 
OBSIZE = 8192 # Size of output buffer (BRAM)
23,11 → 30,12
IBSIZE = 4 * CWINDOW # 2048 # Size of input buffer (LUT-RAM)
 
if OBSIZE > IBSIZE:
LBSIZE = log2(OBSIZE)
LBSIZE = int(log2(OBSIZE))
else:
LBSIZE = log2(IBSIZE)
LBSIZE = int(log2(IBSIZE))
 
IBS = (1 << int(log2(IBSIZE))) - 1
LIBSIZE = int(log2(IBSIZE))
IBS = (1 << LIBSIZE) - 1
 
d_state = enum('IDLE', 'HEADER', 'BL', 'READBL', 'REPEAT', 'DISTTREE', 'INIT3',
'HF1', 'HF1INIT', 'HF2', 'HF3', 'HF4', 'HF4_2', 'HF4_3',
69,6 → 77,8
obyte = Signal(intbv()[8:])
orbyte = Signal(intbv()[8:])
 
iraddr = Signal(intbv()[LIBSIZE:])
 
isize = Signal(intbv()[LBSIZE:])
state = Signal(d_state.IDLE)
method = Signal(intbv()[3:])
146,10 → 156,30
b2 = Signal(intbv()[8:])
b3 = Signal(intbv()[8:])
b4 = Signal(intbv()[8:])
b5 = Signal(intbv()[8:])
 
b41 = ConcatSignal(b4, b3, b2, b1)
b41._markUsed()
 
b14 = ConcatSignal(b1, b2, b3, b4)
b14._markUsed()
 
if MATCH10:
b6 = Signal(intbv()[8:])
b7 = Signal(intbv()[8:])
b8 = Signal(intbv()[8:])
b9 = Signal(intbv()[8:])
b10 = Signal(intbv()[8:])
b110 = ConcatSignal(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10)
b110._markUsed()
else:
b6 = Signal(bool())
b7 = Signal(bool())
b8 = Signal(bool())
b9 = Signal(bool())
b10 = Signal(bool())
b110 = Signal(bool())
 
nb = Signal(intbv()[3:])
 
filled = Signal(bool())
157,7 → 187,7
ob1 = Signal(intbv()[8:])
copy1 = Signal(intbv()[8:])
copy2 = Signal(intbv()[8:])
flush = Signal(bool(0))
flush = Signal(bool())
 
adler1 = Signal(intbv()[16:])
adler2 = Signal(intbv()[16:])
174,6 → 204,21
orbyte.next = oram[oraddr]
# rleaf.next = leaves[lraddr]
 
@block
def matcher3(o_m, mi):
@always_comb
def logic():
o_m.next = ((concat(cwindow,b1,b2) >> (8 * mi)) & 0xFFFFFF) == (b14 >> 8)
return logic
 
if FAST:
smatch = [Signal(bool()) for _ in range(CWINDOW)]
cwindow = Signal(modbv()[8 * CWINDOW:])
matchers = [matcher3(smatch[mi], mi) for mi in range(CWINDOW)]
else:
cwindow = Signal(bool())
smatch = [Signal(bool())]
 
@always(clk.posedge)
def fill_buf():
if not reset:
183,18 → 228,48
b2.next = 0
b3.next = 0
b4.next = 0
old_di.next = 0
else:
if isize < 4:
pass
elif i_mode == STARTC or i_mode == STARTD:
nb.next = 0
old_di.next = 0
else:
# print("FILL", di, isize)
nb.next = 4
"""
if do_compress:
print("FILL", di, old_di, nb, b1, b2, b3, b4)
"""
if FAST: # and nb == 4:
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:
cwindow.next = (cwindow << shift) | (b110 >> (80 - shift))
 
if old_di == di:
nb.next = 4
# wtick.next = True
old_di.next = di
 
# iraddr.next = di
b1.next = iram[di & IBS]
b2.next = iram[di+1 & IBS]
b3.next = iram[di+2 & IBS]
b4.next = iram[di+3 & IBS]
b5.next = iram[di+4 & IBS]
if MATCH10:
b6.next = iram[di+5 & IBS]
b7.next = iram[di+6 & IBS]
b8.next = iram[di+7 & IBS]
b9.next = iram[di+8 & IBS]
b10.next = iram[di+9 & IBS]
"""
@always(clk.posedge)
def fill_buf():
215,6 → 290,8
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
221,30 → 298,43
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.next = 1")
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:
366,7 → 456,7
 
if state == d_state.IDLE:
 
if i_mode == STARTC:
if COMPRESS and i_mode == STARTC:
 
print("STARTC")
do_compress.next = True
455,7 → 545,9
# print("CSTATIC", cur_i, ob1, do, doo, isize)
 
no_adv = 0
if not filled:
if not COMPRESS:
pass
elif not filled:
no_adv = 1
filled.next = True
elif nb < 4:
537,7 → 629,7
ladler1.next = adler1_next
# print("in: ", bdata, di, isize)
state.next = d_state.SEARCH
cur_search.next = di - 1 # - 3
cur_search.next = di - 1
 
if not no_adv:
cur_cstatic.next = cur_cstatic + 1
544,7 → 636,9
 
elif state == d_state.DISTANCE:
 
if flush:
if not COMPRESS:
pass
elif flush:
do_flush()
else:
# print("DISTANCE", di, do, cur_i, cur_dist)
572,7 → 666,9
 
elif state == d_state.CHECKSUM:
 
if cur_i < di:
if not COMPRESS:
pass
elif cur_i < di:
# print("CHECKSUM", cur_i, di, iram[cur_i])
bdata = iram[cur_i & IBS]
adler1_next = (adler1 + bdata) % 65521
585,7 → 681,9
 
elif state == d_state.SEARCH:
 
if not filled:
if not COMPRESS:
pass
elif not filled:
filled.next = True
elif nb < 4:
pass
593,7 → 691,76
if cur_search >= 0 \
and cur_search >= di - CWINDOW \
and di < isize - 3:
if iram[cur_search & IBS] == b1 and \
 
if FAST:
found = 0
fmatch = 0
for si in range(CWINDOW):
# print("test", di, si, di - si - 1)
if smatch[si]:
print("fmatch", si)
fmatch = si
found = 1
break
if not found or di - fmatch - 1 < 0:
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
 
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 \
iram[cur_search+1 & IBS] == b2 and \
iram[cur_search+2 & IBS] == b3:
# Length is 3 code
608,8 → 775,7
iram[cur_search+4 & IBS] == iram[di + 4 & IBS]:
lencode = 259
match = 5
"""
if di < isize - 6 and \
if MATCH10 and di < isize - 6 and \
iram[cur_search+5 & IBS] == iram[di + 5 & IBS]:
lencode = 260
match = 6
629,7 → 795,7
iram[cur_search+9 & IBS] == iram[di + 9 & IBS]:
lencode = 264
match = 10
"""
 
print("found:", cur_search, di, isize, match)
outlen = codeLength[lencode]
outbits = code_bits[lencode]
650,6 → 816,7
else:
cur_search.next = cur_search - 1
else:
# print("NO MATCH")
bdata = iram[di]
# adv(8)
di.next = di + 1
1074,7 → 1241,7
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
elif di > isize: # - 3: # checksum is 4 bytes
state.next = d_state.IDLE
o_done.next = True
print("NO EOF ", di)
1184,7 → 1351,10
print("unknown state?!")
state.next = d_state.IDLE
 
return io_logic, logic, fill_buf, oramwrite, oramread
if FAST:
return io_logic, logic, fill_buf, oramwrite, oramread, matchers
else:
return io_logic, logic, fill_buf, oramwrite, oramread
 
 
if __name__ == "__main__":
/hdl-deflate/trunk/deflate.v
1,6 → 1,6
// File: deflate.v
// Generated by MyHDL 0.10
// Date: Thu Dec 20 18:23:02 2018
// Date: Sun Dec 23 19:31:53 2018
 
 
`timescale 1ns/10ps
43,6 → 43,7
reg [9:0] reverse;
reg [7:0] orbyte;
reg [12:0] oraddr;
reg [12:0] old_di;
reg [12:0] offset;
reg [7:0] obyte;
reg [7:0] ob1;
81,17 → 82,27
reg signed [7:0] cur_dist;
reg [12:0] cur_cstatic;
reg [9:0] cur_HF1;
reg [7:0] copy2;
reg [7:0] copy1;
reg [14:0] code;
reg [3:0] bits;
reg [8:0] b_numCodeLength;
reg [7:0] b9;
reg [7:0] b8;
reg [7:0] b7;
reg [7:0] b6;
reg [7:0] b5;
wire [31:0] b41;
reg [7:0] b4;
reg [7:0] b3;
reg [7:0] b2;
wire [31:0] b14;
wire [79:0] b110;
reg [7:0] b10;
reg [7:0] b1;
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 [18:0] leaves [0:512-1];
101,17 → 112,32
reg [8:0] code_bits [0:288-1];
reg [3:0] codeLength [0:290-1];
reg [8:0] bitLengthCount [0:16-1];
wire smatch [0:32-1];
 
assign b41[32-1:24] = b4;
assign b41[24-1:16] = b3;
assign b41[16-1:8] = b2;
assign b41[8-1:0] = b1;
assign b14[32-1:24] = b1;
assign b14[24-1:16] = b2;
assign b14[16-1:8] = b3;
assign b14[8-1:0] = b4;
assign b110[80-1:72] = b1;
assign b110[72-1:64] = b2;
assign b110[64-1:56] = b3;
assign b110[56-1:48] = b4;
assign b110[48-1:40] = b5;
assign b110[40-1:32] = b6;
assign b110[32-1:24] = b7;
assign b110[24-1:16] = b8;
assign b110[16-1:8] = b9;
assign b110[8-1:0] = b10;
 
task MYHDL3_adv;
input width;
integer width;
integer nshift;
begin: MYHDL77_RETURN
begin: MYHDL113_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
125,7 → 151,7
function integer MYHDL4_get4;
input boffset;
input width;
begin: MYHDL78_RETURN
begin: MYHDL114_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
132,7 → 158,7
$finish;
end
MYHDL4_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL78_RETURN;
disable MYHDL114_RETURN;
end
endfunction
 
140,7 → 166,7
input boffset;
input width;
integer width;
begin: MYHDL79_RETURN
begin: MYHDL115_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
147,7 → 173,7
$finish;
end
MYHDL5_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL79_RETURN;
disable MYHDL115_RETURN;
end
endfunction
 
155,7 → 181,7
input width;
integer width;
integer nshift;
begin: MYHDL80_RETURN
begin: MYHDL116_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
170,7 → 196,7
input width;
integer width;
integer nshift;
begin: MYHDL81_RETURN
begin: MYHDL117_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
186,7 → 212,7
integer boffset;
input width;
integer width;
begin: MYHDL82_RETURN
begin: MYHDL118_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
193,7 → 219,7
$finish;
end
MYHDL8_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL82_RETURN;
disable MYHDL118_RETURN;
end
endfunction
 
201,7 → 227,7
input width;
integer width;
integer nshift;
begin: MYHDL83_RETURN
begin: MYHDL119_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
217,7 → 243,7
integer d;
input width;
integer width;
begin: MYHDL84_RETURN
begin: MYHDL120_RETURN
if ((width > 9)) begin
$finish;
end
225,7 → 251,7
$finish;
end
MYHDL10_put = ((ob1 | (d << doo)) & 255);
disable MYHDL84_RETURN;
disable MYHDL120_RETURN;
end
endfunction
 
237,7 → 263,7
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL85_RETURN
begin: MYHDL121_RETURN
if ((width > 9)) begin
$finish;
end
263,7 → 289,7
endtask
 
task MYHDL12_do_flush;
begin: MYHDL86_RETURN
begin: MYHDL122_RETURN
flush <= 1'b0;
ob1 <= 0;
o_oprogress <= (do + 1);
274,7 → 300,7
function integer MYHDL13_put;
input [9-1:0] d;
input [4-1:0] width;
begin: MYHDL87_RETURN
begin: MYHDL123_RETURN
if ((width > 9)) begin
$finish;
end
282,7 → 308,7
$finish;
end
MYHDL13_put = ((ob1 | (d << doo)) & 255);
disable MYHDL87_RETURN;
disable MYHDL123_RETURN;
end
endfunction
 
292,7 → 318,7
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL88_RETURN
begin: MYHDL124_RETURN
if ((width > 9)) begin
$finish;
end
318,7 → 344,7
endtask
 
task MYHDL15_do_flush;
begin: MYHDL89_RETURN
begin: MYHDL125_RETURN
flush <= 1'b0;
ob1 <= 0;
o_oprogress <= (do + 1);
331,7 → 357,7
input nb;
integer nb;
integer r;
begin: MYHDL90_RETURN
begin: MYHDL126_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
340,7 → 366,7
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 MYHDL90_RETURN;
disable MYHDL126_RETURN;
end
endfunction
 
349,7 → 375,7
integer d;
input width;
integer width;
begin: MYHDL91_RETURN
begin: MYHDL127_RETURN
if ((width > 9)) begin
$finish;
end
357,7 → 383,7
$finish;
end
MYHDL17_put = (($signed({1'b0, ob1}) | (d << $signed({1'b0, doo}))) & 255);
disable MYHDL91_RETURN;
disable MYHDL127_RETURN;
end
endfunction
 
369,7 → 395,7
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL92_RETURN
begin: MYHDL128_RETURN
if ((width > 9)) begin
$finish;
end
394,10 → 420,10
end
endtask
 
function integer MYHDL19_put;
function integer MYHDL21_put;
input [9-1:0] d;
input [4-1:0] width;
begin: MYHDL93_RETURN
begin: MYHDL129_RETURN
if ((width > 9)) begin
$finish;
end
404,18 → 430,18
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
$finish;
end
MYHDL19_put = ((ob1 | (d << doo)) & 255);
disable MYHDL93_RETURN;
MYHDL21_put = ((ob1 | (d << doo)) & 255);
disable MYHDL129_RETURN;
end
endfunction
 
task MYHDL20_put_adv;
task MYHDL22_put_adv;
input [9-1:0] d;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL94_RETURN
begin: MYHDL130_RETURN
if ((width > 9)) begin
$finish;
end
440,10 → 466,10
end
endtask
 
function integer MYHDL21_put;
function integer MYHDL23_put;
input [9-1:0] d;
input [4-1:0] width;
begin: MYHDL95_RETURN
begin: MYHDL131_RETURN
if ((width > 9)) begin
$finish;
end
450,18 → 476,18
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
$finish;
end
MYHDL21_put = ((ob1 | (d << doo)) & 255);
disable MYHDL95_RETURN;
MYHDL23_put = ((ob1 | (d << doo)) & 255);
disable MYHDL131_RETURN;
end
endfunction
 
task MYHDL22_put_adv;
task MYHDL24_put_adv;
input [9-1:0] d;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL96_RETURN
begin: MYHDL132_RETURN
if ((width > 9)) begin
$finish;
end
486,105 → 512,151
end
endtask
 
function integer MYHDL31_get4;
function integer MYHDL25_put;
input [9-1:0] d;
input [4-1:0] width;
begin: MYHDL133_RETURN
if ((width > 9)) begin
$finish;
end
if (($signed({1'b0, d}) > ((1 << width) - 1))) begin
$finish;
end
MYHDL25_put = ((ob1 | (d << doo)) & 255);
disable MYHDL133_RETURN;
end
endfunction
 
task MYHDL26_put_adv;
input [9-1:0] d;
input [4-1:0] width;
reg pshift;
integer carry;
integer doo_next;
begin: MYHDL134_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 MYHDL35_get4;
input boffset;
input width;
integer width;
begin: MYHDL97_RETURN
begin: MYHDL135_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL31_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL97_RETURN;
MYHDL35_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL135_RETURN;
end
endfunction
 
function integer MYHDL32_get4;
function integer MYHDL36_get4;
input boffset;
input width;
integer width;
begin: MYHDL98_RETURN
begin: MYHDL136_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL32_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL98_RETURN;
MYHDL36_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL136_RETURN;
end
endfunction
 
function integer MYHDL33_get4;
function integer MYHDL37_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL99_RETURN
begin: MYHDL137_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL33_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL99_RETURN;
MYHDL37_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL137_RETURN;
end
endfunction
 
function integer MYHDL34_get4;
function integer MYHDL38_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL100_RETURN
begin: MYHDL138_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL34_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL100_RETURN;
MYHDL38_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL138_RETURN;
end
endfunction
 
function integer MYHDL35_get4;
function integer MYHDL39_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL101_RETURN
begin: MYHDL139_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL35_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL101_RETURN;
MYHDL39_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL139_RETURN;
end
endfunction
 
function integer MYHDL36_get4;
function integer MYHDL40_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL102_RETURN
begin: MYHDL140_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL36_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL102_RETURN;
MYHDL40_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL140_RETURN;
end
endfunction
 
task MYHDL37_adv;
task MYHDL41_adv;
input width;
integer width;
integer nshift;
begin: MYHDL103_RETURN
begin: MYHDL141_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
595,26 → 667,26
end
endtask
 
function integer MYHDL38_get4;
function integer MYHDL42_get4;
input boffset;
input width;
integer width;
begin: MYHDL104_RETURN
begin: MYHDL142_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL38_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL104_RETURN;
MYHDL42_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL142_RETURN;
end
endfunction
 
task MYHDL39_adv;
task MYHDL43_adv;
input width;
integer width;
integer nshift;
begin: MYHDL105_RETURN
begin: MYHDL143_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
625,56 → 697,56
end
endtask
 
function integer MYHDL40_get4;
function integer MYHDL44_get4;
input boffset;
input width;
integer width;
begin: MYHDL106_RETURN
begin: MYHDL144_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL40_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL106_RETURN;
MYHDL44_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL144_RETURN;
end
endfunction
 
function integer MYHDL41_get4;
function integer MYHDL45_get4;
input boffset;
input width;
integer width;
begin: MYHDL107_RETURN
begin: MYHDL145_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL41_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL107_RETURN;
MYHDL45_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL145_RETURN;
end
endfunction
 
function integer MYHDL42_get4;
function integer MYHDL46_get4;
input boffset;
input width;
integer width;
begin: MYHDL108_RETURN
begin: MYHDL146_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL42_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL108_RETURN;
MYHDL46_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL146_RETURN;
end
endfunction
 
task MYHDL43_adv;
task MYHDL47_adv;
input width;
integer width;
integer nshift;
begin: MYHDL109_RETURN
begin: MYHDL147_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
685,11 → 757,11
end
endtask
 
function integer MYHDL50_rev_bits;
function integer MYHDL54_rev_bits;
input [10-1:0] b;
input [4-1:0] nb;
integer r;
begin: MYHDL110_RETURN
begin: MYHDL148_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
697,15 → 769,15
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}));
MYHDL50_rev_bits = r;
disable MYHDL110_RETURN;
MYHDL54_rev_bits = r;
disable MYHDL148_RETURN;
end
endfunction
 
function integer MYHDL51_makeLeaf;
function integer MYHDL55_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL111_RETURN
begin: MYHDL149_RETURN
if ((lcode >= (1 << 10))) begin
$finish;
end
712,15 → 784,15
if ((lbits >= (1 << 9))) begin
$finish;
end
MYHDL51_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL111_RETURN;
MYHDL55_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL149_RETURN;
end
endfunction
 
function integer MYHDL52_makeLeaf;
function integer MYHDL56_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL112_RETURN
begin: MYHDL150_RETURN
if ((lcode >= (1 << 10))) begin
$finish;
end
727,15 → 799,15
if ((lbits >= (1 << 9))) begin
$finish;
end
MYHDL52_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL112_RETURN;
MYHDL56_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL150_RETURN;
end
endfunction
 
function integer MYHDL53_makeLeaf;
function integer MYHDL57_makeLeaf;
input [9-1:0] lcode;
input [4-1:0] lbits;
begin: MYHDL113_RETURN
begin: MYHDL151_RETURN
if ((lcode >= (1 << 10))) begin
$finish;
end
742,46 → 814,46
if ((lbits >= (1 << 9))) begin
$finish;
end
MYHDL53_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL113_RETURN;
MYHDL57_makeLeaf = ((lcode << 9) | lbits);
disable MYHDL151_RETURN;
end
endfunction
 
function integer MYHDL54_get4;
function integer MYHDL58_get4;
input boffset;
input [5-1:0] width;
begin: MYHDL114_RETURN
begin: MYHDL152_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL54_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL114_RETURN;
MYHDL58_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL152_RETURN;
end
endfunction
 
function integer MYHDL55_get_bits;
function integer MYHDL59_get_bits;
input [19-1:0] aleaf;
begin: MYHDL115_RETURN
MYHDL55_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL115_RETURN;
begin: MYHDL153_RETURN
MYHDL59_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL153_RETURN;
end
endfunction
 
function integer MYHDL56_get_bits;
function integer MYHDL60_get_bits;
input [19-1:0] aleaf;
begin: MYHDL116_RETURN
MYHDL56_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL116_RETURN;
begin: MYHDL154_RETURN
MYHDL60_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL154_RETURN;
end
endfunction
 
task MYHDL57_adv;
task MYHDL61_adv;
input width;
integer width;
integer nshift;
begin: MYHDL117_RETURN
begin: MYHDL155_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
792,105 → 864,105
end
endtask
 
function integer MYHDL58_get_code;
function integer MYHDL62_get_code;
input [19-1:0] aleaf;
begin: MYHDL118_RETURN
MYHDL58_get_code = (aleaf >>> 9);
disable MYHDL118_RETURN;
begin: MYHDL156_RETURN
MYHDL62_get_code = (aleaf >>> 9);
disable MYHDL156_RETURN;
end
endfunction
 
function integer MYHDL59_get_code;
function integer MYHDL63_get_code;
input [19-1:0] aleaf;
begin: MYHDL119_RETURN
MYHDL59_get_code = (aleaf >>> 9);
disable MYHDL119_RETURN;
begin: MYHDL157_RETURN
MYHDL63_get_code = (aleaf >>> 9);
disable MYHDL157_RETURN;
end
endfunction
 
function integer MYHDL60_get4;
function integer MYHDL64_get4;
input boffset;
integer boffset;
input [5-1:0] width;
begin: MYHDL120_RETURN
begin: MYHDL158_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL60_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL120_RETURN;
MYHDL64_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL158_RETURN;
end
endfunction
 
function integer MYHDL61_get_bits;
function integer MYHDL65_get_bits;
input [19-1:0] aleaf;
begin: MYHDL121_RETURN
MYHDL61_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL121_RETURN;
begin: MYHDL159_RETURN
MYHDL65_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL159_RETURN;
end
endfunction
 
function integer MYHDL62_get4;
function integer MYHDL66_get4;
input boffset;
input width;
integer width;
begin: MYHDL122_RETURN
begin: MYHDL160_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL62_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL122_RETURN;
MYHDL66_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL160_RETURN;
end
endfunction
 
function integer MYHDL63_get_code;
function integer MYHDL67_get_code;
input [19-1:0] aleaf;
begin: MYHDL123_RETURN
MYHDL63_get_code = (aleaf >>> 9);
disable MYHDL123_RETURN;
begin: MYHDL161_RETURN
MYHDL67_get_code = (aleaf >>> 9);
disable MYHDL161_RETURN;
end
endfunction
 
function integer MYHDL64_get_bits;
function integer MYHDL68_get_bits;
input [19-1:0] aleaf;
begin: MYHDL124_RETURN
MYHDL64_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL124_RETURN;
begin: MYHDL162_RETURN
MYHDL68_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL162_RETURN;
end
endfunction
 
function integer MYHDL65_get4;
function integer MYHDL69_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL125_RETURN
begin: MYHDL163_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL65_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL125_RETURN;
MYHDL69_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL163_RETURN;
end
endfunction
 
function integer MYHDL66_get_bits;
function integer MYHDL70_get_bits;
input [19-1:0] aleaf;
begin: MYHDL126_RETURN
MYHDL66_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL126_RETURN;
begin: MYHDL164_RETURN
MYHDL70_get_bits = ($signed({1'b0, aleaf}) & ((1 << 9) - 1));
disable MYHDL164_RETURN;
end
endfunction
 
task MYHDL67_adv;
task MYHDL71_adv;
input width;
integer width;
integer nshift;
begin: MYHDL127_RETURN
begin: MYHDL165_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
901,44 → 973,44
end
endtask
 
function integer MYHDL68_get4;
function integer MYHDL72_get4;
input boffset;
input width;
integer width;
begin: MYHDL128_RETURN
begin: MYHDL166_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL68_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL128_RETURN;
MYHDL72_get4 = ((b41 >>> (dio + boffset)) & ((1 << width) - 1));
disable MYHDL166_RETURN;
end
endfunction
 
function integer MYHDL69_get4;
function integer MYHDL73_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL129_RETURN
begin: MYHDL167_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 MYHDL129_RETURN;
MYHDL73_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL167_RETURN;
end
endfunction
 
function integer MYHDL70_rev_bits;
function integer MYHDL74_rev_bits;
input b;
integer b;
input nb;
integer nb;
integer r;
begin: MYHDL130_RETURN
begin: MYHDL168_RETURN
if ((b >= (1 << nb))) begin
$finish;
$write("too few bits");
946,32 → 1018,32
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}));
MYHDL70_rev_bits = r;
disable MYHDL130_RETURN;
MYHDL74_rev_bits = r;
disable MYHDL168_RETURN;
end
endfunction
 
function integer MYHDL71_get4;
function integer MYHDL75_get4;
input boffset;
integer boffset;
input width;
integer width;
begin: MYHDL131_RETURN
begin: MYHDL169_RETURN
if ((nb != 4)) begin
$write("----NB----");
$write("\n");
$finish;
end
MYHDL71_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL131_RETURN;
MYHDL75_get4 = ($signed($signed({1'b0, b41}) >>> ($signed({1'b0, dio}) + boffset)) & ((1 << width) - 1));
disable MYHDL169_RETURN;
end
endfunction
 
task MYHDL72_adv;
task MYHDL76_adv;
input width;
integer width;
integer nshift;
begin: MYHDL132_RETURN
begin: MYHDL170_RETURN
nshift = $signed(($signed({1'b0, dio}) + width) >>> 3);
o_iprogress <= di;
dio <= (($signed({1'b0, dio}) + width) & 7);
982,11 → 1054,11
end
endtask
 
task MYHDL73_adv;
task MYHDL77_adv;
input width;
integer width;
integer nshift;
begin: MYHDL133_RETURN
begin: MYHDL171_RETURN
nshift = ((dio + width) >>> 3);
o_iprogress <= di;
dio <= ((dio + width) & 7);
1028,9 → 1100,12
integer extra_dist;
integer extra_bits;
integer outcode;
reg found;
integer fmatch;
integer si;
integer distance;
integer lencode;
integer match;
integer distance;
integer stat_i;
integer clo_i;
integer n_adv;
1063,39 → 1138,37
else begin
case (state)
5'b00000: begin
case (i_mode)
'h4: begin
$write("STARTC");
$write("\n");
do_compress <= 1'b1;
method <= 1;
o_done <= 1'b0;
o_iprogress <= 0;
o_oprogress <= 0;
di <= 0;
dio <= 0;
do <= 0;
doo <= 0;
filled <= 1'b1;
cur_static <= 0;
state <= 5'b01110;
end
'h5: begin
do_compress <= 1'b0;
o_done <= 1'b0;
o_iprogress <= 0;
o_oprogress <= 0;
di <= 0;
dio <= 0;
do <= 0;
doo <= 0;
filled <= 1'b1;
state <= 5'b00001;
end
default: begin
// pass
end
endcase
if ((1'b1 && (i_mode == 4))) begin
$write("STARTC");
$write("\n");
do_compress <= 1'b1;
method <= 1;
o_done <= 1'b0;
o_iprogress <= 0;
o_oprogress <= 0;
di <= 0;
dio <= 0;
do <= 0;
doo <= 0;
filled <= 1'b1;
cur_static <= 0;
state <= 5'b01110;
end
else if ((i_mode == 5)) begin
do_compress <= 1'b0;
o_done <= 1'b0;
o_iprogress <= 0;
o_oprogress <= 0;
di <= 0;
dio <= 0;
do <= 0;
doo <= 0;
filled <= 1'b1;
state <= 5'b00001;
end
else begin
// pass
end
end
5'b00001: begin
if ((!filled)) begin
1180,7 → 1253,10
end
5'b10110: begin
no_adv = 0;
if ((!filled)) begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
no_adv = 1;
filled <= 1'b1;
end
1308,7 → 1384,10
end
end
5'b11000: begin
if (flush) begin
if ((!1'b1)) begin
// pass
end
else if (flush) begin
MYHDL15_do_flush;
end
else begin
1411,7 → 1490,10
end
end
5'b11001: begin
if ((cur_i < di)) begin
if ((!1'b1)) begin
// pass
end
else if ((cur_i < di)) begin
bdata = iram[(cur_i & 127)];
adler1_next = ((adler1 + bdata) % 65521);
adler1 <= adler1_next;
1424,7 → 1506,10
end
end
5'b10111: begin
if ((!filled)) begin
if ((!1'b1)) begin
// pass
end
else if ((!filled)) begin
filled <= 1'b1;
end
else if ((nb < 4)) begin
1432,7 → 1517,83
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 (((iram[(cur_search & 127)] == b1) && (iram[((cur_search + 1) & 127)] == b2) && (iram[((cur_search + 2) & 127)] == b3))) begin
//
if (1'b1) begin
found = 0;
fmatch = 0;
begin: MYHDL19_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;
end
end
end
if (((!found) || ((($signed({1'b0, di}) - fmatch) - 1) < 0))) begin
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;
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
lencode = 257;
match = 3;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 4)) && (iram[((cur_search + 3) & 127)] == b4))) begin
1441,23 → 1602,28
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 5)) && (iram[((cur_search + 4) & 127)] == iram[((di + 4) & 127)]))) 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
lencode = 260;
match = 6;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 7)) && (iram[((cur_search + 6) & 127)] == iram[((di + 6) & 127)]))) 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
lencode = 262;
match = 8;
if ((($signed({1'b0, di}) < ($signed({1'b0, isize}) - 9)) && (iram[((cur_search + 8) & 127)] == iram[((di + 8) & 127)]))) 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
lencode = 264;
match = 10;
end
end
end
end
end
end
end
// if di < isize - 6 and iram[cur_search+5 & IBS] == iram[di + 5 & IBS]:
// lencode = 260
// match = 6
// if di < isize - 7 and iram[cur_search+6 & IBS] == iram[di + 6 & IBS]:
// lencode = 261
// match = 7
// if di < isize - 8 and iram[cur_search+7 & IBS] == iram[di + 7 & IBS]:
// lencode = 262
// match = 8
// if di < isize - 9 and iram[cur_search+8 & IBS] == iram[di + 8 & IBS]:
// lencode = 263
// match = 9
// if di < isize - 10 and iram[cur_search+9 & IBS] == iram[di + 9 & IBS]:
// lencode = 264
// match = 10
$write("found:");
$write(" ");
$write("%h", cur_search);
1471,8 → 1637,8
outlen = codeLength[lencode];
outbits = code_bits[lencode];
oaddr <= do;
obyte <= MYHDL19_put(outbits, outlen);
MYHDL20_put_adv(outbits, outlen);
obyte <= MYHDL23_put(outbits, outlen);
MYHDL24_put_adv(outbits, outlen);
distance = ($signed({1'b0, di}) - cur_search);
cur_dist <= distance;
cur_i <= 0;
1491,8 → 1657,8
outlen = codeLength[bdata];
outbits = code_bits[bdata];
oaddr <= do;
obyte <= MYHDL21_put(outbits, outlen);
MYHDL22_put_adv(outbits, outlen);
obyte <= MYHDL25_put(outbits, outlen);
MYHDL26_put_adv(outbits, outlen);
state <= 5'b10110;
end
end
1536,23 → 1702,23
// pass
end
else if ((numLiterals == 0)) begin
numLiterals <= (257 + MYHDL31_get4(0, 5));
numLiterals <= (257 + MYHDL35_get4(0, 5));
$write("NL:");
$write(" ");
$write("%0d", (257 + MYHDL32_get4(0, 5)));
$write("%0d", (257 + MYHDL36_get4(0, 5)));
$write("\n");
numDistance <= (1 + MYHDL33_get4(5, 5));
numDistance <= (1 + MYHDL37_get4(5, 5));
$write("ND:");
$write(" ");
$write("%0d", (1 + MYHDL34_get4(5, 5)));
$write("%0d", (1 + MYHDL38_get4(5, 5)));
$write("\n");
b_numCodeLength <= (4 + MYHDL35_get4(10, 4));
b_numCodeLength <= (4 + MYHDL39_get4(10, 4));
$write("NCL:");
$write(" ");
$write("%0d", (4 + MYHDL36_get4(10, 4)));
$write("%0d", (4 + MYHDL40_get4(10, 4)));
$write("\n");
numCodeLength <= 0;
MYHDL37_adv(14);
MYHDL41_adv(14);
end
else begin
if ((numCodeLength < 19)) begin
1578,8 → 1744,8
default: clo_i = 15;
endcase
if ((numCodeLength < b_numCodeLength)) begin
codeLength[clo_i] <= MYHDL38_get4(0, 3);
MYHDL39_adv(3);
codeLength[clo_i] <= MYHDL42_get4(0, 3);
MYHDL43_adv(3);
end
else begin
codeLength[clo_i] <= 0;
1607,16 → 1773,16
lastToken <= code;
end
else if ((code == 16)) begin
howOften <= (3 + MYHDL40_get4(0, 2));
howOften <= (3 + MYHDL44_get4(0, 2));
n_adv = 2;
end
else if ((code == 17)) begin
howOften <= (3 + MYHDL41_get4(0, 3));
howOften <= (3 + MYHDL45_get4(0, 3));
lastToken <= 0;
n_adv = 3;
end
else if ((code == 18)) begin
howOften <= (11 + MYHDL42_get4(0, 7));
howOften <= (11 + MYHDL46_get4(0, 7));
lastToken <= 0;
n_adv = 7;
end
1624,7 → 1790,7
$finish;
end
if ((n_adv != 0)) begin
MYHDL43_adv(n_adv);
MYHDL47_adv(n_adv);
end
state <= 5'b00100;
end
1802,8 → 1968,8
if ((bits > 15)) begin
$finish;
end
reverse <= MYHDL50_rev_bits(canonical, bits);
leaf <= MYHDL51_makeLeaf(spread_i, bits);
reverse <= MYHDL54_rev_bits(canonical, bits);
leaf <= MYHDL55_makeLeaf(spread_i, bits);
state <= 5'b01101;
end
5'b01101: begin
1883,11 → 2049,11
end
5'b10010: begin
if ((method == 4)) begin
d_leaves[spread] <= MYHDL52_makeLeaf(spread_i, codeLength[spread_i]);
d_leaves[spread] <= MYHDL56_makeLeaf(spread_i, codeLength[spread_i]);
end
else begin
lwaddr <= spread;
wleaf <= MYHDL53_makeLeaf(spread_i, codeLength[spread_i]);
wleaf <= MYHDL57_makeLeaf(spread_i, codeLength[spread_i]);
end
aim = instantMask;
if ((method == 4)) begin
1909,23 → 2075,23
// pass
end
else if ((cur_next == 0)) begin
cto = MYHDL54_get4(0, maxBits);
cto = MYHDL58_get4(0, maxBits);
cur_next <= 1;
mask = ((1 << instantMaxBit) - 1);
leaf <= leaves[(cto & mask)];
end
else begin
if ((MYHDL55_get_bits(leaf) < 1)) begin
if ((MYHDL59_get_bits(leaf) < 1)) begin
$write("< 1 bits: ");
$write("\n");
$finish;
end
MYHDL57_adv(MYHDL56_get_bits(leaf));
if ((MYHDL58_get_code(leaf) == 0)) begin
MYHDL61_adv(MYHDL60_get_bits(leaf));
if ((MYHDL62_get_code(leaf) == 0)) begin
$write("leaf 0");
$write("\n");
end
code <= MYHDL59_get_code(leaf);
code <= MYHDL63_get_code(leaf);
if ((method == 2)) begin
state <= 5'b00011;
end
1974,7 → 2140,7
27: extraLength = 5;
default: extraLength = 0;
endcase
cto = MYHDL60_get4(extraLength, d_maxBits);
cto = MYHDL64_get4(extraLength, d_maxBits);
mask = ((1 << d_instantMaxBit) - 1);
leaf <= d_leaves[(cto & mask)];
state <= 5'b10000;
1981,7 → 2147,7
end
end
5'b10000: begin
if ((MYHDL61_get_bits(leaf) == 0)) begin
if ((MYHDL65_get_bits(leaf) == 0)) begin
$finish;
end
token = (code - 257);
2047,8 → 2213,8
27: extraLength = 5;
default: extraLength = 0;
endcase
tlength = tlength + MYHDL62_get4(0, extraLength);
distanceCode = MYHDL63_get_code(leaf);
tlength = tlength + MYHDL66_get4(0, extraLength);
distanceCode = MYHDL67_get_code(leaf);
case (distanceCode)
0: distance = 1;
1: distance = 2;
2098,13 → 2264,13
13: moreBits = 12;
default: moreBits = 13;
endcase
mored = MYHDL65_get4((extraLength + MYHDL64_get_bits(leaf)), moreBits);
mored = MYHDL69_get4((extraLength + MYHDL68_get_bits(leaf)), moreBits);
distance = distance + mored;
MYHDL67_adv(((moreBits + extraLength) + MYHDL66_get_bits(leaf)));
MYHDL71_adv(((moreBits + extraLength) + MYHDL70_get_bits(leaf)));
offset <= ($signed({1'b0, do}) - distance);
length <= tlength;
cur_i <= 0;
oraddr <= offset;
oraddr <= ($signed({1'b0, do}) - distance);
state <= 5'b10101;
end
default: begin
2115,7 → 2281,7
else if ((nb < 4)) begin
// pass
end
else if (($signed({1'b0, di}) > ($signed({1'b0, isize}) - 3))) begin
else if ((di > isize)) begin
state <= 5'b00000;
o_done <= 1'b1;
$write("NO EOF ");
2217,9 → 2383,9
27: extraLength = 5;
default: extraLength = 0;
endcase
tlength = tlength + MYHDL68_get4(0, extraLength);
t = MYHDL69_get4(extraLength, 5);
distanceCode = MYHDL70_rev_bits(t, 5);
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;
2269,12 → 2435,12
13: moreBits = 12;
default: moreBits = 13;
endcase
distance = distance + MYHDL71_get4((extraLength + 5), moreBits);
MYHDL72_adv(((extraLength + 5) + moreBits));
distance = distance + MYHDL75_get4((extraLength + 5), moreBits);
MYHDL76_adv(((extraLength + 5) + moreBits));
offset <= ($signed({1'b0, do}) - distance);
length <= tlength;
cur_i <= 0;
oraddr <= offset;
oraddr <= ($signed({1'b0, do}) - distance);
state <= 5'b10101;
end
else begin
2296,7 → 2462,7
if ((cur_i < length)) begin
oaddr <= do;
obyte <= b3;
MYHDL73_adv(8);
MYHDL77_adv(8);
cur_i <= (cur_i + 1);
do <= (do + 1);
o_oprogress <= (do + 1);
2310,17 → 2476,35
state <= 5'b00000;
end
end
else if ((cur_i < (length + 1))) begin
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
obyte <= orbyte;
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);
2329,15 → 2513,6
cur_i <= (cur_i + 1);
end
else begin
oaddr <= do;
if (((offset + cur_i) == (do + 1))) begin
obyte <= copy1;
end
else begin
obyte <= orbyte;
end
do <= (do + 1);
o_oprogress <= (do + 1);
cur_next <= 0;
state <= 5'b10011;
end
2358,6 → 2533,7
 
 
always @(posedge clk) begin: DEFLATE_FILL_BUF
integer shift;
if ((!reset)) begin
$write("FILL RESET");
$write("\n");
2366,6 → 2542,7
b2 <= 0;
b3 <= 0;
b4 <= 0;
old_di <= 0;
end
else begin
if ((isize < 4)) begin
2373,13 → 2550,41
end
else if (((i_mode == 4) || (i_mode == 5))) begin
nb <= 0;
old_di <= 0;
end
else begin
nb <= 4;
// if do_compress:
// print("FILL", di, old_di, nb, b1, b2, b3, b4)
if (1'b1) begin
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)));
end
else if ((shift == 40)) begin
cwindow <= ((($signed({1'b0, cwindow}) << shift) | (b14 << 8)) | b5);
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)];
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)];
end
end
end
end
2395,4 → 2600,132
orbyte <= oram[oraddr];
end
 
 
 
assign smatch[0] = ((({cwindow, b1, b2} >>> (8 * 0)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[1] = ((({cwindow, b1, b2} >>> (8 * 1)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[2] = ((({cwindow, b1, b2} >>> (8 * 2)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[3] = ((({cwindow, b1, b2} >>> (8 * 3)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[4] = ((({cwindow, b1, b2} >>> (8 * 4)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[5] = ((({cwindow, b1, b2} >>> (8 * 5)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[6] = ((({cwindow, b1, b2} >>> (8 * 6)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[7] = ((({cwindow, b1, b2} >>> (8 * 7)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[8] = ((({cwindow, b1, b2} >>> (8 * 8)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[9] = ((({cwindow, b1, b2} >>> (8 * 9)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[10] = ((({cwindow, b1, b2} >>> (8 * 10)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[11] = ((({cwindow, b1, b2} >>> (8 * 11)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[12] = ((({cwindow, b1, b2} >>> (8 * 12)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[13] = ((({cwindow, b1, b2} >>> (8 * 13)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[14] = ((({cwindow, b1, b2} >>> (8 * 14)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[15] = ((({cwindow, b1, b2} >>> (8 * 15)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[16] = ((({cwindow, b1, b2} >>> (8 * 16)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[17] = ((({cwindow, b1, b2} >>> (8 * 17)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[18] = ((({cwindow, b1, b2} >>> (8 * 18)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[19] = ((({cwindow, b1, b2} >>> (8 * 19)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[20] = ((({cwindow, b1, b2} >>> (8 * 20)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[21] = ((({cwindow, b1, b2} >>> (8 * 21)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[22] = ((({cwindow, b1, b2} >>> (8 * 22)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[23] = ((({cwindow, b1, b2} >>> (8 * 23)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[24] = ((({cwindow, b1, b2} >>> (8 * 24)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[25] = ((({cwindow, b1, b2} >>> (8 * 25)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[26] = ((({cwindow, b1, b2} >>> (8 * 26)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[27] = ((({cwindow, b1, b2} >>> (8 * 27)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[28] = ((({cwindow, b1, b2} >>> (8 * 28)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[29] = ((({cwindow, b1, b2} >>> (8 * 29)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[30] = ((({cwindow, b1, b2} >>> (8 * 30)) & 16777215) == (b14 >>> 8));
 
 
 
assign smatch[31] = ((({cwindow, b1, b2} >>> (8 * 31)) & 16777215) == (b14 >>> 8));
 
endmodule
/hdl-deflate/trunk/test_deflate.py
7,7 → 7,8
Cosimulation, block, instance, StopSimulation, modbv, \
always, always_seq, always_comb, enum, Error
 
from deflate import IDLE, WRITE, READ, STARTC, STARTD, LBSIZE, IBSIZE, CWINDOW
from deflate import IDLE, WRITE, READ, STARTC, STARTD, LBSIZE, IBSIZE, \
CWINDOW, COMPRESS
 
MAXW = 2 * CWINDOW
 
55,7 → 56,8
b_data = str_data.encode('utf-8')
else:
raise Error("unknown test mode")
b_data = b_data[:IBSIZE-4]
# print(str_data)
b_data = b_data[:IBSIZE - 4 - 20]
zl_data = zlib.compress(b_data)
print("From %d to %d bytes" % (len(b_data), len(zl_data)))
print(zl_data)
104,7 → 106,8
i_addr.next = i
i = i + 1
else:
print("Wait for space")
# print("Wait for space")
pass
tick()
yield delay(5)
tick()
446,7 → 449,10
print("DECOMPRESS test OK!, pausing", tbi)
i_mode.next = IDLE
tbi.next = 0
tstate.next = tb_state.PAUSE
if not COMPRESS:
tstate.next = tb_state.CPAUSE
else:
tstate.next = tb_state.PAUSE
# tstate.next = tb_state.HALT
# state.next = tb_state.CPAUSE
resume.next = 1
568,8 → 574,6
led2_r.next = 0
i_mode.next = IDLE
resume.next = 1
if SLOWDOWN <= 4:
raise StopSimulation()
"""
"""
tstate.next = tb_state.CPAUSE
576,6 → 580,8
# tstate.next = tb_state.HALT
 
elif tstate == tb_state.CPAUSE:
if SLOWDOWN <= 4:
raise StopSimulation()
if resume == 0:
print("--------------RESET-------------")
o_led.next = o_led + 1

powered by: WebSVN 2.1.0

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