def __init__(self):
# jack client
self.client = jack.Client("palette", no_start_server=True)
# interface
entities = [
Entity.KEYBOARD, Entity.SAMPLER, Entity.DRUM_MACHINE, Entity.PUSH
]
self.display = Interface(entities)
# metronome
self.metronome = Metronome(self.display, self.client)
# backend
constructors = [Keyboard, Sampler, DrumMachine, Push]
self.be = Backend(self.client, self.metronome, constructors)
# misc
self.pressed_keys = []
self.fifo = open("palette.pipe", mode="rt")
self.current_inst_number = 0
# let's go
self.client.activate()
self.display.paint_pad(0)
self.metronome.sync_transport()
def __init__(self):
GObject.GObject.__init__(self)
brush_file = open('../brushes/classic/charcoal.myb')
brush_info = brush.BrushInfo(brush_file.read())
brush_info.set_color_rgb((0.0, 0.0, 0.0))
self.default_eraser = brush_info.get_base_value("eraser")
self.default_radius = brush_info.get_base_value("radius_logarithmic")
self.brush = brush.Brush(brush_info)
self.button_pressed = False
self.last_event = (0.0, 0.0, 0.0) # (x, y, time)
self.onionskin_on = True
self.onionskin_by_cels = True
self.onionskin_length = 3
self.onionskin_falloff = 0.5
self.eraser_on = False
self.force_add_cel = True
self.surface = None
self.surface_node = None
self.xsheet = XSheet(24 * 60)
self.xsheet.connect('frame-changed', self.xsheet_changed_cb)
self.xsheet.connect('layer-changed', self.xsheet_changed_cb)
self.metronome = Metronome(self.xsheet)
self.update_surface()
self.nodes = {}
self.create_graph()
self.init_ui()
def __init__(self, ui=None, track=None, width=None, height=None, x=0, y=0):
self.ui = ui
# Offset on left side, leaving space for timestamps
self.offset = len("00:00.000 ")
if self.ui != None:
logger.log("Using ui")
self.height, self.width = list(map(int, self.ui.size()))
self.width -= self.offset
else:
logger.log("Not using ui")
self.height, self.width = 10, 10
self.cursorY = self.height / 2
self.cursorX = 44
self.track = track
self.bpm = self.track.beatsPerMinute
self.tpb = self.track.ticksPerBeat
self.seconds = 60.0 / self.tpb / self.bpm
#Begin and end using real time
#self.length = self.track.getLengthInSec()
#self.begin = 0.0
#self.end = (self.height-1) * 60.0 / self.bpm
#self.step = 60.0 / self.bpm
#Begin and end using beats
self.length = self.track.getLengthInBeats()
self.begin = 0
self.end = self.height - 1
self.step = 1
logger.log("Track's length: %.2f beats" % self.length)
self.beats = []
for i in range(int(self.track.getLengthInBeats() + 1)):
self.beats.append([])
logger.log("width = %d" % self.width)
## Create display window
if self.width > KEYS:
displayWidth = KEYS + self.offset
else:
displayWidth = self.width + self.offset
MIN = (KEYS - self.width) / 2
MAX = (KEYS - self.width) / 2 + self.width
if self.ui != None:
self.display = self.ui.newWindow(self.height, displayWidth,
"display", x, y)
self.ui.setWindow(self.display)
## Connect to Piano
self.piano = Piano()
self.player = Player()
self.player.start()
self.player.setPiano(self.piano)
self.piano.autoconnect()
self.playing = False
## Create metronome
beatLength = 60.0 / self.bpm
self.metronome = Metronome(self.down, beatLength)
def __init__(self):
self._log = logging.getLogger('musicbox.MusicBox')
# Internal attributes
self._selected_stompbox = 1 # 0 = global parameters, 1-8 = actual stompboxes
self._current_mode = Mode.PRESET
self._last_slider_update_time = 0
# OSC inputs (footpedal)
try:
self._midi_to_osc = MidiToOsc(
'Arduino Micro') # works via callbacks, so not blocking
except ValueError as e:
self._log.error('Failed to start Midi Footpedal: ' + str(e))
# OSC server (receives inputs)
self._osc_server = FootpedalOscServer(self.cb_mode, self.cb_preset,
self.cb_stomp, self.cb_looper,
self.cb_metronome,
self.cb_slider)
# mod-host LV2 host (output)
self._banks_manager = BanksManager()
self._banks_manager.append(
Bank('Bank 1')) # TODO: load banks from stored files
self._modhost = ModHost('localhost')
self._modhost.connect()
self._banks_manager.register(self._modhost)
self._pedalboard = None
self._log.info("STARTED mod-host client")
# Metronome output (using klick)
self._metronome = Metronome()
self._log.info("STARTED Metronome")
# Looper object (using sooperlooper)
self._looper = Looper()
self._log.info("STARTED Looper")
# Notifiers
self._notifier = TcpNotifier()
self._log.info("STARTED TcpNotifier")
# Initialize: set mode PRESET and load preset1
time.sleep(2)
self._set_mode(Mode.PRESET)
for preset_id in range(4):
self._load_preset('preset{:02d}.yaml'.format(preset_id))
clock.display_channel = midi_h.channel
state.reset_buttons()
clock.sequencers[midi_h.channel].show_pattern()
async def knob_handler(clock):
# apply knob position to chan
knob_ctl_val = knob.get_knob_value()
if knob_ctl_val is not None:
midi_h.controller_change(state.knob_controller, knob_ctl_val)
cbs = [button_handler, knob_handler]
# knob interrupt handler
# set tempo to 160 beats-per-minute
tempo = 320
# create the metronome
metronome = Metronome(tempo=tempo, callbacks=cbs)
# produce the coroutine
metronome_coro = metronome.start()
# asyncio boilerplate to run the coroutine
bounce_count = 1
loop = asyncio.get_event_loop()
loop.run_until_complete(metronome_coro)
