416 lines
16 KiB
Python
416 lines
16 KiB
Python
|
"""Handles /live/clip/* OSC addresses."""
|
||
|
|
import logging
|
||
|
|
from typing import Any, Optional
|
||
|
|
from .handler import AbletonOSCHandler
|
||
|
|
|
||
|
|
logger = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
CLIP_PROPS_RW = [
|
||
|
|
"name", "color", "color_index",
|
||
|
|
"muted", "gain",
|
||
|
|
"pitch_coarse", "pitch_fine", "velocity_amount",
|
||
|
|
"looping", "loop_start", "loop_end",
|
||
|
|
"start_marker", "end_marker",
|
||
|
|
"warping", "warp_mode",
|
||
|
|
"launch_mode", "launch_quantization",
|
||
|
|
"ram_mode",
|
||
|
|
]
|
||
|
|
|
||
|
|
CLIP_PROPS_RO = [
|
||
|
|
"is_playing", "is_recording", "is_midi_clip", "is_audio_clip",
|
||
|
|
"is_overdubbing", "is_triggered", "will_record_on_start",
|
||
|
|
"has_groove",
|
||
|
|
"length", "end_time", "start_time",
|
||
|
|
"playing_position", "sample_length",
|
||
|
|
"gain_display_string",
|
||
|
|
"file_path",
|
||
|
|
]
|
||
|
|
|
||
|
|
|
||
|
|
class ClipHandler(AbletonOSCHandler):
|
||
|
|
def init_api(self) -> None:
|
||
|
|
self.clear_listeners()
|
||
|
|
|
||
|
|
for prop in CLIP_PROPS_RW:
|
||
|
|
self._add(f"/live/clip/get/{prop}", self._make_getter(prop))
|
||
|
|
self._add(f"/live/clip/set/{prop}", self._make_setter(prop))
|
||
|
|
self._add(f"/live/clip/start_listen/{prop}", self._make_start_listen(prop))
|
||
|
|
self._add(f"/live/clip/stop_listen/{prop}", self._make_stop_listen(prop))
|
||
|
|
|
||
|
|
for prop in CLIP_PROPS_RO:
|
||
|
|
self._add(f"/live/clip/get/{prop}", self._make_getter(prop))
|
||
|
|
self._add(f"/live/clip/start_listen/{prop}", self._make_start_listen(prop))
|
||
|
|
self._add(f"/live/clip/stop_listen/{prop}", self._make_stop_listen(prop))
|
||
|
|
|
||
|
|
# Playback
|
||
|
|
self._add("/live/clip/fire", self._fire)
|
||
|
|
self._add("/live/clip/stop", self._stop)
|
||
|
|
self._add("/live/clip/duplicate_loop", self._duplicate_loop)
|
||
|
|
self._add("/live/clip/quantize", self._quantize)
|
||
|
|
|
||
|
|
# MIDI notes
|
||
|
|
self._add("/live/clip/get/notes", self._get_notes)
|
||
|
|
self._add("/live/clip/add/notes", self._add_notes)
|
||
|
|
self._add("/live/clip/remove/notes", self._remove_notes)
|
||
|
|
self._add("/live/clip/get/notes_extended", self._get_notes_extended)
|
||
|
|
self._add("/live/clip/apply_note_modifications", self._apply_note_modifications)
|
||
|
|
|
||
|
|
# Automation envelopes
|
||
|
|
self._add("/live/clip/get/automation_envelope", self._get_automation_envelope)
|
||
|
|
self._add("/live/clip/create_automation_envelope", self._create_automation_envelope)
|
||
|
|
self._add("/live/clip/clear_envelope", self._clear_envelope)
|
||
|
|
self._add("/live/clip/clear_all_envelopes", self._clear_all_envelopes)
|
||
|
|
|
||
|
|
# Warp markers
|
||
|
|
self._add("/live/clip/get/warp_markers", self._get_warp_markers)
|
||
|
|
|
||
|
|
# Groove
|
||
|
|
self._add("/live/clip/get/groove", self._get_groove)
|
||
|
|
self._add("/live/clip/set/groove", self._set_groove)
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _get_clip(self, params: tuple) -> Optional[Any]:
|
||
|
|
if len(params) < 2:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
track_idx = int(params[0])
|
||
|
|
clip_idx = int(params[1])
|
||
|
|
tracks = list(self.song.tracks)
|
||
|
|
if 0 <= track_idx < len(tracks):
|
||
|
|
slots = list(tracks[track_idx].clip_slots)
|
||
|
|
if 0 <= clip_idx < len(slots) and slots[clip_idx].has_clip:
|
||
|
|
return slots[clip_idx].clip
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get_clip(%s): %s", params, e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _clip_key(self, params: tuple) -> str:
|
||
|
|
return f"clip.{params[0]}.{params[1]}"
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _make_getter(self, prop: str):
|
||
|
|
def handler(params: tuple) -> Optional[tuple]:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None:
|
||
|
|
return None
|
||
|
|
val = self._get_prop(clip, prop)
|
||
|
|
if val is None:
|
||
|
|
return None
|
||
|
|
prefix = (int(params[0]), int(params[1]))
|
||
|
|
if isinstance(val, (list, tuple)):
|
||
|
|
return prefix + tuple(val)
|
||
|
|
return prefix + (val,)
|
||
|
|
return handler
|
||
|
|
|
||
|
|
def _make_setter(self, prop: str):
|
||
|
|
def handler(params: tuple) -> None:
|
||
|
|
if len(params) < 3:
|
||
|
|
return None
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
self._set_prop(clip, prop, params[2])
|
||
|
|
return None
|
||
|
|
return handler
|
||
|
|
|
||
|
|
def _make_start_listen(self, prop: str):
|
||
|
|
def handler(params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
key = f"{self._clip_key(params)}.{prop}"
|
||
|
|
prefix = (int(params[0]), int(params[1]))
|
||
|
|
self._register_listener(
|
||
|
|
key, clip, prop, f"/live/clip/get/{prop}", prefix
|
||
|
|
)
|
||
|
|
return handler
|
||
|
|
|
||
|
|
def _make_stop_listen(self, prop: str):
|
||
|
|
def handler(params: tuple) -> None:
|
||
|
|
if len(params) >= 2:
|
||
|
|
self._remove_listener(f"{self._clip_key(params)}.{prop}")
|
||
|
|
return handler
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
# Playback methods
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _fire(self, params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
try:
|
||
|
|
clip.fire()
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clip.fire: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _stop(self, params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
try:
|
||
|
|
clip.stop()
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clip.stop: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _duplicate_loop(self, params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
try:
|
||
|
|
clip.duplicate_loop()
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clip.duplicate_loop: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _quantize(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx, quantization, strength"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
try:
|
||
|
|
quant = int(params[2]) if len(params) > 2 else 4
|
||
|
|
strength = float(params[3]) if len(params) > 3 else 1.0
|
||
|
|
clip.quantize(quant, strength)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clip.quantize: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
# MIDI notes
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _get_notes(self, params: tuple) -> Optional[tuple]:
|
||
|
|
"""params: track_idx, clip_idx [, pitch, pitch_span, time, time_span]"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_midi_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
if len(params) >= 6:
|
||
|
|
pitch = int(params[2])
|
||
|
|
pitch_span = int(params[3])
|
||
|
|
time = float(params[4])
|
||
|
|
time_span = float(params[5])
|
||
|
|
notes = clip.get_notes(time, pitch, time_span, pitch_span)
|
||
|
|
else:
|
||
|
|
notes = clip.get_notes(0, 0, clip.length, 128)
|
||
|
|
result = []
|
||
|
|
for note in notes:
|
||
|
|
result += [note[0], note[1], note[2], note[3], int(note[4])]
|
||
|
|
return (int(params[0]), int(params[1])) + tuple(result)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get_notes: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _get_notes_extended(self, params: tuple) -> Optional[tuple]:
|
||
|
|
"""Returns notes using the extended API (with IDs)."""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_midi_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
if len(params) >= 6:
|
||
|
|
notes = clip.get_notes_extended(
|
||
|
|
int(params[2]), int(params[3]),
|
||
|
|
float(params[4]), float(params[5])
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
notes = clip.get_notes_extended(0, 128, 0, clip.length)
|
||
|
|
result = []
|
||
|
|
for note in notes:
|
||
|
|
result += [
|
||
|
|
note.pitch, float(note.start_time), float(note.duration),
|
||
|
|
note.velocity, int(note.mute), note.note_id,
|
||
|
|
float(note.release_velocity), float(note.probability)
|
||
|
|
]
|
||
|
|
return (int(params[0]), int(params[1])) + tuple(result)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get_notes_extended: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _add_notes(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx, pitch, start_time, duration, velocity, mute, [...]"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_midi_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
note_data = params[2:]
|
||
|
|
if len(note_data) % 5 != 0:
|
||
|
|
logger.warning("add_notes: expected multiple of 5 args after indices")
|
||
|
|
return None
|
||
|
|
notes = []
|
||
|
|
for i in range(0, len(note_data), 5):
|
||
|
|
notes.append((
|
||
|
|
int(note_data[i]), # pitch
|
||
|
|
float(note_data[i+1]), # start_time
|
||
|
|
float(note_data[i+2]), # duration
|
||
|
|
int(note_data[i+3]), # velocity
|
||
|
|
bool(note_data[i+4]), # mute
|
||
|
|
))
|
||
|
|
clip.set_notes(tuple(notes))
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("add_notes: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _remove_notes(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx [, time, time_span, pitch, pitch_span]"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_midi_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
if len(params) >= 6:
|
||
|
|
time = float(params[2])
|
||
|
|
time_span = float(params[3])
|
||
|
|
pitch = int(params[4])
|
||
|
|
pitch_span = int(params[5])
|
||
|
|
else:
|
||
|
|
time, time_span, pitch, pitch_span = 0, clip.length, 0, 128
|
||
|
|
clip.remove_notes(time, pitch, time_span, pitch_span)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("remove_notes: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _apply_note_modifications(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx, note_id, pitch, start_time, duration, velocity, mute, ..."""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_midi_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
note_data = params[2:]
|
||
|
|
# 8 values per note: note_id, pitch, start_time, duration, velocity, mute,
|
||
|
|
# release_velocity, probability
|
||
|
|
if len(note_data) % 8 != 0:
|
||
|
|
logger.warning("apply_note_modifications: expected multiple of 8 args")
|
||
|
|
return None
|
||
|
|
notes = []
|
||
|
|
for i in range(0, len(note_data), 8):
|
||
|
|
note = clip.get_notes_extended(0, 128, 0, clip.length)
|
||
|
|
# Build modification by note_id
|
||
|
|
notes.append({
|
||
|
|
"note_id": int(note_data[i]),
|
||
|
|
"pitch": int(note_data[i+1]),
|
||
|
|
"start_time": float(note_data[i+2]),
|
||
|
|
"duration": float(note_data[i+3]),
|
||
|
|
"velocity": int(note_data[i+4]),
|
||
|
|
"mute": bool(note_data[i+5]),
|
||
|
|
"release_velocity": float(note_data[i+6]),
|
||
|
|
"probability": float(note_data[i+7]),
|
||
|
|
})
|
||
|
|
clip.apply_note_modifications(notes)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("apply_note_modifications: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
# Automation envelopes
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _get_automation_envelope(self, params: tuple) -> Optional[tuple]:
|
||
|
|
"""params: track_idx, clip_idx, device_idx, param_idx"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or len(params) < 4:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
track = list(self.song.tracks)[int(params[0])]
|
||
|
|
device = list(track.devices)[int(params[2])]
|
||
|
|
param = list(device.parameters)[int(params[3])]
|
||
|
|
env = clip.automation_envelope(param)
|
||
|
|
if env is None:
|
||
|
|
return None
|
||
|
|
points = []
|
||
|
|
for step in range(env.count):
|
||
|
|
time = step * (clip.length / env.count)
|
||
|
|
points += [float(time), float(env.value_at_time(time))]
|
||
|
|
return (int(params[0]), int(params[1]), int(params[2]), int(params[3])) + tuple(points)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get_automation_envelope: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _create_automation_envelope(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx, device_idx, param_idx"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or len(params) < 4:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
track = list(self.song.tracks)[int(params[0])]
|
||
|
|
device = list(track.devices)[int(params[2])]
|
||
|
|
param = list(device.parameters)[int(params[3])]
|
||
|
|
clip.create_automation_envelope(param)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("create_automation_envelope: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _clear_envelope(self, params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or len(params) < 4:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
track = list(self.song.tracks)[int(params[0])]
|
||
|
|
device = list(track.devices)[int(params[2])]
|
||
|
|
param = list(device.parameters)[int(params[3])]
|
||
|
|
env = clip.automation_envelope(param)
|
||
|
|
if env:
|
||
|
|
env.clear_all_events()
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clear_envelope: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _clear_all_envelopes(self, params: tuple) -> None:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip:
|
||
|
|
try:
|
||
|
|
clip.clear_all_envelopes()
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("clear_all_envelopes: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
# Warp markers
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _get_warp_markers(self, params: tuple) -> Optional[tuple]:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or not clip.is_audio_clip:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
markers = list(clip.warp_markers)
|
||
|
|
result = []
|
||
|
|
for m in markers:
|
||
|
|
result += [float(m.beat_time), float(m.sample_time)]
|
||
|
|
return (int(params[0]), int(params[1])) + tuple(result)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get_warp_markers: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
# Groove
|
||
|
|
# ------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _get_groove(self, params: tuple) -> Optional[tuple]:
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None:
|
||
|
|
return None
|
||
|
|
try:
|
||
|
|
groove = clip.groove
|
||
|
|
if groove is None:
|
||
|
|
return (int(params[0]), int(params[1]), "")
|
||
|
|
return (int(params[0]), int(params[1]), groove.name)
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("get groove: %s", e)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _set_groove(self, params: tuple) -> None:
|
||
|
|
"""params: track_idx, clip_idx, groove_name"""
|
||
|
|
clip = self._get_clip(params)
|
||
|
|
if clip is None or len(params) < 3:
|
||
|
|
return None
|
||
|
|
groove_name = str(params[2])
|
||
|
|
try:
|
||
|
|
if groove_name == "":
|
||
|
|
clip.groove = None
|
||
|
|
else:
|
||
|
|
for g in self.song.groove_pool.grooves:
|
||
|
|
if g.name == groove_name:
|
||
|
|
clip.groove = g
|
||
|
|
break
|
||
|
|
except Exception as e:
|
||
|
|
logger.warning("set groove: %s", e)
|
||
|
|
return None
|