def __init__(self):
persistent_attrs_init(self)
self.synth = Fluidsynth()
logging.debug("...")
# 16 channels. One DeviceChain for each channel. Each
# DeviceChain has a `Latch` and `Arpeggiator`
self.devicechains = [DeviceChain(self, i) for i in range(16)]
## The root of all notes.
self.key = notes.A
logging.debug("...")
self.grids = []
self.scale = [0, 3, 6, 7, 10]
self.cpu = CPU(self)
self.clock = Clock(self)
self.looper = Looper(self)
self.mixer = Mixer(self)
self.detect_devices()
# FIXME: probably make this configurable somehow (env var...?)
if False:
from termpad import ASCIIGrid
self.grids.append(ASCIIGrid(self, 0, 1))
def test_make_proof(self):
wrapper = Mixer(NATIVE_LIB_PATH, VK_PATH, PK_PATH)
tree_depth = wrapper.tree_depth
n_items = 2 << (tree_depth - 1)
tree = MerkleTree(n_items)
for n in range(0, 2):
tree.append(int(FQ.random()))
wallet_address = int(FQ.random())
nullifier_secret = int(FQ.random())
nullifier_hash = mimc_hash([nullifier_secret, nullifier_secret])
leaf_hash = int(
get_sha256_hash(to_hex(nullifier_secret), to_hex(wallet_address)),
16)
leaf_idx = tree.append(leaf_hash)
self.assertEqual(leaf_idx, tree.index(leaf_hash))
# Verify it exists in true
leaf_proof = tree.proof(leaf_idx)
self.assertTrue(leaf_proof.verify(tree.root))
# Generate proof
snark_proof = wrapper.prove(
tree.root,
wallet_address,
nullifier_hash,
nullifier_secret,
# (index)_2 bits reversed, i.e. [LSB, ... , MSB]
leaf_proof.address,
leaf_proof.path)
self.assertTrue(wrapper.verify(snark_proof))
def test_1(self):
mixer1 = Mixer()
out_v: int = mixer1.getvolume(out=True)
in_v: int = mixer1.getvolume(out=False)
mixer1.setvolume(33, out=True)
mixer1.setvolume(23, out=False)
self.assertEqual(mixer1.getvolume(out=True), 33)
self.assertEqual(mixer1.getvolume(out=False), 23)
mixer1.setvolume(out_v, out=True)
mixer1.setvolume(in_v, out=False)
mixer3 = Mixer()
self.assertEqual(mixer3.getvolume(out=True), out_v)
self.assertEqual(mixer3.getvolume(out=False), in_v)
def playit(self,file):
os.system('clear')
"Playing..."
playing = Mixer(file)
playing.mixer()
os.system('clear')
print "Done."
pass
pass
def __init__(self):
persistent_attrs_init(self)
self.synth = Fluidsynth()
self.devicechains = [DeviceChain(self, i) for i in range(16)]
self.grids = []
self.cpu = CPU(self)
self.clock = Clock(self)
self.looper = Looper(self)
self.mixer = Mixer(self)
# FIXME: probably make this configurable somehow (env var...?)
if False:
from termpad import ASCIIGrid
self.grids.append(ASCIIGrid(self, 0, 1))
def mixer_process_function():
"""This function is meant to be placed into is own process and loops in
order to play the sounds without delay
"""
# Initialise the mixer and provide a callback to output to the GPIO port
mixer = Mixer(lambda x: GPIO.output(consts.BUZZER_GPIO_CODE, x > 0.0))
time_old = time.time()
while True:
time_now = time.time()
# Take from the queue and insert into the mixer
while not consts.MIXER_QUEUE.empty():
mixer.insert(*consts.MIXER_QUEUE.get())
time_delta = time_now - time_old
# Sample the mixer to provide output
mixer.sample(time_delta)
time_old = time_now
def __init__(self,
input_bits=12,
output_bits=16,
phaseinc_bits=18,
nco_bits=18,
if_bits=20):
self.i_sample = Signal((input_bits, True))
self.o_i = Signal((output_bits, True))
self.o_q = Signal((output_bits, True))
self.o_valid = Signal()
self.i_nco_freq = Signal(phaseinc_bits)
self.input_bits = input_bits
self.output_bits = output_bits
self.phase_bits = phaseinc_bits
self.if_bits = if_bits
self.nco_bits = nco_bits
self.nco = nco = NCO(output_bits=nco_bits, phaseinc_bits=phaseinc_bits)
self.mixer = mixer = Mixer(sample_bits=input_bits,
nco_bits=nco_bits,
output_bits=if_bits)
self.cic_i = cic_i = CIC(input_bits=if_bits)
self.cic_q = cic_q = CIC(input_bits=if_bits)
self.comb += [
mixer.i_sample.eq(self.i_sample),
mixer.i_nco_i.eq(nco.o_nco_i),
mixer.i_nco_q.eq(nco.o_nco_q),
cic_i.i_sample.eq(mixer.o_i),
cic_q.i_sample.eq(mixer.o_q),
self.o_valid.eq(cic_i.o_valid),
self.o_i.eq(cic_i.o_result[(cic_i.filter_bits - output_bits):]),
self.o_q.eq(cic_q.o_result[(cic_q.filter_bits - output_bits):])
]
self.submodules += [
nco,
mixer,
cic_i,
cic_q,
]
def __init__(self):
"""Class constructor. Loads everything into memory
"""
self.display = pg.display.set_mode((640, 360))
pg.display.set_caption("Crawler")
pg.init()
self.level_list = None
self.gui = Gui((640, 360))
self.level_id = 0
self.level = None
self.event_queue = EventQueue()
self.clock = Clock()
self.renderer = Renderer(self.display, self.level, self.gui)
self.mixer = Mixer()
self.mixer.load_track(0)
self.mixer.set_volume(0.3)
self.game_loop = None
self.menu_loop = MenuLoop(self.renderer, self.event_queue, self.clock)
self.start_menu()
def __init__(self, display: Display):
self.__mixer = Mixer()
# precaution initial muting
self.__mixer.mute()
self.__stateFile = StateFile()
self.__display = display
self.__showInitInfo()
self.__cdIsOver = False
self.__mpv = MyMPV(self)
self.__selectedSource = None
self.__extConfig = self.__initExtConfig()
# initial mute - arduino will send proper volumecommand
# initial mute - arduino will send proper volumecommand
# self.__switchToRadio()
radioSource = RadioSource(display, self.__extConfig, self.__stateFile,
self.__mixer, self)
self.__cdSource = CDSource(display, self.__extConfig, self.__stateFile,
self.__mixer, self)
flashSource = FlashSource(display, self.__extConfig, self.__stateFile,
self.__mixer, self)
self.__sources = [radioSource, flashSource, self.__cdSource]
self.__ringSources = cycle(self.__sources)
self.switch()
def __init__( self, freq=440.0, level=1.0, phase=0.0, feedback=0, wave_type='sine', fm_type='DX', gate=Gate([0.0]), key_in=None ): Oscillator.__init__(self, key_in) self.freq = freq #frequency self.mixer = Mixer() #mixer to add modulators' outputs #sound generator if fm_type == 'LinearFM': self.generator = LinearFMGenerator( freq, level, phase, wave_type, self.mixer, key_in ) elif fm_type == 'DX': self.generator = DXGenerator( freq, level, phase, wave_type, self.mixer, key_in ) self.eg = ADSR(input=gate) #envelope generator #amplifier self.amp = Amplifier(input=self.generator, mod=self.eg)
from mixer import Mixer, get_from_list, shuffled_ints, shuffled_decs
if __name__ == "__main__":
fn = get_from_list("lists/firstnames.txt")
ln = get_from_list("lists/lastnames.txt")
dates_f = get_from_list("lists/dates.txt")
systems_f = get_from_list("lists/systems.txt")
device_agents_f = get_from_list("lists/device_agents.txt")
mixer = Mixer()
mixer.set_delimiter('|')
mixer.add_column(fn)
mixer.add_column(ln)
mixer.add_column(shuffled_ints(1, 5))
mixer.add_column(shuffled_ints(100, 250))
mixer.add_column(dates_f)
mixer.add_column(systems_f)
mixer.add_column(device_agents_f)
mixer.add_column(dates_f)
mixer.add_column(['\n'])
print mixer.mix(number_of_records=100, with_incremental_id=False)
with open('sample-data.txt', "w+") as f:
f.writelines([
"first_name|last_name|count_num|amount|start_date|name_2|name_3|date_1|empty_col\n"
])
f.writelines(
mixer.mix(number_of_records=100000, with_incremental_id=False))
N_COMPS = 5
unit_dict = dict()
# instantiate the required objects
condensate = Stream(n_comps=N_COMPS, name='Condensate')
reflux = Stream(n_comps=N_COMPS, name='Reflux')
top_product = Stream(n_comps=N_COMPS, name='Top product')
bottoms = Stream(n_comps=N_COMPS, name='Bottoms')
vapor_reboil = Stream(n_comps=N_COMPS, name='Vapor reboil')
bottom_product = Stream(n_comps=N_COMPS, name='Bottom product')
feed = Stream(n_comps=N_COMPS, name='LiquidFeed')
condenser = Mixer(streams_in=[condensate],
streams_out=[reflux, top_product],
name='Condenser')
reboiler = Mixer(streams_in=[bottoms],
streams_out=[vapor_reboil, bottom_product],
name='Reboiler')
feed_flow_spec = Specify(flow=True, stream=feed, value=100)
feed_temp_spec = Specify(temperature=True, stream=feed, value=100)
feed_ic4_spec = Specify(fraction=True, stream=feed, comp_num=0, value=0.1)
feed_nc4_spec = Specify(fraction=True, stream=feed, comp_num=1, value=0.3)
feed_ic5_spec = Specify(fraction=True, stream=feed, comp_num=2, value=0.2)
feed_nc5_spec = Specify(fraction=True, stream=feed, comp_num=3, value=0.3)
feed_nc6_spec = Specify(fraction=True, stream=feed, comp_num=4, value=0.1)
reflux_flow_spec = Specify(flow=True, stream=reflux, value=120)
vapor_reboil_flow_spec = Specify(flow=True, stream=vapor_reboil, value=160)
top_product_flow_spec = Specify(flow=True, stream=top_product, value=40)
foust_8_11 = SimpleColumn(n_trays=15,
class ExtendedCtrl(LooperCtrl):
"""Add screen connection and Mixer.
Add looper commands"""
__mixer: Mixer = Mixer()
def __init__(self, scr_conn: Connection):
LooperCtrl.__init__(self)
self.__update_method: str = ""
self.__description: str = ""
self.__scr_conn: Connection = scr_conn
def _redraw(self) -> None:
"""used by children to _redraw itself on screen"""
if self.__update_method:
method = getattr(self, self.__update_method)
info = method()
else:
info = ""
part = self.get_item_now()
self.__scr_conn.send([
ConfigName.redraw, info, self.__description, part.length, self.idx,
self._go_play.is_set(),
self.get_stop_event().is_set()
])
def _prepare_redraw(self, update_method: str, description: str) -> None:
self.__update_method = update_method
self.__description = description
if self._is_rec:
self._is_rec = False
part = self.get_item_now()
loop = part.get_item_now()
if loop.is_empty:
loop.trim_buffer(self.idx, self.get_item_now().length)
self._redraw()
def _prepare_song(self) -> None:
super()._prepare_song()
self.items.append(SongPart(self))
self.items.append(SongPart(self))
self.items.append(SongPart(self))
self.items.append(SongPart(self))
# ========= change methods
def _load_drum_type(self):
self.drum.load_drum_type()
self._redraw()
def _change_mixer_in(self, change_by: int) -> None:
out_vol: bool = False
ExtendedCtrl.__mixer.change_volume(change_by, out_vol)
self._redraw()
def _change_mixer_out(self, change_by: int) -> None:
out_vol: bool = True
ExtendedCtrl.__mixer.change_volume(change_by, out_vol)
self._redraw()
def _change_drum_volume(self, change_by: int) -> None:
self.drum.change_volume(change_by)
self._redraw()
def _change_drum_swing(self, change_by: int) -> None:
self.drum.change_swing(change_by)
self._redraw()
def _change_drum(self) -> None:
self.drum.play_break_now()
def _change_song(self, *params) -> None:
self._file_finder.iterate_dir(go_fwd=params[0] > 0)
self._redraw()
def _change_drum_type(self, *params) -> None:
self.drum.change_drum_type(go_fwd=params[0] >= 0)
self._redraw()
def _change_drum_intensity(self, change_by: int) -> None:
self.drum.change_intensity(change_by)
# ================ show methods
def _show_song_now(self) -> str:
ff = self._file_finder
return ff.get_item_now()
def _show_song_next(self) -> str:
ff = self._file_finder
return ff.get_item_next()
def _show_drum_type(self) -> str:
return self.drum.show_drum_type()
def _show_one_part(self) -> str:
tmp = ""
part = self.get_item_now()
for k, loop in enumerate(part.items):
tmp += loop.state_str(k == part.now, k == part.next)
tmp += loop.info_str(USE_COLS)
tmp += "\n"
return tmp[:-1]
def _show_all_parts(self) -> str:
tmp = ""
for k, part in enumerate(self.items):
tmp += part.state_str(k == self.now, k == self.next)
tmp += part.items[0].info_str(
USE_COLS) if part.items_len else "-" * USE_COLS
tmp += "\n"
return tmp[:-1]
def _show_drum_param(self) -> str:
tmp = "vol:".ljust(STATE_COLS) + val_str(self.drum.volume, 0, 1,
USE_COLS) + "\n"
tmp += "swing:".ljust(STATE_COLS) + val_str(self.drum.swing, 0.5, 0.75,
USE_COLS)
return tmp
@staticmethod
def _show_mixer_volume() -> str:
tmp = "out:".ljust(STATE_COLS) + val_str(
ExtendedCtrl.__mixer.getvolume(out=True), 0, 100, USE_COLS) + "\n"
tmp += "in:".ljust(STATE_COLS) + val_str(
ExtendedCtrl.__mixer.getvolume(out=False), 0, 100, USE_COLS)
return tmp
@staticmethod
def _show_version() -> str:
return f"Version: {CURRENT_VERSION}"
# ================ other methods
def _fade_and_stop(self, *params):
self._go_play.clear()
seconds: int = params[0]
ExtendedCtrl.__mixer.fade(seconds)
self.stop_now()
@staticmethod
def _restart() -> None:
ppid = os.getppid()
run_os_cmd(["kill", "-9", str(ppid)])
@staticmethod
def _check_updates() -> None:
run_os_cmd(["git", "reset", "--hard"])
if 0 == run_os_cmd(["git", "pull", "--ff-only"]):
ExtendedCtrl._restart()
# ============ All song parts view and related commands
def _clear_part_id(self, part_id: int) -> None:
if part_id != self.now:
self._is_rec = False
part = self.items[part_id]
self.next = self.now
self._stop_never()
if not part.is_empty:
self.items[part_id] = SongPart(self)
self._redraw()
def _duplicate_part(self) -> None:
part = self.get_item_now()
if part.is_empty:
return
for x in self.items:
if x.is_empty:
x.items = copy.deepcopy(part.items)
self._redraw()
break
def _undo_part(self) -> None:
part = self.get_item_now()
if part.items_len > 1:
loop = part.items.pop()
part.now = part.next = 0
if self._is_rec:
self._is_rec = False
else:
part.backup.append(loop)
self._redraw()
def _redo_part(self) -> None:
self._is_rec = False
part = self.get_item_now()
if len(part.backup) > 0:
part.items.append(part.backup.pop())
self._redraw()
# ================= One song part view and related commands
def _change_loop(self, *params) -> None:
if self._is_rec:
return
part = self.get_item_now()
if params[0] == "prev":
new_id = part.now - 1
new_id %= part.items_len
part.now = new_id
elif params[0] == "next":
new_id = part.now + 1
new_id %= part.items_len
part.now = new_id
elif params[0] == "delete" and part.now != 0:
part.items.pop(part.now)
part.now = 0
elif params[0] == "silent" and part.now != 0:
loop = self.get_item_now().get_item_now()
loop.is_silent = not loop.is_silent
elif params[0] == "reverse" and part.now != 0:
loop = self.get_item_now().get_item_now()
loop.is_reverse = not loop.is_reverse
loop.is_silent = False
elif params[0] == "move" and part.now != 0:
loop = part.items.pop(part.now)
part.items.append(loop)
part.now = part.next = part.items_len - 1
self._redraw()
def _undo_loop(self):
self._is_rec = False
part = self.get_item_now()
if part.now == 0:
self._undo_part()
else:
loop = part.get_item_now()
if loop.is_empty:
part.items.pop(part.now)
part.now = part.next = 0
else:
loop.undo()
self._redraw()
def _redo_loop(self):
self._is_rec = False
part = self.get_item_now()
if part.now == 0:
self._redo_part()
else:
loop = part.get_item_now()
loop.redo()
self._redraw()
def __init__(self,
n_trays,
feed_tray,
feed_stream_liq,
reflux,
vapor_reboil,
condensate,
bottoms,
pressure,
tray_efficiency=1.0,
name=None):
'''
feed_tray must be an integer between 1 and n_trays-2 (feed cannot be to the top or bottom trays for now)
the bottom tray is tray number zero
the top tray is tray number n_trays-1
the default efficiency is 1 for all trays.
if tray_efficiency is a scalar, it is used for all trays.
if tray_efficiency is a dict (tray:efficiency), it is used for the specified trays. the remaining are
assigned an efficiency of 1.
'''
self.column_num = SimpleColumn.n_columns
super().__init__(name, self.column_num)
SimpleColumn.n_columns += 1
assert n_trays > 0, '{}: Number of tray must be greater than zero (specified {})'.format(
self.name, n_trays)
self.n_trays = n_trays
assert (feed_tray >= 1) and (feed_tray <= self.n_trays-2), \
'{}: Feed tray number must be from 1 to {} inclusive (specified {}). No feed to the top or bottom trays for now' \
.format(self.name, self.n_trays-2, feed_tray)
self.feed_tray = feed_tray
self.feed_stream_liq = feed_stream_liq
self.reflux = reflux
self.vapor_reboil = vapor_reboil
self.condensate = condensate
self.bottoms = bottoms
self.pressure = pressure
self.n_vars = 0
self.n_eqns = 0
self.xvar = None
self.eqns = None
# figure out number of streams to be created as part of this column
# for each tray, there are two streams leaving (one liquid, one vapor)
# one liquid feed stream (comes from outside the column)
# one stream that is a combination of the liquid feed stream and the liquid from the tray above the feed tray
# create the streams associated with the column
# tray liquid and vapor streams
self.tray_liq_stream = []
for i_tray in range(self.n_trays):
name = self.name + 'Tray' + str(i_tray) + 'Liquid'
# self.tray_liq_stream.append(Stream(n_comps=N_COMPS, name=name))
self.tray_liq_stream.append(
Stream(n_comps=self.feed_stream_liq.n_comps, name=name))
self.tray_vap_stream = []
for i_tray in range(self.n_trays):
name = self.name + 'Tray' + str(i_tray) + 'Vapor'
# self.tray_vap_stream.append(Stream(n_comps=N_COMPS, name=name))
self.tray_vap_stream.append(
Stream(n_comps=self.feed_stream_liq.n_comps, name=name))
# create the mixed stream consisting of the feed stream and the liquid from the tray above the feed tray
name = self.name + 'MixedLiquidFeed'
# self.mixed_liq_feed = Stream(n_comps=N_COMPS, name=name)
self.mixed_liq_feed = Stream(n_comps=self.feed_stream_liq.n_comps,
name=name)
self.unit_dict[name] = self.mixed_liq_feed
# create the mixer needed to mix the liquid feed and the liquid from the tray above the feed tray
name = self.name + 'FeedMixer'
self.feed_mixer = Mixer(streams_in=[
self.feed_stream_liq, self.tray_liq_stream[feed_tray + 1]
],
streams_out=[self.mixed_liq_feed],
name=name)
self.unit_dict[name] = self.feed_mixer
# create trays
self.trays = []
for i_tray in range(self.n_trays):
name = self.name + 'Tray' + str(i_tray)
if i_tray == self.feed_tray:
self.trays.append(
Tray(
liq_stream_in=self.mixed_liq_feed,
liq_stream_out=self.tray_liq_stream[i_tray],
vap_stream_in=self.tray_vap_stream[i_tray - 1],
vap_stream_out=self.tray_vap_stream[i_tray],
tray_efficiency=1, # will be updated later
pressure=self.pressure,
name=name))
elif i_tray == 0:
self.trays.append(
Tray(
liq_stream_in=self.tray_liq_stream[i_tray + 1],
liq_stream_out=self.tray_liq_stream[i_tray],
vap_stream_in=self.vapor_reboil,
vap_stream_out=self.tray_vap_stream[i_tray],
tray_efficiency=1, # will be updated later
pressure=self.pressure,
name=name))
elif i_tray == self.n_trays - 1:
self.trays.append(
Tray(
liq_stream_in=self.reflux,
liq_stream_out=self.tray_liq_stream[i_tray],
vap_stream_in=self.tray_vap_stream[i_tray - 1],
vap_stream_out=self.tray_vap_stream[i_tray],
tray_efficiency=1, # will be updated later
pressure=self.pressure,
name=name))
else:
self.trays.append(
Tray(
liq_stream_in=self.tray_liq_stream[i_tray + 1],
liq_stream_out=self.tray_liq_stream[i_tray],
vap_stream_in=self.tray_vap_stream[i_tray - 1],
vap_stream_out=self.tray_vap_stream[i_tray],
tray_efficiency=1, # will be updated later
pressure=self.pressure,
name=name))
self.update_tray_efficiency(tray_efficiency)
for s in self.tray_liq_stream:
self.unit_dict[s.name] = s
for s in self.tray_vap_stream:
self.unit_dict[s.name] = s
for s in self.trays:
self.unit_dict[s.name] = s
name = self.name + 'CondensateConnector'
self.condensate_connector = Connector(self.condensate,
self.tray_vap_stream[n_trays -
1],
name=name)
self.unit_dict[name] = self.condensate_connector
name = self.name + 'BottomsConnector'
self.bottoms_connector = Connector(self.bottoms,
self.tray_liq_stream[0],
name=name)
self.unit_dict[name] = self.bottoms_connector
from mixer import Mixer m = Mixer() m.init_all() m.calibrate_all() m.clean_gpio()
def main():
sessions = AudioUtilities.GetAllSessions
mixer = Mixer()
# SysTrayIcon menu items
menu_options = ()
# SysTrayIcon object
systray = SysTrayIcon(None,
"NK2Mixer",
menu_options,
on_quit=partial(exit_program, mixer))
# Start SysTray
systray.start()
# Map physical faders to Voicemeeter faders - mappings subject to personal preference
with voicemeeter.remote('banana', 0.0005) as vmr:
mixer.vb_map = {
4: vmr.inputs[3],
5: vmr.inputs[4],
6: vmr.inputs[1],
7: vmr.outputs[0]
}
for session in sessions():
if session.Process:
print(session.Process.name)
while mixer.running:
# Receive midi message (non-blocking)
msg = mixer.nk2_in.poll()
# If no message exists, end current loop
if not msg:
continue
# Check for select button press
if msg.control in mixer.select_range and msg.value:
group = mixer.groups[msg.control - mixer.select_fader_diff]
# If program is not bound bound
if not group.program:
# Get active program name
active_program = get_active_program()
# Find audio session with matching name
session = next(
(s for s in sessions()
if s.Process and s.Process.name() == active_program),
None)
# If audio session does not exist end current loop
if not session:
continue
# Assign session to control group
group.program = session
# Turn on select button light
mixer.enable_light(group.select)
# If program is muted turn on mute button light
if group.program.SimpleAudioVolume.GetMute():
mixer.enable_light(group.mute)
print(
f"{group.program.Process.name()} bound to fader {group.fader}"
)
else:
print(
f"{group.program.Process.name()} unbound from fader {group.fader}"
)
# Unassign session from fader
group.program = None
# Turn off select button light
mixer.disable_light(group.select)
# Turn off mute button light
mixer.disable_light(group.mute)
# Check for mute button press
elif msg.control in mixer.mute_range and msg.value and mixer.groups[
msg.control - mixer.mute_fader_diff].program:
group = mixer.groups[msg.control - mixer.mute_fader_diff]
# Check if program is muted
if group.program.SimpleAudioVolume.GetMute():
# Unmute program
group.program.SimpleAudioVolume.SetMute(0, None)
# Turn off mute button light
mixer.disable_light(group.mute)
print(
f"{group.program.Process.name()} unmuted (fader {group.fader})"
)
# If program is not muted
else:
# Mute program
group.program.SimpleAudioVolume.SetMute(1, None)
# Turn on mute button light
mixer.enable_light(group.mute)
print(
f"{group.program.Process.name()} muted (fader {group.fader})"
)
# Check for fader input
elif msg.control in mixer.fader_range:
group = mixer.groups[msg.control]
# If fader does not have assigned program end current loop
if not group.program:
continue
# Get volume control object from session
volume = group.program._ctl.QueryInterface(ISimpleAudioVolume)
# Convert midi value to percentage and set volume
volume.SetMasterVolume(msg.value / 127, None)
print(
f"{group.program.Process.name()} set to {volume.GetMasterVolume() * 100}%"
)
# Check for Voicemeeter fader input
elif msg.control in mixer.vb_fader_range:
# Map midi value (0-127) to VB appropriate gain value (-60-0)
level = ((127 - msg.value) / 127) * -60
# Set VB fader gain
mixer.vb_map[msg.control].gain = level
print(f"fader {msg.control} (VoiceMeeter) gain set to {level}")
elif msg.control in mixer.vb_mute_range and msg.value:
fader = msg.control - mixer.mute_fader_diff
control = mixer.vb_map[fader]
# ISSUE: inconsistent mute/unmute
if control.mute:
# Unmute VB control
control.mute = False
# Turn off mute button light
mixer.disable_light(msg.control)
print(f"fader {fader} (VoiceMeeter) unmuted")
else:
# Mute FB control
control.mute = True
# Turn on mute button light
mixer.enable_light(msg.control)
print(f"fader {fader} (VoiceMeeter) muted")
# After input is processed delete message to prevent unnecessary looping
msg = None
for handler in logging.root.handlers:
logging.root.removeHandler(handler)
logging.root.addHandler(customlog.MultiprocessingStreamHandler())
log = logging.getLogger(config.log_name)
log.info("Starting %s...", config.app_name)
track_queue = multiprocessing.Queue(1)
log.info("Initializing read queue to hold %2.2f seconds of audio.",
config.frontend_buffer)
v2_queue = BufferedReadQueue(
int(config.frontend_buffer / SECONDS_PER_FRAME))
info_queue = multiprocessing.Queue()
mixer = Mixer(iqueue=track_queue,
oqueues=(v2_queue.raw, ),
infoqueue=info_queue)
mixer.start()
if stream:
import brain
Hotswap(track_queue.put, brain).start()
Hotswap(InfoHandler.add, info, 'generate', info_queue, first_frame).start()
Hotswap(MonitorSocket.update,
statistician,
'generate',
lambda: StreamHandler.relays,
InfoHandler.stats,
mp3_queue=v2_queue).start()
tornado.ioloop.PeriodicCallback(
# Entry point of the program - initializes mixer and client # Also for basic settings from mixer import Mixer from client import Client # Settings for testing ''' url = "broker.mqttdashboard.com" topic = "haw/dmi/mt/its/ss17/ambientbox" user = "" pw = "" ''' # Settings for HAW url = "diginet.mt.haw-hamburg.de" topic = "ambientbox" user = "******" pw = "schuh+-0" # Mixer Settings loopThreshold = 10 # Sounds shorter than this (seconds) will not be looped nonstop but rather be played in intervals depending on the volume of the channel maxLoopLength = 30 # Short sounds (see above) may be repeated at least every amount of seconds this is set to mixer = Mixer(loopThreshold, maxLoopLength) Client(url, topic, user, pw, mixer)
def main():
global DISPLAYSURF, FPSCLOCK, FPS
pygame.init()
FPSCLOCK = pygame.time.Clock()
FPS = 60
pygame.key.set_repeat(int(1000 / FPS))
global XMARGIN, YMARGIN, BOXSIZE
width, height = pygame.display.Info().current_w, pygame.display.Info(
).current_h
maxHeight = int(0.8 * height)
maxWidth = int(1.5 * maxHeight)
XMARGIN = YMARGIN = 0
BOXSIZE = 16
maxBoxSize = int((maxWidth / 15))
for scale in range(2, 5):
if BOXSIZE * scale > maxBoxSize:
break
scale -= 1
scale = 3
BOXSIZE *= scale
windowWidth = 15 * BOXSIZE
windowHeight = 10 * BOXSIZE
DISPLAYSURF = pygame.display.set_mode((windowWidth, windowHeight))
pygame.display.set_caption('Map Test')
DISPLAYSURF.set_colorkey((255, 0, 255))
mixer = Mixer()
player = Player(scale,
party=[
get_pokemon(132, level=50),
random_pokemon(level=50),
random_pokemon(level=50)
])
# player = Player()
playerSprite = pygame.sprite.Group()
playerSprite.add(player)
startX = player.get_position()[0] - 7
endX = startX + 15
startY = player.get_position()[1] - 5
endY = startY + 11
mainMap = load_map_square('main_map_full_test')
mapSquare = mainMap.tiles
mapImages, mapDecorations = mainMap.new_screen_images_array(
player, tileSize=BOXSIZE)
mixer.play_song(mainMap.tiles[player.x][player.y].group)
global mapCoords
mapCoords = []
for x in range(len(mapSquare)):
column = []
for y in range(len(mapSquare)):
column.append((x, y))
mapCoords.append(column)
count = 0
maxCount = 4
running = True
lastKeys = None
change = True
while running:
offsetX, offsetY = 0, 0
count += 1
if count == maxCount:
count = 0
position = player.get_position()
move = (0, 0)
columns = mapCoords[startX:endX]
displayArea = [y[startY:endY] for y in columns]
for event in pygame.event.get():
if event.type == pygame.QUIT or (event.type == KEYUP
and event.key == K_ESCAPE):
running = False
elif event.type == KEYDOWN:
if event.key == K_SPACE:
interact(mainMap, player)
elif event.key in [K_UP, K_w]:
move = (0, -1)
elif event.key in [K_DOWN, K_s]:
move = (0, 1)
elif event.key in [K_LEFT, K_a]:
move = (-1, 0)
elif event.key in [K_RIGHT, K_d]:
move = (1, 0)
elif event.type == KEYUP:
if event.key == K_x:
player.toggle_run()
elif event.key == K_b:
player.toggle_bike()
change = True
elif event.key == K_v and mainMap.surfable(player):
player.toggle_surf()
move = player.facing
change = True
else:
pass
if move != (0, 0):
if mainMap.passable(player, move):
change = True
player.update(move)
do_move(mapImages, playerSprite, mapDecorations, player, move)
mapImages, mapDecorations = update_map(mainMap, mapImages,
mapDecorations, player,
move)
elif mainMap.jumpable(player, move):
change = True
move = tuple_add(move, move)
player.update(move)
do_jump(mapImages, playerSprite, mapDecorations, player, move)
mapImages, mapDecorations = update_map(mainMap, mapImages,
mapDecorations, player,
move)
else:
change = True
player.turn(move)
if mainMap.encounter_tile(player):
# print('encounter')
encounterPokemon = random_pokemon(level=50)
WildBattle(DISPLAYSURF, mixer, player, encounterPokemon)
# DISPLAYSURF.set_mode((windowWidth, windowHeight))
# keys = pygame.key.get_pressed()
# if keys[K_SPACE]:
# interact(mainMap, player)
# elif keys[K_UP] or keys[K_w]:
# move = (0, -1)
# elif keys[K_DOWN] or keys[K_s]:
# move = (0, 1)
# elif keys[K_LEFT] or keys[K_a]:
# move = (-1, 0)
# elif keys[K_RIGHT] or keys[K_d]:
# move = (1, 0)
# if move != (0, 0):
# if count == 0 and mainMap.passable(player, move):
# change = True
# offsetX = int(1*BOXSIZE/4) * move[0]
# offsetY = int(1*BOXSIZE/4) * move[1]
# elif count == 1 and mainMap.passable(player, move):
# change = True
# offsetX = int(2*BOXSIZE/4) * move[0]
# offsetY = int(2*BOXSIZE/4) * move[1]
# elif count == 2 and mainMap.passable(player, move):
# change = True
# offsetX = int(3*BOXSIZE/4) * move[0]
# offsetY = int(3*BOXSIZE/4) * move[1]
# elif count == 3 and mainMap.passable(player, move):
# change = True
# startX += move[0]
# endX += move[0]
# startY += move[1]
# endY += move[1]
# offsetX, offsetY = 0, 0
# player.update(move)
# mapImages = update_map(mainMap, mapImages, player, move)
# elif count == 3:
# change = True
# player.turn(move)
if change:
offsetX, offsetY = 0, 0
draw_screen(mapImages, playerSprite, mapDecorations,
(offsetX, offsetY))
pygame.display.update()
change = False
# print(mainMap.tiles[player.x][player.y].group)
if player.isBiking:
mixer.play_song('Cycling')
elif player.isSurfing:
mixer.play_song('Surfing')
else:
mixer.play_song(mainMap.tiles[player.x][player.y].group)
FPSCLOCK.tick(FPS)
# target_corners[7, :] = target_bbox[1]
# return target_bbox, target_corners
if __name__ == "__main__":
# dataset = GRASSNewDataset('D:\\CMPT 764\\chairs_dataset',3)
agg = Aggregator()
#mixer = Mixer('Chair', 5, ['172', '182', '178', '517', '197'])
#mixer = Mixer('Chair', 5, ['172', '173', '182', '178', '686'])
#mixer = Mixer('Chair', 5, ['178', '348', '456', '504', '518'])
#test_models: A = [197, 41103, 37574], B = [45075, 40015, 39696, 37658, 36193], C = [309, 1325, 3244, 36881, 37614, 40403, 42663, 37989, 3223, 41656]
#mixer = Mixer('Chair', 3, ['197', '41103', '37574'])
#mixer = Mixer('Chair', 5, ['45075', '40015', '39696', '37658', '36193'])
mixer = Mixer('Chair', 10, [
'309', '1325', '3244', '36881', '37614', '40403', '42663', '37989',
'3223', '41656'
])
#mixer.show_data_meshes()
# extractor = RandomizedExtractor(dataset)
mixer.show_data_meshes()
for i in range(15):
mixer.reset_target()
print("Starting for model number ", i)
mixer.mix_parts()
renderMeshFromParts_new(mixer.get_target_mesh().parts, i)
# for i in range(len(mixer.dataset)):
# # mesh = mixer.dataset[i]
