def parse(self, patch, data):
bitstream = BitStream(data)
read_bits = bitstream.read_bits
nvariations, nmorphs, _, _ = bitstream.read_bitsa([8, 4, 10, 10])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
morphmaps = patch.settings.morphmaps
for i in xrange(nvariations):
variation = read_bits(4)
bitstream.seek_bit(4 + (6*8) + 4, 1) # zeros
nmorphs = read_bits(8)
for j in xrange(nmorphs):
morph_map = MorphMap()
area, index, param, morph = bitstream.read_bitsa([2, 8, 7, 4])
morph_map.range = read_bits(8, 1)
module = get_patch_area(patch, area).find_module(index)
morph_map.param = module.params[param]
morph_map.variation = variation
morph_map.morph = morphs[morph-1]
morph_map.morph.maps[variation].append(morph_map)
morphmaps[variation].append(morph_map)
reserved = read_bits(4) # always 0
def format(self, patch, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
bitstream.write_bitsa([8, 4, 10, 10], [ NVARIATIONS, NMORPHS, 0, 0])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
for variation in xrange(NVARIATIONS):
write_bits(4, variation)
bitstream.seek_bit(4 + (6 * 8) + 4, 1)
# collect all morph_maps of this variation into 1 array
morph_maps = []
for morph in morphs:
morph_maps.extend(morph.maps[variation])
def mod_param_index_cmp(a, b):
return cmp(a.param.module.index, b.param.module.index)
morph_maps.sort(mod_param_index_cmp)
write_bits(8, len(morph_maps))
for morph_map in morph_maps:
values = [
morph_map.param.module.area.index, morph_map.param.module.index,
morph_map.param.index, morph_map.morph.index, morph_map.range,
] # range is signed
bitstream.write_bitsa([2, 8, 7, 4, 8], values)
write_bits(4, 0) # always 0
bitstream.seek_bit(-4, 1) # remove last 4-bits
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
nknobs = bitstream.read_bits(16)
patch.knobs = [ Knob() for i in xrange(nknobs)] # G2Patch / G2Performance
for knob in patch.knobs:
knob.assigned = bitstream.read_bits(1)
if not knob.assigned:
continue
area, index, knob.isled, param = bitstream.read_bitsa([2, 8, 2, 7])
if type(patch) == Performance:
knob.slot = bitstream.read_bits(2)
perf = patch
patch = perf.slots[knob.slot].patch
else:
knob.slot = 0
if area == SETTINGS:
knob.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
if module:
knob.param = module.params[param]
else:
knob.assigned = 0
continue
knob.param.knob = knob
def format(self, patch, data):
bitstream = BitStream(data)
if self.area == SETTINGS:
self.format_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
self.parse_morphs(patch.settings.morphs, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
if self.area == SETTINGS:
self.format_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
self.parse_morphs(patch.settings.morphs, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
patch.settings = Settings() # G2Patch
self.parse_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def parse(self, patch, data):
bitstream = BitStream(data)
lastnote = patch.lastnote = Note() # G2Patch
values = bitstream.read_bitsa([7] * 3)
lastnote.note, lastnote.attack, lastnote.release = values
nnotes = bitstream.read_bits(5) + 1
notes = patch.notes = [ Note() for i in xrange(nnotes) ] # G2Patch
for note in notes:
note.note, note.attack, note.release = bitstream.read_bitsa([7, 7, 7])
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
patch.settings = Settings() # G2Patch
self.parse_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def parse(self, patch, data):
bitstream = BitStream(data)
lastnote = patch.lastnote = Note() # G2Patch
values = bitstream.read_bitsa([7] * 3)
lastnote.note, lastnote.attack, lastnote.release = values
nnotes = bitstream.read_bits(5) + 1
notes = patch.notes = [Note() for i in xrange(nnotes)] # G2Patch
for note in notes:
note.note, note.attack, note.release = bitstream.read_bitsa(
[7, 7, 7])
def parse(self, patch, data):
bitstream = BitStream(data)
nctrls = bitstream.read_bits(7)
patch.ctrls = [ Ctrl() for i in xrange(nctrls)] # G2Patch? / G2Ctrl?
for ctrl in patch.ctrls:
ctrl.midicc, area, index, param = bitstream.read_bitsa([7, 2, 8, 7])
if area == SETTINGS:
ctrl.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
ctrl.param = module.params[param]
ctrl.param.ctrl = ctrl
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(16, NKNOBS)
for knob in patch.knobs:
bitstream.write_bits(1, knob.assigned)
if not knob.assigned:
continue
module = knob.param.module
bitstream.write_bitsa([2, 8, 2, 7],
[ module.area.index, module.index, knob.isled, knob.param.index ])
if type(patch) == Performance:
bitstream.write_bits(2, knob.slot)
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
nctrls = bitstream.read_bits(7)
patch.ctrls = [Ctrl() for i in xrange(nctrls)] # G2Patch? / G2Ctrl?
for ctrl in patch.ctrls:
ctrl.midicc, area, index, param = bitstream.read_bitsa(
[7, 2, 8, 7])
if area == SETTINGS:
ctrl.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
ctrl.param = module.params[param]
ctrl.param.ctrl = ctrl
def format(self, performance, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
description = performance.description
for name, nbits in self.description_attrs:
write_bits(nbits, getattr(description, name))
for slot in performance.slots:
write_string(bitstream, slot.name, 16)
for name, nbits in self.slot_attrs:
write_bits(nbits, getattr(slot.description, name))
return bitstream.tell_bit()
def format(self, performance, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
description = performance.description
for name, nbits in self.description_attrs:
write_bits(nbits, getattr(description, name))
for slot in performance.slots:
write_string(bitstream, slot.name, 16)
for name, nbits in self.slot_attrs:
write_bits(nbits, getattr(slot.description, name))
return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data)
if self.area == SETTINGS:
return self.format_morphs(patch.settings.morphs, bitstream)
else:
area = get_patch_area(patch, self.area)
return self.format_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
if len(patch.notes):
lastnote = patch.lastnote
if not lastnote:
values = [ 64, 0, 0 ]
else:
values = [ lastnote.note, lastnote.attack, lastnote.release ]
bitstream.write_bitsa([7, 7, 7], values)
bitstream.write_bits(5, len(patch.notes)-1)
for note in patch.notes:
bitstream.write_bitsa([7, 7, 7], [note.note, note.attack, note.release])
else:
bitstream.write_bits(24, 0x800000)
bitstream.write_bits(24, 0x200000)
return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(7, len(patch.ctrls))
for ctrl in patch.ctrls:
param = ctrl.param
bitstream.write_bitsa([7, 2, 8, 7], [
ctrl.midicc, param.module.area.index, param.module.index,
param.index
])
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
read_bits = bitstream.read_bits
nvariations, nmorphs, _, _ = bitstream.read_bitsa([8, 4, 10, 10])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
morphmaps = patch.settings.morphmaps
for i in xrange(nvariations):
variation = read_bits(4)
bitstream.seek_bit(4 + (6 * 8) + 4, 1) # zeros
nmorphs = read_bits(8)
for j in xrange(nmorphs):
morph_map = MorphMap()
area, index, param, morph = bitstream.read_bitsa([2, 8, 7, 4])
morph_map.range = read_bits(8, 1)
module = get_patch_area(patch, area).find_module(index)
morph_map.param = module.params[param]
morph_map.variation = variation
morph_map.morph = morphs[morph - 1]
morph_map.morph.maps[variation].append(morph_map)
morphmaps[variation].append(morph_map)
reserved = read_bits(4) # always 0
def parse(self, patch, data):
bitstream = BitStream(data)
nknobs = bitstream.read_bits(16)
patch.knobs = [Knob()
for i in xrange(nknobs)] # G2Patch / G2Performance
for knob in patch.knobs:
knob.assigned = bitstream.read_bits(1)
if not knob.assigned:
continue
area, index, knob.isled, param = bitstream.read_bitsa([2, 8, 2, 7])
if type(patch) == Performance:
knob.slot = bitstream.read_bits(2)
perf = patch
patch = perf.slots[knob.slot].patch
else:
knob.slot = 0
if area == SETTINGS:
knob.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
if module:
knob.param = module.params[param]
else:
knob.assigned = 0
continue
knob.param.knob = knob
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(7, len(patch.ctrls))
for ctrl in patch.ctrls:
param = ctrl.param
bitstream.write_bitsa([7, 2, 8, 7], [ ctrl.midicc,
param.module.area.index, param.module.index, param.index ])
return bitstream.tell_bit()
def parse(self, performance, data):
description = performance.description = Description() # G2Performance
bitstream = BitStream(data)
read_bits = bitstream.read_bits
for name, nbits in self.description_attrs:
value = read_bits(nbits)
setattr(description, name, value)
for slot in performance.slots:
slot.description = Description()
slot.name = read_string(bitstream, 16)
for name, nbits in self.slot_attrs:
value = read_bits(nbits)
setattr(slot.description, name, value)
def format(self, patch, data): bitstream = BitStream(data) area = get_patch_area(patch, self.area) self.format_area(area, bitstream) return bitstream.tell_bit()
def format(self, patch, data): bitstream = BitStream(data) bitstream.write_str(patch.textpad) return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data)
if len(patch.notes):
lastnote = patch.lastnote
if not lastnote:
values = [64, 0, 0]
else:
values = [lastnote.note, lastnote.attack, lastnote.release]
bitstream.write_bitsa([7, 7, 7], values)
bitstream.write_bits(5, len(patch.notes) - 1)
for note in patch.notes:
bitstream.write_bitsa([7, 7, 7],
[note.note, note.attack, note.release])
else:
bitstream.write_bits(24, 0x800000)
bitstream.write_bits(24, 0x200000)
return bitstream.tell_bit()
def parse(self, patch, data): bitstream = BitStream(data) self.area = bitstream.read_bits(2) area = get_patch_area(patch, self.area) self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(16, NKNOBS)
for knob in patch.knobs:
bitstream.write_bits(1, knob.assigned)
if not knob.assigned:
continue
module = knob.param.module
bitstream.write_bitsa([2, 8, 2, 7], [
module.area.index, module.index, knob.isled, knob.param.index
])
if type(patch) == Performance:
bitstream.write_bits(2, knob.slot)
return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
bitstream.write_bitsa([8, 4, 10, 10], [NVARIATIONS, NMORPHS, 0, 0])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
for variation in xrange(NVARIATIONS):
write_bits(4, variation)
bitstream.seek_bit(4 + (6 * 8) + 4, 1)
# collect all morph_maps of this variation into 1 array
morph_maps = []
for morph in morphs:
morph_maps.extend(morph.maps[variation])
def mod_param_index_cmp(a, b):
return cmp(a.param.module.index, b.param.module.index)
morph_maps.sort(mod_param_index_cmp)
write_bits(8, len(morph_maps))
for morph_map in morph_maps:
values = [
morph_map.param.module.area.index,
morph_map.param.module.index,
morph_map.param.index,
morph_map.morph.index,
morph_map.range,
] # range is signed
bitstream.write_bitsa([2, 8, 7, 4, 8], values)
write_bits(4, 0) # always 0
bitstream.seek_bit(-4, 1) # remove last 4-bits
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_str(patch.textpad)
return bitstream.tell_bit()
def format(self, patch, data):
bitstream = BitStream(data, 7 * 8)
self.format_description(patch.description, bitstream)
return bitstream.tell_bit()
def format(self, patch, data): bitstream = BitStream(data, 7*8) self.format_description(patch.description, bitstream) return bitstream.tell_bit()
def cmd_settings(command):
g2usb.send_message([CMD_SYS, 0x41, 0x35, 0x04])
syst = g2usb.send_message([CMD_SYS, 0x41, 0x02])
synthname, syst = parse_name(syst[4:])
printf('%s:\n', synthname)
bitstream = BitStream(syst)
mode = bitstream.read_bits(1)
bitstream.seek_bit(8*5)
midis = bitstream.read_bitsa([8]*5)
sysex, local, _, prgch = bitstream.read_bitsa([8, 1, 7, 8])
_, clkse, clkre, _ = bitstream.read_bitsa([1, 1, 1, 5])
_, tune_cent, _, tune_semi = bitstream.read_bitsa([8, 8, 16, 8])
_, pedal_polarity, _, pedal_gain = bitstream.read_bitsa([8, 1, 7, 8])
printf(' mode: %s\n', ['Patch', 'Performance'][mode])
printf(' midi:\n')
printf(' slots: a:%d b:%d c:%d d:%d glob:%d\n', *midis)
printf(' sysex: %d\n', sysex+1)
printf(' local: %s\n', ['off','on'][local])
printf(' prgch: %s\n', ['off','send','recv','send/recv'][prgch])
printf(' clkse: %s\n', ['on','off'][clkse])
printf(' clkre: %s\n', ['on','off'][clkre])
printf(' tune semi: %d\n', struct.unpack('b',chr(tune_semi))[0])
printf(' tune cent: %d\n', struct.unpack('b',chr(tune_cent))[0])
printf(' pedal polarity: %s\n', ['open','closed'][pedal_polarity])
printf(' pedal gain: %.2f\n', 1.0 + 0.5*pedal_gain/32)
sels = g2usb.send_message([CMD_SYS, 0x41, 0x81])
data = g2usb.send_message([CMD_SYS, sels[2], 0x10])
perfname, data = parse_name(data[4:])
bitstream = BitStream(data, 8*4)
if mode:
printf('Performance: %s\n', perfname)
else:
printf('Patches: %s\n', perfname)
_, focus, _ = bitstream.read_bitsa([4, 2, 2])
range_enable, bpm, split, clock = bitstream.read_bitsa([8, 8, 8, 8])
printf(' focus: %s\n', 'abcd'[focus])
printf(' range enable: %s\n', ['off','on'][range_enable])
printf(' master clock: %d BPM: %s\n', bpm, ['stop','run'][clock])
printf(' kb split: %s\n', ['off','on'][split])
data = data[11:]
for slot in range(4):
name, data = parse_name(data)
active, key, hold, bank, patch, low, high = data[:7]
printf(' slot %s: %d:%d "%-16s"\n', 'abcd'[slot], bank+1, patch+1, name)
printf(' active: %-3s, ', ['off','on'][active])
printf('key: %-3s, ', ['off','on'][key])
printf('hold: %-3s, ', ['off','on'][hold])
printf('range: %d-%d\n', low, high)
data = data[10:]
return 0
def parse(self, patch, data):
description = patch.description = Description() # G2Patch
bitstream = BitStream(data, 7 * 8)
self.parse_description(patch.description, bitstream)
