aboutsummaryrefslogtreecommitdiffstats
path: root/solo-tool-project/src
diff options
context:
space:
mode:
Diffstat (limited to 'solo-tool-project/src')
-rw-r--r--solo-tool-project/src/solo_tool/external_volume.py31
-rw-r--r--solo-tool-project/src/solo_tool/handlers.py65
-rw-r--r--solo-tool-project/src/solo_tool/metronome.py78
-rw-r--r--solo-tool-project/src/solo_tool/midi_controller_actition.py47
-rw-r--r--solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py135
-rw-r--r--solo-tool-project/src/solo_tool/midi_wrapper_mido.py28
-rw-r--r--solo-tool-project/src/solo_tool/notifier.py4
-rw-r--r--solo-tool-project/src/solo_tool/player_mpv.py101
-rw-r--r--solo-tool-project/src/solo_tool/player_vlc.py55
-rw-r--r--solo-tool-project/src/solo_tool/recorder.py76
-rw-r--r--solo-tool-project/src/solo_tool/session_manager.py68
-rw-r--r--solo-tool-project/src/solo_tool/solo_tool.py109
-rw-r--r--solo-tool-project/src/solo_tool/storage.py99
-rw-r--r--solo-tool-project/src/solo_tool/utils.py7
14 files changed, 708 insertions, 195 deletions
diff --git a/solo-tool-project/src/solo_tool/external_volume.py b/solo-tool-project/src/solo_tool/external_volume.py
new file mode 100644
index 0000000..425351a
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/external_volume.py
@@ -0,0 +1,31 @@
+from pythonosc import udp_client
+
+class VolumeControllerXR18():
+ def __init__(self, ip: str):
+ port = 10024
+ self._client = udp_client.SimpleUDPClient(ip, port, timeout=1)
+ self._headphoneVolume = 0.0
+ self._speakerVolume = 0.0
+
+ def __del__(self):
+ self._client.close()
+
+ @property
+ def headphoneVolume(self) -> float:
+ return self._headphoneVolume
+
+ @headphoneVolume.setter
+ def headphoneVolume(self, new: float) -> None:
+ if new is not None:
+ self._headphoneVolume = min(max(new, 0.0), 1.0)
+ self._client.send_message("/config/solo/level", self._headphoneVolume)
+
+ @property
+ def speakerVolume(self) -> float:
+ return self._speakerVolume
+
+ @speakerVolume.setter
+ def speakerVolume(self, new: float) -> None:
+ if new is not None:
+ self._speakerVolume = min(max(new, 0.0), 1.0)
+ self._client.send_message("/lr/mix/fader", self._speakerVolume)
diff --git a/solo-tool-project/src/solo_tool/handlers.py b/solo-tool-project/src/solo_tool/handlers.py
index 13e982b..3beb0fb 100644
--- a/solo-tool-project/src/solo_tool/handlers.py
+++ b/solo-tool-project/src/solo_tool/handlers.py
@@ -2,7 +2,15 @@ from collections.abc import Callable
from solo_tool.solo_tool import SoloTool
-def changeSong(st: SoloTool, delta: int) -> Callable[[], None]:
+def playPause(st: SoloTool) -> Callable[[], None]:
+ def f():
+ if st.playing:
+ st.pause()
+ else:
+ st.play()
+ return f
+
+def songRelative(st: SoloTool, delta: int) -> Callable[[], None]:
def f():
if st.song is None:
st.song = 0
@@ -10,12 +18,67 @@ def changeSong(st: SoloTool, delta: int) -> Callable[[], None]:
st.song += delta
return f
+def restartOrPreviousSong(st: SoloTool, threshold: float) -> Callable[[], None]:
+ def f():
+ if st.position < threshold and st.song > 0:
+ st.song -= 1
+ else:
+ st.position = 0.0
+ return f
+
+def songAbsolute(st: SoloTool, index: int, followUp: Callable[[], None]=None) -> Callable[[], None]:
+ def f():
+ st.song = index
+ if followUp is not None:
+ followUp()
+ return f
+
def seekRelative(st: SoloTool, delta: float) -> Callable[[], None]:
def f():
st.position += delta
return f
+def seekAbsolute(st: SoloTool, new: float) -> Callable[[], None]:
+ def f():
+ st.position = new
+ return f
+
def positionToKeyPoint(st: SoloTool) -> Callable[[], None]:
def f():
st.keyPoint = st.position
return f
+
+def keyPointAbsolute(st: SoloTool, kp: float) -> Callable[[], None]:
+ def f():
+ st.keyPoint = kp
+ return f
+
+def keyPointRelative(st: SoloTool, delta: int) -> Callable[[], None]:
+ from bisect import bisect_right, bisect_left
+ def f():
+ l = sorted(set(st.keyPoints + [st.keyPoint]))
+ if delta > 0:
+ pivot = bisect_right(l, st.keyPoint) - 1
+ elif delta < 0:
+ pivot = bisect_left(l, st.keyPoint)
+ else:
+ return
+ new = max(min(pivot + delta, len(l) - 1), 0)
+ st.keyPoint = l[new]
+ return f
+
+def rateAbsolute(st: SoloTool, value: float) -> Callable[[], None]:
+ def f():
+ st.rate = value
+ return f
+
+def rateRelative(st: SoloTool, delta: float) -> Callable[[], None]:
+ def f():
+ st.rate += delta
+ return f
+
+def volumeAbsolute(st: SoloTool, value: float) -> Callable[[], None]:
+ def f():
+ st.volume = value
+ return f
+
diff --git a/solo-tool-project/src/solo_tool/metronome.py b/solo-tool-project/src/solo_tool/metronome.py
new file mode 100644
index 0000000..3ffc6bc
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/metronome.py
@@ -0,0 +1,78 @@
+import pyaudio as pa
+from array import array
+
+from solo_tool.utils import getAudioDeviceIndex
+
+def _createClickSample(clickFrequency: int, samplingRate: int) -> array:
+ clickDuration = 0.03 # seconds
+
+ sampleLength = int(clickDuration * samplingRate)
+ fadeSamples = 50
+ amplitude = 0.8
+ attackEnv = [(i/fadeSamples) * amplitude for i in range(1, fadeSamples, 1)]
+ releaseEnv = [(i/fadeSamples) * amplitude for i in range(fadeSamples, 0, -1)]
+ amplitudeEnv = attackEnv + [amplitude] * (sampleLength - len(attackEnv) - len(releaseEnv)) + releaseEnv
+ cycleLength = (1 / clickFrequency) * samplingRate
+
+ from math import sin, pi
+ return array('h', [int(sin(((i % cycleLength) / cycleLength) * 2 * pi) * amplitudeEnv[i] * 32767) for i in range(sampleLength)])
+
+def _createOutputBuffer(bpm: int, clickFrequency: int, samplingRate: int) -> array:
+ clickSample = _createClickSample(clickFrequency, samplingRate)
+ samplesPerBeat = int((60 / bpm) * samplingRate)
+ assert len(clickSample) <= samplesPerBeat
+ return clickSample + array('h', [0] * (samplesPerBeat - len(clickSample)))
+
+class Metronome:
+ def __init__(self, bufferSize: int, samplingRate: int, deviceName: str):
+ self._bufferSize = bufferSize
+ self._samplingRate = samplingRate
+ self._deviceName = deviceName
+ self._sampleFormat = pa.paInt16
+ self._channels = 1
+ self._pa = pa.PyAudio()
+ self._stream = None
+ self._bufferPointer = 0
+ self._outputBuffer = array('h')
+
+ def __del__(self):
+ if self.running:
+ self._stream.stop_stream()
+ self._stream.close()
+
+ def _callback(self, inData, frameCount, timeInfo, statusFlags):
+ leftover = len(self._outputBuffer) - self._bufferPointer
+ if frameCount > leftover:
+ outData = self._outputBuffer[self._bufferPointer:] + self._outputBuffer[0:frameCount - leftover]
+ self._bufferPointer = frameCount - leftover
+ else:
+ outData = self._outputBuffer[self._bufferPointer:self._bufferPointer + frameCount]
+ self._bufferPointer += frameCount
+ assert self._bufferPointer >= 0 and self._bufferPointer <= len(self._outputBuffer)
+ return (outData.tobytes(), pa.paContinue)
+
+ def start(self, bpm: int, clickFrequency: int) -> None:
+ if self.running:
+ return
+ self._bufferPointer = 0
+ self._outputBuffer = _createOutputBuffer(bpm, clickFrequency, self._samplingRate)
+ self._stream = self._pa.open(format=self._sampleFormat,
+ channels=self._channels,
+ rate=self._samplingRate,
+ frames_per_buffer=self._bufferSize,
+ output=True,
+ output_device_index=getAudioDeviceIndex(self._deviceName, self._pa),
+ stream_callback=self._callback)
+
+ def stop(self) -> None:
+ if not self.running:
+ return None
+
+ self._stream.stop_stream()
+ self._stream.close()
+ self._stream = None
+
+ @property
+ def running(self) -> bool:
+ return self._stream is not None
+
diff --git a/solo-tool-project/src/solo_tool/midi_controller_actition.py b/solo-tool-project/src/solo_tool/midi_controller_actition.py
new file mode 100644
index 0000000..19654ee
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/midi_controller_actition.py
@@ -0,0 +1,47 @@
+import mido
+from collections.abc import Callable
+
+from . import handlers
+from .solo_tool import SoloTool
+
+class ActitionController:
+ class _MidoMidiWrapper:
+ def __init__(self):
+ self._callback = None
+ port = "SoloTool Virtual MIDI Out"
+ try:
+ self._inPort = mido.open_input(port)
+ self._inPort.callback = self._midoCallback
+ except:
+ print(f"Failed to open {port} for Actition controller")
+
+ def setCallback(self, callback: Callable[[int, int], None]) -> None:
+ self._callback = callback
+
+ def _midoCallback(self, msg: mido.Message) -> None:
+ if msg.type != "control_change":
+ return
+ if self._callback:
+ self._callback(msg.control, msg.channel)
+
+ def __init__(self, midiWrapperOverride=None):
+ self._handlers = {}
+ if midiWrapperOverride:
+ self._midiWrapper = midiWrapperOverride
+ else:
+ self._midiWrapper = ActitionController._MidoMidiWrapper()
+ self._midiWrapper.setCallback(self._callback)
+
+ def _callback(self, control: int, channel: int) -> None:
+ if channel != 14:
+ return
+ if control in self._handlers:
+ self._handlers[control]()
+
+ def setSoloTool(self, soloTool: SoloTool) -> None:
+ self._handlers = {
+ 102: handlers.seekAbsolute(soloTool, 0.0),
+ 103: handlers.positionToKeyPoint(soloTool),
+ 104: soloTool.jump,
+ 105: handlers.playPause(soloTool)
+ }
diff --git a/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py b/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
index 3dc8ec6..e79b60c 100644
--- a/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
+++ b/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
@@ -1,7 +1,34 @@
-from .midi_wrapper_mido import MidiWrapper
+import mido
from . import handlers
+from .solo_tool import SoloTool
-class MidiController:
+class MidiWrapper:
+ def __init__(self):
+ self._inPort = None
+ self._outPort = None
+
+ def connect(self, deviceName, callback):
+ if self._inPort is None and self._outPort is None:
+ self._inPort = mido.open_input(deviceName)
+ self._inPort.callback = callback
+ self._outPort = mido.open_output(deviceName)
+
+ def disconnect(self):
+ if self._inPort is not None:
+ self._inPort.close()
+ self._inPort = None
+
+ if self._outPort is not None:
+ self._outPort.reset()
+ self._outPort.close()
+ self._outPort = None
+
+ def sendNoteOn(self, note, velocity, channel):
+ if self._outPort is not None:
+ msg = mido.Message("note_on", channel=channel, velocity=velocity, note=note)
+ self._outPort.send(msg)
+
+class LaunchpadMiniController:
DEVICE_NAME = "Launchpad Mini MIDI 1"
LIGHT_CONTROL_CHANNEL = 0
LED_GREEN = 124
@@ -18,7 +45,7 @@ class MidiController:
MAX_PLAYBACK_VOLUME = 1.2
PLAYBACK_VOLUME_STEP = 0.1
- def __init__(self, soloTool, midiWrapperOverride=None):
+ def __init__(self, soloTool: SoloTool, midiWrapperOverride=None):
self._soloTool = soloTool
if midiWrapperOverride is not None:
self._midiWrapper = midiWrapperOverride
@@ -32,36 +59,36 @@ class MidiController:
def _registerHandlers(self):
self._handlers = {
- 96 : self._soloTool.stop,
+ 96 : handlers.seekAbsolute(self._soloTool, 0.0),
114 : self._soloTool.jump,
- 112 : self._playPause,
- #118 : self._soloTool.previousStoredAbLimits,
- #119 : self._soloTool.nextStoredAbLimits,
+ 112 : handlers.playPause(self._soloTool),
+ 118 : handlers.keyPointRelative(self._soloTool, -1),
+ 119 : handlers.keyPointRelative(self._soloTool, 1),
117 : handlers.positionToKeyPoint(self._soloTool),
- 48 : handlers.changeSong(self._soloTool, -1),
+ 48 : handlers.songRelative(self._soloTool, -1),
49 : handlers.seekRelative(self._soloTool, -0.25),
50 : handlers.seekRelative(self._soloTool, -0.05),
51 : handlers.seekRelative(self._soloTool, -0.01),
52 : handlers.seekRelative(self._soloTool, 0.01),
53 : handlers.seekRelative(self._soloTool, 0.05),
54 : handlers.seekRelative(self._soloTool, 0.25),
- 55 : handlers.changeSong(self._soloTool, 1),
+ 55 : handlers.songRelative(self._soloTool, 1),
}
for i in range(0, 8):
- volume = round(MidiController.MIN_PLAYBACK_VOLUME + MidiController.PLAYBACK_VOLUME_STEP * i, 1)
- self._handlers[i] = self._createSetPlaybackVolumeCallback(volume)
+ volume = round(LaunchpadMiniController.MIN_PLAYBACK_VOLUME + LaunchpadMiniController.PLAYBACK_VOLUME_STEP * i, 1)
+ self._handlers[i] = handlers.volumeAbsolute(self._soloTool, volume)
for i, button in enumerate(range(16, 24)):
- rate = round(MidiController.MIN_PLAYBACK_RATE + MidiController.PLAYBACK_RATE_STEP * i, 1)
- self._handlers[button] = self._createSetPlaybackRateCallback(rate)
+ rate = round(LaunchpadMiniController.MIN_PLAYBACK_RATE + LaunchpadMiniController.PLAYBACK_RATE_STEP * i, 1)
+ self._handlers[button] = handlers.rateAbsolute(self._soloTool, rate)
def connect(self):
- self._midiWrapper.connect(MidiController.DEVICE_NAME, self._callback)
+ self._midiWrapper.connect(LaunchpadMiniController.DEVICE_NAME, self._callback)
self._initialiseButtonLEDs()
def disconnect(self):
- self._allLEDsOff()
+ self._setAllLEDs(LaunchpadMiniController.LED_OFF)
self._midiWrapper.disconnect()
def _callback(self, msg):
@@ -71,61 +98,39 @@ class MidiController:
if msg.note in self._handlers:
handler = self._handlers[msg.note]()
- def _playPause(self):
- if self._soloTool.isPlaying():
- self._soloTool.pause()
- else:
- self._soloTool.play()
-
def _updatePlayPauseButton(self, playing):
if playing:
- self._setButtonLED(7, 0, MidiController.LED_GREEN)
- else:
- self._setButtonLED(7, 0, MidiController.LED_YELLOW)
-
- def _updateToggleAbLimitEnableButton(self, enabled):
- if enabled:
- self._setButtonLED(6, 2, MidiController.LED_GREEN)
+ self._setButtonLED(7, 0, LaunchpadMiniController.LED_GREEN)
else:
- self._setButtonLED(6, 2, MidiController.LED_RED)
+ self._setButtonLED(7, 0, LaunchpadMiniController.LED_YELLOW)
def _updateVolumeRow(self, volume):
- t1 = int(round(volume / MidiController.PLAYBACK_VOLUME_STEP, 1))
- t2 = int(round(MidiController.MIN_PLAYBACK_VOLUME / MidiController.PLAYBACK_VOLUME_STEP, 1))
+ t1 = int(round(volume / LaunchpadMiniController.PLAYBACK_VOLUME_STEP, 1))
+ t2 = int(round(LaunchpadMiniController.MIN_PLAYBACK_VOLUME / LaunchpadMiniController.PLAYBACK_VOLUME_STEP, 1))
lastColumnLit = t1 - t2 + 1
- self._lightRowUntilColumn(0, lastColumnLit, MidiController.LED_GREEN)
+ self._lightRowUntilColumn(0, lastColumnLit, LaunchpadMiniController.LED_GREEN)
def _updateRateRow(self, rate):
- t1 = int(round(rate / MidiController.PLAYBACK_RATE_STEP, 1))
- t2 = int(round(MidiController.MIN_PLAYBACK_RATE / MidiController.PLAYBACK_RATE_STEP, 1))
+ t1 = int(round(rate / LaunchpadMiniController.PLAYBACK_RATE_STEP, 1))
+ t2 = int(round(LaunchpadMiniController.MIN_PLAYBACK_RATE / LaunchpadMiniController.PLAYBACK_RATE_STEP, 1))
lastColumnLit = t1 - t2 + 1
- self._lightRowUntilColumn(1, lastColumnLit, MidiController.LED_YELLOW)
-
- def _createSetPlaybackRateCallback(self, rate):
- def f():
- self._soloTool.rate = rate
- return f
-
- def _createSetPlaybackVolumeCallback(self, volume):
- def f():
- self._soloTool.volume = volume
- return f
+ self._lightRowUntilColumn(1, lastColumnLit, LaunchpadMiniController.LED_YELLOW)
def _setButtonLED(self, row, col, colour):
- self._midiWrapper.sendMessage(MidiController.BUTTON_MATRIX[row][col], colour, MidiController.LIGHT_CONTROL_CHANNEL)
+ self._midiWrapper.sendNoteOn(LaunchpadMiniController.BUTTON_MATRIX[row][col], colour, LaunchpadMiniController.LIGHT_CONTROL_CHANNEL)
def _lightRowUntilColumn(self, row, column, litColour):
- colours = [litColour] * column + [MidiController.LED_OFF] * (8 - column)
+ colours = [litColour] * column + [LaunchpadMiniController.LED_OFF] * (8 - column)
for col in range(0, 8):
self._setButtonLED(row, col, colours[col])
- def _allLEDsOff(self):
+ def _setAllLEDs(self, colour):
for row in range(0, 8):
for col in range(0, 8):
- self._setButtonLED(row, col, MidiController.LED_OFF)
+ self._setButtonLED(row, col, colour)
def _initialiseButtonLEDs(self):
- self._allLEDsOff()
+ self._setAllLEDs(LaunchpadMiniController.LED_OFF)
# volume buttons
self._updateVolumeRow(self._soloTool.volume)
@@ -134,22 +139,22 @@ class MidiController:
self._updateRateRow(self._soloTool.rate)
# playback control
- self._setButtonLED(6, 0, MidiController.LED_RED)
- self._updatePlayPauseButton(self._soloTool.isPlaying())
+ self._setButtonLED(6, 0, LaunchpadMiniController.LED_YELLOW)
+ self._updatePlayPauseButton(self._soloTool.playing)
- # AB control
- self._setButtonLED(7, 2, MidiController.LED_YELLOW)
- self._setButtonLED(7, 6, MidiController.LED_RED)
- self._setButtonLED(7, 7, MidiController.LED_GREEN)
- self._setButtonLED(7, 5, MidiController.LED_YELLOW)
+ # Key point control
+ self._setButtonLED(7, 2, LaunchpadMiniController.LED_YELLOW)
+ self._setButtonLED(7, 6, LaunchpadMiniController.LED_RED)
+ self._setButtonLED(7, 7, LaunchpadMiniController.LED_GREEN)
+ self._setButtonLED(7, 5, LaunchpadMiniController.LED_YELLOW)
# Song control
- self._setButtonLED(3, 0, MidiController.LED_RED)
- self._setButtonLED(3, 1, MidiController.LED_RED)
- self._setButtonLED(3, 2, MidiController.LED_RED)
- self._setButtonLED(3, 3, MidiController.LED_RED)
- self._setButtonLED(3, 4, MidiController.LED_GREEN)
- self._setButtonLED(3, 5, MidiController.LED_GREEN)
- self._setButtonLED(3, 6, MidiController.LED_GREEN)
- self._setButtonLED(3, 7, MidiController.LED_GREEN)
+ self._setButtonLED(3, 0, LaunchpadMiniController.LED_RED)
+ self._setButtonLED(3, 1, LaunchpadMiniController.LED_RED)
+ self._setButtonLED(3, 2, LaunchpadMiniController.LED_RED)
+ self._setButtonLED(3, 3, LaunchpadMiniController.LED_RED)
+ self._setButtonLED(3, 4, LaunchpadMiniController.LED_GREEN)
+ self._setButtonLED(3, 5, LaunchpadMiniController.LED_GREEN)
+ self._setButtonLED(3, 6, LaunchpadMiniController.LED_GREEN)
+ self._setButtonLED(3, 7, LaunchpadMiniController.LED_GREEN)
diff --git a/solo-tool-project/src/solo_tool/midi_wrapper_mido.py b/solo-tool-project/src/solo_tool/midi_wrapper_mido.py
deleted file mode 100644
index 34f1031..0000000
--- a/solo-tool-project/src/solo_tool/midi_wrapper_mido.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import mido
-
-class MidiWrapper:
- def __init__(self):
- self._inPort = None
- self._outPort = None
-
- def connect(self, deviceName, callback):
- if self._inPort is None and self._outPort is None:
- self._inPort = mido.open_input(deviceName)
- self._inPort.callback = callback
- self._outPort = mido.open_output(deviceName)
-
- def disconnect(self):
- if self._inPort is not None:
- self._inPort.close()
- self._inPort = None
-
- if self._outPort is not None:
- self._outPort.reset()
- self._outPort.close()
- self._outPort = None
-
- def sendMessage(self, note, velocity, channel):
- if self._outPort is not None:
- msg = mido.Message('note_on', channel=channel, velocity=velocity, note=note)
- self._outPort.send(msg)
-
diff --git a/solo-tool-project/src/solo_tool/notifier.py b/solo-tool-project/src/solo_tool/notifier.py
index 73b84b7..5b3539c 100644
--- a/solo-tool-project/src/solo_tool/notifier.py
+++ b/solo-tool-project/src/solo_tool/notifier.py
@@ -3,7 +3,9 @@ class Notifier:
PLAYBACK_VOLUME_EVENT = 1
PLAYBACK_RATE_EVENT = 2
CURRENT_SONG_EVENT = 3
- CURRENT_KEY_POINT_EVENT = 3
+ SONG_LIST_EVENT = 4
+ CURRENT_KEY_POINT_EVENT = 5
+ KEY_POINT_LIST_EVENT = 6
def __init__(self, player):
self._callbacks = dict()
diff --git a/solo-tool-project/src/solo_tool/player_mpv.py b/solo-tool-project/src/solo_tool/player_mpv.py
new file mode 100644
index 0000000..77e0651
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/player_mpv.py
@@ -0,0 +1,101 @@
+import mpv
+
+def _complexGraph(tracks):
+ graph = ""
+ for i, enabled in tracks.items():
+ graph += f"[aid{i}]volume={"1.0" if enabled else "0.0"}[a{i}];"
+ graph += "[a1][a2][a3][a4][a5][a6]amix=inputs=6:"
+ graph += "duration=longest:normalize=0[ao]"
+ return graph
+
+def _simpleGraph():
+ return (
+ "[aid1]volume=1.0[a1];"
+ "[a1]amix=inputs=1:"
+ "duration=longest:normalize=1[ao]"
+ )
+
+class Player:
+ VOCAL_TRACK = 1
+ GUITAR_TRACK = 2
+ BASS_TRACK = 3
+ PIANO_TRACK =4
+ DRUM_TRACK = 5
+ OTHER_TRACK = 6
+
+ def __init__(self):
+ self._player = mpv.MPV(ao="jack")
+ self._player.loop = "inf"
+ self._player.lavfi_complex = _simpleGraph()
+ self._playingStateCallback = self._dummyCallback
+ self._volumeCallback = self._dummyCallback
+ self._player.observe_property("pause", lambda name, value: self._playingStateCallback())
+ self._player.observe_property("volume", lambda name, value: self._volumeCallback())
+ self._player.observe_property("track-list/count", lambda name, value: self._updateGraph())
+ self._tracks = {
+ self.VOCAL_TRACK: True,
+ self.GUITAR_TRACK: True,
+ self.BASS_TRACK: True,
+ self.PIANO_TRACK: True,
+ self.DRUM_TRACK: True,
+ self.OTHER_TRACK: True
+ }
+
+ def __del__(self):
+ self._player.close()
+
+ def _dummyCallback(self):
+ pass
+
+ def _updateGraph(self):
+ if self.tracksSupported():
+ self._player.lavfi_complex = _complexGraph(self._tracks)
+ else:
+ self._player.lavfi_complex = _simpleGraph()
+
+ def play(self):
+ self._player.pause = False
+
+ def pause(self):
+ self._player.pause = True
+
+ def isPlaying(self):
+ return not self._player.pause
+
+ def setPlaybackRate(self, rate):
+ self._player.speed = rate
+
+ def getPlaybackRate(self):
+ return self._player.speed
+
+ def setPlaybackPosition(self, position):
+ self._player.percent_pos = position * 100
+
+ def getPlaybackPosition(self):
+ return float(self._player.percent_pos or 0.0) / 100.0
+
+ def setPlaybackVolume(self, volume):
+ self._player.volume = int(volume * 100)
+
+ def getPlaybackVolume(self):
+ return float(self._player.volume) / 100.0
+
+ def setCurrentSong(self, path):
+ self.pause()
+ self._player.play(str(path))
+
+ def setPlayingStateChangedCallback(self, callback):
+ self._playingStateCallback = callback
+
+ def setPlaybackVolumeChangedCallback(self, callback):
+ self._volumeCallback = callback
+
+ def tracksSupported(self):
+ return len(self._player.track_list) == 6
+
+ def trackEnabled(self, trackId):
+ return self._tracks[trackId]
+
+ def setTrackEnabled(self, trackId, enable):
+ self._tracks[trackId] = enable
+ self._updateGraph()
diff --git a/solo-tool-project/src/solo_tool/player_vlc.py b/solo-tool-project/src/solo_tool/player_vlc.py
deleted file mode 100644
index 283102e..0000000
--- a/solo-tool-project/src/solo_tool/player_vlc.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import vlc
-
-class Player:
- def __init__(self):
- self._player = vlc.MediaPlayer()
-
- def play(self):
- self._player.play()
-
- def stop(self):
- self._player.stop()
-
- def pause(self):
- self._player.pause()
-
- def isPlaying(self):
- playing = self._player.is_playing() == 1
- return playing
-
- def setPlaybackRate(self, rate):
- self._player.set_rate(rate)
-
- def getPlaybackRate(self):
- return self._player.get_rate()
-
- def setPlaybackPosition(self, position):
- self._player.set_position(position)
-
- def getPlaybackPosition(self):
- return self._player.get_position()
-
- def setPlaybackVolume(self, volume):
- self._player.audio_set_volume(int(volume * 100))
-
- def getPlaybackVolume(self):
- return self._player.audio_get_volume() / 100.0
-
- def setCurrentSong(self, path):
- self._player.stop()
- media = vlc.Media(path)
- self._player.set_media(media)
-
- def setPlayingStateChangedCallback(self, callback):
- events = [
- vlc.EventType.MediaPlayerStopped,
- vlc.EventType.MediaPlayerPlaying,
- vlc.EventType.MediaPlayerPaused
- ]
- manager = self._player.event_manager()
- for e in events:
- manager.event_attach(e, callback)
-
- def setPlaybackVolumeChangedCallback(self, callback):
- manager = self._player.event_manager()
- manager.event_attach(vlc.EventType.MediaPlayerAudioVolume, callback)
diff --git a/solo-tool-project/src/solo_tool/recorder.py b/solo-tool-project/src/solo_tool/recorder.py
new file mode 100644
index 0000000..c628832
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/recorder.py
@@ -0,0 +1,76 @@
+from pathlib import Path
+
+import pyaudio as pa
+from pydub import AudioSegment, effects
+
+from solo_tool.utils import getAudioDeviceIndex
+
+class Recording:
+ def __init__(self, frames: list, channels: int, samplingRate: int, sampleFormat: int):
+ self._segment = AudioSegment(
+ data=b''.join(frames),
+ sample_width=sampleFormat,
+ frame_rate=samplingRate,
+ channels=channels
+ )
+ self._postProcess()
+
+ def _postProcess(self) -> None:
+ self._segment = effects.normalize(self._segment)
+
+ def writeWav(self, file: Path) -> None:
+ self._segment.export(str(file), format="wav")
+
+ def writeMp3(self, file: Path) -> None:
+ self._segment.export(str(file), format="mp3", bitrate="320k")
+
+class Recorder:
+ def __init__(self, bufferSize: int, samplingRate: int, deviceName: str):
+ self._bufferSize = bufferSize
+ self._samplingRate = samplingRate
+ self._deviceName = deviceName
+ self._sampleFormat = pa.paInt16
+ self._channels = 2
+ self._pa = pa.PyAudio()
+ self._stream = None
+ self._frames = []
+
+ def __del__(self):
+ if self.recording:
+ self._stream.stop_stream()
+ self._stream.close()
+
+ def _callback(self, inData, frameCount, timeInfo, statusFlags):
+ if statusFlags != pa.paNoError and statusFlags != pa.paInputOverflowed:
+ print(f"Recorder callback got status {hex(statusFlags)}, aborting")
+ # TODO figure out what status code is being received and if it's a problem or not
+ #return (None, pa.paAbort)
+
+ self._frames.append(inData)
+ return (None, pa.paContinue)
+
+ def startRecording(self) -> None:
+ if self.recording:
+ return
+
+ self._frames.clear()
+ self._stream = self._pa.open(format=self._sampleFormat,
+ channels=self._channels,
+ rate=self._samplingRate,
+ frames_per_buffer=self._bufferSize,
+ input=True,
+ input_device_index=getAudioDeviceIndex(self._deviceName, self._pa),
+ stream_callback=self._callback)
+
+ def stopRecording(self) -> Recording:
+ if not self.recording:
+ return None
+ self._stream.stop_stream()
+ self._stream.close()
+ self._stream = None
+ return Recording(self._frames, self._channels, self._samplingRate, self._pa.get_sample_size(self._sampleFormat))
+
+ @property
+ def recording(self) -> bool:
+ return self._stream is not None
+
diff --git a/solo-tool-project/src/solo_tool/session_manager.py b/solo-tool-project/src/solo_tool/session_manager.py
index 9744b57..96b100a 100644
--- a/solo-tool-project/src/solo_tool/session_manager.py
+++ b/solo-tool-project/src/solo_tool/session_manager.py
@@ -1,30 +1,52 @@
-import json
+from pathlib import Path
+
from . import SoloTool
+from .storage import FileSystemStorageBackend, FileBrowserStorageBackend
+
+class SessionManager():
+ def __init__(self, sessionPath: str):
+ self._sessionPath = sessionPath
-def loadSession(file: str) -> SoloTool:
- with open(file, "r") as f:
- session = json.load(f)
+ from re import search
+ match = search(r"^([a-z0-9]+://)", sessionPath)
+ if not match or match.group(0) == "file://":
+ self._backend = FileSystemStorageBackend(sessionPath)
+ elif match.group(0) in ["http://", "https://"]:
+ self._backend = FileBrowserStorageBackend(sessionPath)
+ else:
+ raise ValueError(f"Unsupported session path: {sessionPath}")
- st = SoloTool()
+ def getSessions(self) -> list[str]:
+ return self._backend.listSessions()
- for i, entry in enumerate(session):
- songPath = entry["path"]
- keyPoints = entry["key_points"]
+ def getSongs(self) -> list[str]:
+ return self._backend.listSongs()
- st.addSong(songPath)
- st._keyPoints[i] = keyPoints
+ def loadSession(self, id: str, player=None) -> SoloTool:
+ session = self._backend.readSession(id)
- return st
+ st = SoloTool(player=player)
+ for i, entry in enumerate(session):
+ songPath = entry["path"]
+ keyPoints = entry.get("key_points", [])
+ volume = entry.get("vol", 1.0)
+
+ st.addSong(songPath, keyPoints=keyPoints, volume=volume)
-def saveSession(soloTool: SoloTool, file: str) -> None:
- session = []
-
- for i, song in enumerate(soloTool.songs):
- entry = {
- "path": song,
- "key_points" : soloTool._keyPoints[i]
- }
- session.append(entry)
-
- with open(file, "w") as f:
- json.dump(session, f)
+ return st
+
+ def saveSession(self, soloTool: SoloTool, id: str) -> None:
+ session = []
+
+ for i, song in enumerate(soloTool.songs):
+ entry = {
+ "path": song,
+ "key_points" : soloTool._keyPoints[i],
+ "vol" : soloTool._volumes[i]
+ }
+ session.append(entry)
+
+ self._backend.writeSession(session, id)
+
+ def saveRecording(self, recording: Path, destination: str) -> None:
+ self._backend.writeRecording(recording, destination)
diff --git a/solo-tool-project/src/solo_tool/solo_tool.py b/solo-tool-project/src/solo_tool/solo_tool.py
index 147a7b9..591d303 100644
--- a/solo-tool-project/src/solo_tool/solo_tool.py
+++ b/solo-tool-project/src/solo_tool/solo_tool.py
@@ -1,23 +1,62 @@
import os
from .notifier import Notifier
-from .player_vlc import Player
+from .player_mpv import Player
class SoloTool:
- def __init__(self, playerOverride=None):
- self._player = Player() if playerOverride is None else playerOverride
+ def __init__(self, player=None):
+ self._player = Player() if player is None else player
self._notifier = Notifier(self._player)
self._songs = []
self._song = None
self._keyPoints = []
self._keyPoint = None
+ self._volumes = []
+ self._adHoc = False
+
+ tracks = [
+ ("vocalTrackEnabled", self._player.VOCAL_TRACK),
+ ("guitarTrackEnabled", self._player.GUITAR_TRACK),
+ ("bassTrackEnabled", self._player.BASS_TRACK),
+ ("pianoTrackEnabled", self._player.PIANO_TRACK),
+ ("drumTrackEnabled", self._player.DRUM_TRACK),
+ ("otherTrackEnabled", self._player.OTHER_TRACK)
+ ]
+ for trackName, trackId in tracks:
+ if not hasattr(type(self), trackName):
+ setattr(type(self), trackName, self._makeTrackProperty(trackId))
+
+ @staticmethod
+ def _makeTrackProperty(trackId: int) -> property:
+ def getter(self) -> bool:
+ return self._player.trackEnabled(trackId)
+
+ def setter(self, new: bool) -> None:
+ if new is not None and new != self._player.trackEnabled(trackId):
+ self._player.setTrackEnabled(trackId, new)
+
+ return property(getter, setter)
+
+ def __del__(self):
+ del self._player
def _updateSong(self, index):
+ previousSong = self._song
+ self._adHoc = False
self._song = index
- path = self._songs[index]
- self._player.setCurrentSong(path)
+ self._player.pause()
+ self._player.setCurrentSong(self._songs[index])
self._notifier.notify(Notifier.CURRENT_SONG_EVENT, index)
- self._keyPoint = 0.0
+
+ previousKp = self._keyPoint
+ self._keyPoint = self.keyPoints[0] if len(self.keyPoints) > 0 else 0.0
+ if previousKp != self._keyPoint:
+ self._notifier.notify(Notifier.CURRENT_KEY_POINT_EVENT, self._keyPoint)
+
+ if previousSong is None or self._keyPoints[previousSong] != self._keyPoints[index]:
+ self._notifier.notify(Notifier.KEY_POINT_LIST_EVENT, self.keyPoints)
+
+ self.volume = self._volumes[index]
@staticmethod
def _keyPointValid(kp: float) -> bool:
@@ -27,11 +66,15 @@ class SoloTool:
def songs(self) -> list[str]:
return self._songs.copy()
- def addSong(self, path: str) -> None:
- if not os.path.isfile(path):
- raise FileNotFoundError()
+ def addSong(self, path: str, keyPoints: list[float]=[], volume: float=1.0) -> None:
+ if path in self._songs:
+ return
self._songs.append(path)
- self._keyPoints.append([])
+ self._keyPoints.append(keyPoints)
+ self._volumes.append(volume)
+ self._notifier.notify(Notifier.SONG_LIST_EVENT, self.songs)
+ if self.song is None:
+ self.song = 0
@property
def song(self) -> int:
@@ -49,17 +92,18 @@ class SoloTool:
def keyPoints(self) -> list[float]:
if self._song is None:
return None
- return self._keyPoints[self._song]
+ return self._keyPoints[self._song].copy()
@keyPoints.setter
def keyPoints(self, new: list[float]) -> None:
if new is not None and self._song is not None:
sanitized = sorted(list(set([p for p in new if SoloTool._keyPointValid(p)])))
- self._keyPoints[self._song] = sanitized
+ self._keyPoints[self._song] = sanitized.copy()
+ self._notifier.notify(Notifier.KEY_POINT_LIST_EVENT, self.keyPoints)
@property
def keyPoint(self) -> float:
- return self._keyPoint
+ return float(self._keyPoint) if self._keyPoint is not None else None
@keyPoint.setter
def keyPoint(self, new: float) -> None:
@@ -73,10 +117,8 @@ class SoloTool:
def pause(self):
self._player.pause()
- def stop(self):
- self._player.stop()
-
- def isPlaying(self):
+ @property
+ def playing(self) -> bool:
return self._player.isPlaying()
def jump(self):
@@ -99,6 +141,8 @@ class SoloTool:
@volume.setter
def volume(self, new: float) -> None:
if new is not None and new >= 0.0 and new != self._player.getPlaybackVolume():
+ if self._song is not None:
+ self._volumes[self._song] = new
self._player.setPlaybackVolume(new)
self._notifier.notify(Notifier.PLAYBACK_VOLUME_EVENT, new)
@@ -108,10 +152,21 @@ class SoloTool:
@position.setter
def position(self, new: float) -> None:
- # TODO stop playback before changing position?
if new is not None and new != self._player.getPlaybackPosition():
self._player.setPlaybackPosition(min(max(0.0, new), 1.0))
+ def registerSongSelectionCallback(self, callback):
+ self._notifier.registerCallback(Notifier.CURRENT_SONG_EVENT, callback)
+
+ def registerSongListCallback(self, callback):
+ self._notifier.registerCallback(Notifier.SONG_LIST_EVENT, callback)
+
+ def registerKeyPointSelectionCallback(self, callback):
+ self._notifier.registerCallback(Notifier.CURRENT_KEY_POINT_EVENT, callback)
+
+ def registerKeyPointListCallback(self, callback):
+ self._notifier.registerCallback(Notifier.KEY_POINT_LIST_EVENT, callback)
+
def registerPlayingStateCallback(self, callback):
self._notifier.registerCallback(Notifier.PLAYING_STATE_EVENT, callback)
@@ -121,9 +176,19 @@ class SoloTool:
def registerRateCallback(self, callback):
self._notifier.registerCallback(Notifier.PLAYBACK_RATE_EVENT, callback)
- def registerCurrentSongCallback(self, callback):
- self._notifier.registerCallback(Notifier.CURRENT_SONG_EVENT, callback)
+ def playAdHoc(self, file) -> None:
+ self._adHoc = True
+ self._player.setCurrentSong(file)
- def registerCurrentKeyPointCallback(self, callback):
- self._notifier.registerCallback(Notifier.CURRENT_KEY_POINT_EVENT, callback)
+ def backToNormal(self) -> None:
+ self._adHoc = False
+ self._player.setCurrentSong(self._songs[self._song])
+
+ @property
+ def playingAdHoc(self) -> bool:
+ return self._adHoc
+
+ @property
+ def tracksSupported(self) -> bool:
+ return self._player.tracksSupported()
diff --git a/solo-tool-project/src/solo_tool/storage.py b/solo-tool-project/src/solo_tool/storage.py
new file mode 100644
index 0000000..d07ba25
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/storage.py
@@ -0,0 +1,99 @@
+from typing import Protocol
+from abc import abstractmethod
+
+from pathlib import Path
+from glob import glob
+import json
+import requests
+from os import getenv
+
+class StorageBackend(Protocol):
+ @abstractmethod
+ def listSessions(self) -> list[str]:
+ raise NotImplementedError
+
+ @abstractmethod
+ def readSession(self, id: str) -> dict:
+ raise NotImplementedError
+
+ @abstractmethod
+ def writeSession(self, session: dict, id: str) -> None:
+ raise NotImplementedError
+
+ @abstractmethod
+ def writeRecording(self, recording: Path, destination: str) -> None:
+ raise NotImplementedError
+
+ @abstractmethod
+ def listSongs(self) -> list[str]:
+ raise NotImplementedError
+
+class FileSystemStorageBackend(StorageBackend):
+ def __init__(self, storagePath: str):
+ self._storagePath = Path(storagePath)
+
+ def listSessions(self) -> list[str]:
+ return [Path(f).stem for f in glob(str(self._storagePath / "sessions" / "*.json"))]
+
+ def readSession(self, id: str) -> dict:
+ with open(self._storagePath / "sessions" / f"{id}.json", "r") as f:
+ session = json.load(f)
+ return session
+
+ def writeSession(self, session: dict, id: str) -> None:
+ with open(self._storagePath / "sessions" / f"{id}.json", "w") as f:
+ json.dump(session, f)
+
+ def writeRecording(self, recording: Path, destination: str) -> None:
+ pass
+
+ def listSongs(self) -> list[str]:
+ return [str(Path(f).absolute()) for f in glob(str(self._storagePath / "songs" / "*"))]
+
+class FileBrowserStorageBackend(StorageBackend):
+ def __init__(self, serverUrl: str):
+ self._baseUrl = serverUrl
+ self._username = getenv("ST_USER")
+ self._password = getenv("ST_PASS")
+ self._apiKey = self._getApiKey()
+ self._publicUrl = "https://files.0xf7.com/api/public/dl/NR1j-os8/solo-tool"
+
+ def listSessions(self) -> list[str]:
+ url = f"{self._baseUrl}/api/resources/sessions"
+ response = self._request("GET", url)
+ return [item["name"][0:-5] for item in response.json()["items"] if item["extension"] == ".json"]
+
+ def readSession(self, id: str) -> dict:
+ url = f"{self._baseUrl}/api/raw/sessions/{id}.json"
+ response = self._request("GET", url)
+ return json.loads(response.content)
+
+ def writeSession(self, session: dict, id: str) -> None:
+ url = f"{self._baseUrl}/api/resources/sessions/{id}.json"
+ self._request("PUT", url, json=session)
+
+ def writeRecording(self, recording: Path, destination: str) -> None:
+ url = f"{self._baseUrl}/api/resources/recordings/{destination}"
+ with open(recording, "rb") as file:
+ self._request("POST", url, {"Content-Type" : "audio/mpeg"}, data=file)
+
+ def listSongs(self) -> list[str]:
+ url = f"{self._baseUrl}/api/resources/songs"
+ response = self._request("GET", url)
+ return [f"{self._publicUrl}{item["path"]}" for item in response.json()["items"]]
+
+ def _getApiKey(self) -> str:
+ response = requests.post(f"{self._baseUrl}/api/login", json={"username":self._username, "password":self._password})
+ return response.content
+
+ def _request(self, verb: str, url: str, moreHeaders: dict={}, **kwargs):
+ headers = moreHeaders | {"X-Auth" : self._apiKey}
+ response = requests.request(verb, url, headers=headers, **kwargs)
+ if response.status_code == requests.codes.UNAUTHORIZED:
+ # if unauthorized, the key might have expired
+ self._apiKey = self._getApiKey()
+ headers["X-Auth"] = self._apiKey
+ response = requests.request(verb, url, headers=headers, **kwargs)
+ response.raise_for_status()
+ return response
+
diff --git a/solo-tool-project/src/solo_tool/utils.py b/solo-tool-project/src/solo_tool/utils.py
new file mode 100644
index 0000000..df39fd9
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/utils.py
@@ -0,0 +1,7 @@
+from pyaudio import PyAudio
+
+def getAudioDeviceIndex(name: str, pa: PyAudio) -> int:
+ for i in range(pa.get_device_count()):
+ if pa.get_device_info_by_index(i)["name"].startswith(name):
+ return i
+ raise Exception(f"Audio device not found: {name}")
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-15 10:55:48 +0000