781 lines
22 KiB
Python
781 lines
22 KiB
Python
from chipchune.furnace.module import FurnaceModule
|
|
from chipchune.furnace.data_types import InsFeatureMacro, InsFeatureC64, InsFeatureAmiga
|
|
from chipchune.furnace.enums import MacroCode, MacroItem, MacroType
|
|
from chipchune.furnace.enums import InstrumentType
|
|
import sys
|
|
|
|
subsong = 0
|
|
note_transpose = 0
|
|
dups = {}
|
|
|
|
print(sys.argv)
|
|
module = FurnaceModule(sys.argv[1])
|
|
chnum = module.get_num_channels()
|
|
|
|
speed_type = len(module.subsongs[subsong].speed_pattern)
|
|
|
|
notes = ["C_","Cs","D_","Ds","E_","F_","Fs","G_","Gs","A_","As","B_"]
|
|
|
|
def comp(pat):
|
|
i = 0
|
|
o = []
|
|
n = 0
|
|
while i < len(pat):
|
|
j = i
|
|
k = 0
|
|
if pat[i] >= 0x40 and pat[i] < 128: i += 1
|
|
elif pat[i] == 0xFB: i += 2
|
|
elif pat[i] == 0xFC: i += 2
|
|
elif pat[i] == 0xE0: i += 2
|
|
elif pat[i] == 0xE1: i += 2
|
|
elif pat[i] == 0xE2: i += 2
|
|
elif pat[i] == 0xE3: i += 2
|
|
elif pat[i] == 0xE4: i += 2
|
|
elif pat[i] == 0xE5: i += 3
|
|
elif pat[i] == 0xE6: i += 2
|
|
elif pat[i] == 0xE7: i += 2
|
|
elif pat[i] == 0xE8: i += 2
|
|
elif pat[i] == 0xE9: i += 3
|
|
elif pat[i] == 0xEA: i += 3
|
|
elif pat[i] == 0xEB: i += 2
|
|
elif pat[i] == 0xEC: i += 2
|
|
elif pat[i] == 0xED: i += 2
|
|
elif pat[i] == 0xEE: i += 2
|
|
elif pat[i] == 0xEF: i += 1
|
|
elif pat[i] == 0xF0: i += 1
|
|
elif pat[i] == 0xF1: i += 2
|
|
elif pat[i] == 0xFF: i += 2
|
|
elif pat[i] == 0xFD:
|
|
i += 1
|
|
n = 2
|
|
elif pat[i] == 0xFE:
|
|
i += 1
|
|
n = 2
|
|
elif pat[i] >= 128:
|
|
i += 1
|
|
n = 2
|
|
else:
|
|
k = 1
|
|
if n == 0:
|
|
o.append(pat[i])
|
|
elif pat[i] > 1:
|
|
o.append(pat[i]-1)
|
|
#print(i,pat[i])
|
|
i += 1
|
|
n = max(n-1,0)
|
|
if k == 0:
|
|
o.extend(pat[j:i])
|
|
#print(pat,"\n",o,"\n")
|
|
return o
|
|
|
|
def conv_pattern(pattern):
|
|
out = [0]
|
|
oldtemp = [0,0]
|
|
r = 0
|
|
bitind = 0
|
|
oldins = -1
|
|
for row in pattern.data:
|
|
has03xx = 0
|
|
for l in row.effects:
|
|
k = list(l)
|
|
if k[0] == 0x03 and k[1] > 0:
|
|
has03xx = 1
|
|
break
|
|
|
|
temp = []
|
|
notnote = 0
|
|
new_byte = 0
|
|
if row.instrument != 65535 and oldins != row.instrument:
|
|
new_byte = 1
|
|
if row.instrument < 0x40:
|
|
temp.append(row.instrument+0x40)
|
|
else:
|
|
temp.append(0xFB)
|
|
temp.append(row.instrument)
|
|
oldins = row.instrument
|
|
if row.volume != 65535:
|
|
new_byte = 1
|
|
temp.append(0xFC)
|
|
temp.append(row.volume)
|
|
|
|
hasEffect = [-1,-1]
|
|
has0Dxx = -1
|
|
for l in row.effects:
|
|
k = list(l)
|
|
if k[1] == 65535:
|
|
k[1] = 0
|
|
|
|
if k[0] == 0xD:
|
|
new_byte = 1
|
|
has0Dxx = k[1]
|
|
continue
|
|
if k[0] == 0x0B:
|
|
new_byte = 1
|
|
temp.extend([0xED, k[1]])
|
|
has0Dxx = 0
|
|
continue
|
|
if (k[0] == 0x09 or k[0] == 0x0F) and (speed_type == 1):
|
|
new_byte = 1
|
|
temp.extend([0xE1, k[1]])
|
|
temp.extend([0xE0, k[1]])
|
|
continue
|
|
if k[0] == 0x0F and (speed_type == 2):
|
|
new_byte = 1
|
|
temp.extend([0xE1, k[1]])
|
|
continue
|
|
if k[0] == 0x09 and (speed_type == 2):
|
|
new_byte = 1
|
|
temp.extend([0xE0, k[1]])
|
|
continue
|
|
if k[0] == 0x00:
|
|
new_byte = 1
|
|
temp.extend([0xE2, k[1]])
|
|
continue
|
|
if k[0] == 0x01:
|
|
new_byte = 1
|
|
temp.extend([0xE3, k[1]])
|
|
continue
|
|
if k[0] == 0x02:
|
|
new_byte = 1
|
|
temp.extend([0xE4, k[1]])
|
|
continue
|
|
if k[0] == 0x03 and k[1] == 0:
|
|
new_byte = 1
|
|
temp.extend([0xE4, 0])
|
|
continue
|
|
if k[0] == 0x03 and k[1] > 0:
|
|
new_byte = 1
|
|
temp.extend([0xE5, k[1], max(min(notes.index(str(row.note))+(row.octave*12)+note_transpose,95),0)])
|
|
continue
|
|
if k[0] == 0x04:
|
|
new_byte = 1
|
|
temp.extend([0xE6, k[1]])
|
|
continue
|
|
if k[0] == 0x1B:
|
|
new_byte = 1
|
|
temp.extend([0xE7, k[1]])
|
|
continue
|
|
if k[0] == 0x1C:
|
|
new_byte = 1
|
|
temp.extend([0xE8, k[1]])
|
|
continue
|
|
if k[0] == 0xE1:
|
|
new_byte = 1
|
|
temp.extend([0xE9, k[1]>>4, k[1]&15])
|
|
continue
|
|
if k[0] == 0xE2:
|
|
new_byte = 1
|
|
temp.extend([0xEA, k[1]>>4, k[1]&15])
|
|
continue
|
|
if k[0] == 0xE5:
|
|
new_byte = 1
|
|
temp.extend([0xEB, k[1]])
|
|
continue
|
|
if k[0] == 0xEC:
|
|
new_byte = 1
|
|
temp.extend([0xEC, k[1]])
|
|
continue
|
|
if (k[0]>>4) == 4:
|
|
new_byte = 1
|
|
temp.extend([0xEE, (k[1]|(k[0]&0xf)<<8)>>3])
|
|
continue
|
|
if k[0] == 0xEA:
|
|
new_byte = 1
|
|
if k[1] == 0:
|
|
temp.extend([0xEF])
|
|
else:
|
|
temp.extend([0xF0])
|
|
continue
|
|
if k[0] == 0x1A:
|
|
new_byte = 1
|
|
if k[1] > 0:
|
|
temp.extend([0xF1, 0x00])
|
|
else:
|
|
temp.extend([0xF1, 0xFF])
|
|
continue
|
|
if str(row.note) == "OFF_REL":
|
|
notnote = 1
|
|
new_byte = 1
|
|
temp.append(0xFD)
|
|
elif str(row.note) == "REL":
|
|
notnote = 1
|
|
new_byte = 1
|
|
temp.append(0xFD)
|
|
elif str(row.note) == "OFF":
|
|
notnote = 1
|
|
new_byte = 1
|
|
temp.append(0xFE)
|
|
elif str(row.note) == "__" or (has03xx == 1):
|
|
if has03xx == 0:
|
|
notnote = 1
|
|
#temp.append(0x80)
|
|
else:
|
|
new_byte = 1
|
|
temp.append(max(min(notes.index(str(row.note))+(row.octave*12)+note_transpose,95),0)+0x80)
|
|
|
|
if new_byte == 1:
|
|
temp.append(0)
|
|
out.extend(temp)
|
|
durpass = False
|
|
if out[-1] >= 63:
|
|
out.append(0)
|
|
if has0Dxx > -1:
|
|
out[-1] += 1
|
|
if out[0] == 0: out = out[1:]
|
|
out.extend([0xFF, has0Dxx])
|
|
return out
|
|
out[-1] += 1
|
|
r += 1
|
|
out.extend([0xFF, 0])
|
|
if out[0] == 0: out = out[1:]
|
|
return out
|
|
|
|
f = open("asm/song.asm","w")
|
|
|
|
relW = []
|
|
relA = []
|
|
relD = []
|
|
relC = []
|
|
|
|
f.write("ticks_init:")
|
|
f.write(".byte ")
|
|
if speed_type == 1:
|
|
f.write(str(module.subsongs[subsong].speed_pattern[0])+", ")
|
|
f.write(str(module.subsongs[subsong].speed_pattern[0])+"\n")
|
|
elif speed_type == 2:
|
|
f.write(str(module.subsongs[subsong].speed_pattern[0])+", ")
|
|
f.write(str(module.subsongs[subsong].speed_pattern[1])+"\n")
|
|
|
|
f.write("insFL:\n")
|
|
f.write(".lobytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"F")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("insFH:\n")
|
|
f.write(".hibytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"F")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write("insAL:\n")
|
|
f.write(".lobytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"A")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("insAH:\n")
|
|
f.write(".hibytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"A")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write("insDL:\n")
|
|
f.write(".lobytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"D")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("insDH:\n")
|
|
f.write(".hibytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"D")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write("insWL:\n")
|
|
f.write(".lobytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"W")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("insWH:\n")
|
|
f.write(".hibytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"W")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write("insCL:\n")
|
|
f.write(".lobytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"C")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("insCH:\n")
|
|
f.write(".hibytes ")
|
|
for i in range(len(module.instruments)):
|
|
f.write("ins"+str(i)+"C")
|
|
if i == len(module.instruments)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
for i in range(len(module.instruments)):
|
|
features = module.instruments[i].features
|
|
a = filter(
|
|
lambda x: (
|
|
type(x) == InsFeatureMacro
|
|
), features
|
|
)
|
|
macros = []
|
|
for j in a:
|
|
macros = j.macros
|
|
hasWaveMacro = 0
|
|
hasCutMacro = 0
|
|
for j in macros:
|
|
kind = j.kind
|
|
if kind == MacroCode.WAVE:
|
|
hasWaveMacro = 1
|
|
continue
|
|
if kind == MacroCode.ALG:
|
|
hasCutMacro = 1
|
|
continue
|
|
|
|
hasAbsFilter = False
|
|
hasAbsDuty = False
|
|
written_ins = False
|
|
|
|
a = filter(
|
|
lambda x: (
|
|
type(x) == InsFeatureMacro
|
|
), features
|
|
)
|
|
macros = []
|
|
for j in a:
|
|
macros = j.macros
|
|
for j in macros:
|
|
kind = j.kind
|
|
if kind == MacroCode.DUTY and j.type == MacroType.LFO:
|
|
hasAbsDuty = True
|
|
|
|
a = filter(
|
|
lambda x: (
|
|
type(x) == InsFeatureC64
|
|
), features
|
|
)
|
|
for j in a:
|
|
wave = j.tri_on
|
|
wave |= j.saw_on<<1
|
|
wave |= j.pulse_on<<2
|
|
wave |= j.noise_on<<3
|
|
wave <<= 4
|
|
wave |= j.ring_mod<<2
|
|
wave |= j.osc_sync<<1
|
|
f.write("ins"+str(i)+"F:\n")
|
|
f.write(".byte ")
|
|
f.write(str(wave)+", ")
|
|
ad = (j.envelope.a<<4)|j.envelope.d
|
|
sr = (j.envelope.s<<4)|j.envelope.r
|
|
f.write(str(ad)+", ")
|
|
f.write(str(sr)+", ")
|
|
f.write(str(j.duty&0xff)+", ")
|
|
f.write(str(j.duty>>8)+", ")
|
|
flags = 0
|
|
if j.duty_is_abs:
|
|
flags |= 1
|
|
if hasWaveMacro:
|
|
flags |= 2
|
|
if j.to_filter:
|
|
flags |= 4
|
|
if j.init_filter:
|
|
flags |= 8
|
|
if j.filter_is_abs:
|
|
flags |= 16
|
|
if hasCutMacro:
|
|
flags |= 32
|
|
if not j.no_test:
|
|
flags |= 64
|
|
f.write(str(flags)+", ")
|
|
fil = 0
|
|
fil = j.lp<<4
|
|
fil |= j.bp<<5
|
|
fil |= j.hp<<6
|
|
fil |= j.ch3_off<<7
|
|
f.write(str(j.res<<4)+", ")
|
|
f.write(str(fil)+", ")
|
|
f.write(str(j.cut&0xff)+", ")
|
|
f.write(str((j.cut>>8)&15)+"\n")
|
|
f.write("\n")
|
|
written_ins = True
|
|
hasAbsDuty |= j.duty_is_abs
|
|
hasAbsFilter = j.filter_is_abs
|
|
if written_ins == False:
|
|
f.write("ins"+str(i)+"F:\n")
|
|
f.write(".byte 32, 8, 0, 255, 7, 0\n")
|
|
a = filter(
|
|
lambda x: (
|
|
type(x) == InsFeatureMacro
|
|
), features
|
|
)
|
|
arp = [128,0xFF,0xFF]
|
|
duty = [0xFF,0xFF]
|
|
wave = [0xFF,0xFF]
|
|
cutoff = [0xFF,0xFF]
|
|
macros = []
|
|
for j in a:
|
|
macros = j.macros
|
|
hasRelTotal = [0,0,0,0]
|
|
for j in macros:
|
|
kind = j.kind
|
|
if kind == MacroCode.ARP:
|
|
s = j.speed
|
|
arp = []
|
|
loop = 0xff
|
|
hasRel = 0
|
|
oldlen = 0
|
|
if j.data[-1] == MacroItem.LOOP:
|
|
arr = [MacroItem.LOOP, j.data[-2]]
|
|
j.data = j.data[:-2] + arr
|
|
for k in j.data:
|
|
if k == MacroItem.LOOP:
|
|
loop = oldlen
|
|
elif k == MacroItem.RELEASE:
|
|
arp.append(0xFF)
|
|
arp.append(loop)
|
|
relA.append(len(arp))
|
|
oldlen = max(len(arp),0)
|
|
hasRel = 1
|
|
elif (k>>30) > 0:
|
|
arp.append(0xFE)
|
|
k = abs(k^(1<<30))
|
|
k = max(min(k,95),0)
|
|
arp.append(k%120)
|
|
oldlen = max(len(arp),0)
|
|
else:
|
|
if k < 0:
|
|
arp.append((k%120)-120+128)
|
|
else:
|
|
arp.append((k%120)+128)
|
|
oldlen = max(len(arp),0)
|
|
if hasRel == 0:
|
|
relA.append(len(arp))
|
|
hasRelTotal[1] = 1
|
|
len_temp = len(arp)
|
|
arp.append(0xFF)
|
|
arp.append(loop if loop!=len_temp else 0xff)
|
|
if kind == MacroCode.DUTY and j.type == MacroType.LFO:
|
|
while type(j.data[0]) is not int:
|
|
j.data = j.data[1:]
|
|
|
|
s = j.speed
|
|
duty = []
|
|
hasRel = 0
|
|
lfo = j.data[13]
|
|
while lfo <= 1023:
|
|
lfo += j.data[11]
|
|
if lfo > 1023: break
|
|
k = lfo
|
|
if k & 512:
|
|
k = 1023-lfo
|
|
k >>= 1
|
|
k = j.data[0]+((k+(j.data[1]-j.data[0])*k)>>8)
|
|
if (k&0xff) == 255:
|
|
duty.append(254)
|
|
else:
|
|
duty.append(k&0xff)
|
|
duty.append(k>>8)
|
|
if hasRel == 0:
|
|
relD.append(0)
|
|
hasRelTotal[2] = 1
|
|
duty.append(0xFF)
|
|
duty.append(0)
|
|
elif kind == MacroCode.DUTY:
|
|
s = j.speed
|
|
duty = []
|
|
loop = 0xff
|
|
loop2 = 0
|
|
hasRel = 0
|
|
for k in j.data:
|
|
if k == MacroItem.LOOP:
|
|
loop = loop2
|
|
elif k == MacroItem.RELEASE:
|
|
duty.append(0xFF)
|
|
duty.append(loop)
|
|
relD.append(len(duty))
|
|
hasRel = 1
|
|
else:
|
|
loop2 = len(duty)+2
|
|
if hasAbsDuty:
|
|
if (k&0xff) == 255:
|
|
duty.append(254)
|
|
else:
|
|
duty.append(k&0xff)
|
|
duty.append(k>>8)
|
|
else:
|
|
k = 32768-(k*4) #4)
|
|
duty.append(k&0xff)
|
|
duty.append(k>>8)
|
|
if hasRel == 0:
|
|
relD.append(len(duty))
|
|
hasRelTotal[2] = 1
|
|
len_temp = len(duty)
|
|
duty.append(0xFF)
|
|
duty.append(loop if loop!=len_temp else 0xff)
|
|
if kind == MacroCode.ALG and j.type == MacroType.LFO:
|
|
while type(j.data[0]) is not int:
|
|
j.data = j.data[1:]
|
|
|
|
s = j.speed
|
|
cutoff = []
|
|
hasRel = 0
|
|
lfo = j.data[13]
|
|
while lfo <= 1023:
|
|
lfo += j.data[11]
|
|
k = lfo
|
|
if k & 512:
|
|
k = 1023-lfo
|
|
k >>= 1
|
|
k = j.data[0]+((k+(j.data[1]-j.data[0])*k)>>8)
|
|
if (k&0xff) == 255:
|
|
cutoff.append(254)
|
|
else:
|
|
cutoff.append(k&0xff)
|
|
cutoff.append(k>>8)
|
|
if hasRel == 0:
|
|
relC.append(len(cutoff))
|
|
hasRelTotal[3] = 1
|
|
cutoff.append(0xFF)
|
|
cutoff.append(0)
|
|
elif kind == MacroCode.ALG:
|
|
s = j.speed
|
|
cutoff = []
|
|
loop = 0xff
|
|
loop2 = 0
|
|
hasRel = 0
|
|
for k in j.data:
|
|
if k == MacroItem.LOOP:
|
|
loop = loop2
|
|
elif k == MacroItem.RELEASE:
|
|
cutoff.append(0xFF)
|
|
cutoff.append(loop)
|
|
relC.append(len(cutoff))
|
|
hasRel = 1
|
|
else:
|
|
loop2 = len(cutoff)+1
|
|
if hasAbsFilter:
|
|
if (k&0xff) == 255:
|
|
cutoff.append(254)
|
|
else:
|
|
cutoff.append(k&0xff)
|
|
cutoff.append(k>>8)
|
|
else:
|
|
k = 32768+k*7
|
|
cutoff.append(k&0xff)
|
|
cutoff.append(k>>8)
|
|
if hasRel == 0:
|
|
relC.append(len(cutoff))
|
|
hasRelTotal[3] = 1
|
|
len_temp = len(cutoff)
|
|
cutoff.append(0xFF)
|
|
cutoff.append(loop if loop!=len_temp else 0xff)
|
|
if kind == MacroCode.WAVE:
|
|
s = j.speed
|
|
wave = []
|
|
loop = 0xff
|
|
loop2 = 0
|
|
hasRel = 0
|
|
for k in j.data:
|
|
if k == MacroItem.LOOP:
|
|
loop = len(wave)
|
|
elif k == MacroItem.RELEASE:
|
|
wave.append(0xFF)
|
|
wave.append(loop)
|
|
relW.append(len(wave))
|
|
hasRel = 1
|
|
else:
|
|
wave.append(k<<4)
|
|
if hasRel == 0:
|
|
relW.append(len(wave))
|
|
hasRelTotal[0] = 1
|
|
len_temp = len(wave)
|
|
wave.append(0xFF)
|
|
wave.append(loop if loop!=len_temp else 0xff)
|
|
if hasRelTotal[0] == 0:
|
|
relW.append(0)
|
|
if hasRelTotal[1] == 0:
|
|
relA.append(0)
|
|
if hasRelTotal[2] == 0:
|
|
relD.append(0)
|
|
if hasRelTotal[3] == 0:
|
|
relC.append(0)
|
|
wave = str(wave)[1:-1]
|
|
duty = str(duty)[1:-1]
|
|
arp = str(arp)[1:-1]
|
|
cutoff = str(cutoff)[1:-1]
|
|
if arp in dups:
|
|
f.write("ins"+str(i)+"A = "+dups[arp]+"\n")
|
|
else:
|
|
f.write("ins"+str(i)+"A:\n")
|
|
f.write(".byte "+arp+"\n")
|
|
dups[arp] = "ins"+str(i)+"A"
|
|
|
|
if duty in dups:
|
|
f.write("ins"+str(i)+"D = "+dups[duty]+"\n")
|
|
else:
|
|
f.write("ins"+str(i)+"D:\n")
|
|
f.write(".byte "+duty+"\n")
|
|
dups[duty] = "ins"+str(i)+"D"
|
|
|
|
if wave in dups:
|
|
f.write("ins"+str(i)+"W = "+dups[wave]+"\n")
|
|
else:
|
|
f.write("ins"+str(i)+"W:\n")
|
|
f.write(".byte "+wave+"\n")
|
|
dups[wave] = "ins"+str(i)+"W"
|
|
|
|
if cutoff in dups:
|
|
f.write("ins"+str(i)+"C = "+dups[cutoff]+"\n")
|
|
else:
|
|
f.write("ins"+str(i)+"C:\n")
|
|
f.write(".byte "+cutoff+"\n")
|
|
dups[cutoff] = "ins"+str(i)+"C"
|
|
|
|
relW = str(relW)[1:-1]
|
|
relD = str(relD)[1:-1]
|
|
relA = str(relA)[1:-1]
|
|
f.write("insArel:\n")
|
|
f.write(".byte "+relA+"\n")
|
|
f.write("insDrel:\n")
|
|
f.write(".byte "+relD+"\n")
|
|
f.write("insWrel:\n")
|
|
f.write(".byte "+relW+"\n")
|
|
|
|
for i in range(chnum):
|
|
order = module.subsongs[subsong].order[i]
|
|
f.write("order"+str(i)+"len = "+str(len(order))+"\n")
|
|
f.write("order"+str(i)+"L:\n")
|
|
f.write(".byte ")
|
|
for o in range(len(order)):
|
|
f.write("<(patCH"+str(i)+"N"+str(order[o])+"-1)")
|
|
if o == len(order)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
f.write("order"+str(i)+"H:\n")
|
|
f.write(".byte ")
|
|
for o in range(len(order)):
|
|
f.write(">(patCH"+str(i)+"N"+str(order[o])+"-1)")
|
|
if o == len(order)-1:
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
for i in range(chnum):
|
|
order = module.subsongs[subsong].order[i]
|
|
avail_patterns = filter(
|
|
lambda x: (
|
|
x.channel == i and
|
|
x.subsong == subsong
|
|
),
|
|
module.patterns
|
|
)
|
|
for p in avail_patterns:
|
|
patnum = p.index
|
|
#print(patnum,i)
|
|
g = str(comp(conv_pattern(p)))[1:-1]
|
|
f.write("patCH"+str(i)+"N"+str(patnum)+":\n")
|
|
f.write(".byte "+g+"\n")
|
|
|
|
if chnum == 4:
|
|
f.write("sampleHS:\n.hibytes ")
|
|
for i in range(len(module.samples)):
|
|
f.write("PCM"+str(i))
|
|
if i == (len(module.samples)-1):
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write("sampleHE:\n.hibytes ")
|
|
for i in range(len(module.samples)):
|
|
f.write("PCMe"+str(i))
|
|
if i == (len(module.samples)-1):
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
total_maps = []
|
|
f.write("insSI:\n.byte ")
|
|
for i in range(len(module.instruments)):
|
|
features = module.instruments[i].features
|
|
a = filter(
|
|
lambda x: (
|
|
type(x) == InsFeatureAmiga
|
|
), features
|
|
)
|
|
init_sample = 0
|
|
for j in a:
|
|
if j.init_sample > 0 and j.init_sample != 65535:
|
|
init_sample = j.init_sample
|
|
break
|
|
f.write(str(init_sample))
|
|
if i == (len(module.instruments)-1):
|
|
f.write("\n")
|
|
else:
|
|
f.write(", ")
|
|
|
|
f.write(".res 256-(*&$ff), 0\n")
|
|
for i in range(len(module.samples)):
|
|
sample = []
|
|
rate = max(min(module.samples[i].meta.sample_rate,384000),100)
|
|
smp = list(module.samples[i].data)
|
|
k = 0
|
|
while k < len(smp):
|
|
j = smp[int(k)]
|
|
s = float(((int(j)+128)&0xff))
|
|
s = ((s-128)/1.65)+128
|
|
#s = ((s-128)/1.6)+128
|
|
s = int(s/16)
|
|
#s = (s>>1)+8
|
|
sample.append(s)
|
|
k += rate/7812
|
|
s = sample[-1]
|
|
if (len(sample)%256) == 0:
|
|
sample.extend([s]*256)
|
|
else:
|
|
while (len(sample)%256) != 0:
|
|
sample.append(s)
|
|
f.write("PCM"+str(i)+":\n.byte "+str(sample)[1:-1]+"\n")
|
|
f.write("PCMe"+str(i)+":\n")
|
|
|
|
f.close()
|
|
|
|
# frequency calculation code taken from
|
|
# https://codebase64.org/doku.php?id=base:how_to_calculate_your_own_sid_frequency_table
|
|
|
|
tuning = module.meta.tuning
|
|
f = open("asm/note_lo.bin","wb")
|
|
for i in range(96):
|
|
hz = tuning * (2**(float(i-57)/12.0))
|
|
cnst = (256**3)/985248.0 # PAL frequency
|
|
freq = min(max(hz*cnst,0),0xffff)
|
|
f.write(bytearray([int(freq)&0xff]))
|
|
f.close()
|
|
f = open("asm/note_hi.bin","wb")
|
|
for i in range(96):
|
|
hz = tuning * (2**(float(i-57)/12.0))
|
|
cnst = (256**3)/985248.0 # PAL frequency
|
|
freq = min(max(hz*cnst,0),0xffff)
|
|
f.write(bytearray([(int(freq)>>8)&0xff]))
|
|
f.close()
|