def mastermeters(self):
tracks = LiveUtils.getSong().return_tracks
vall = LiveUtils.getSong().master_track.output_meter_left
valr = LiveUtils.getSong().master_track.output_meter_right
vall = round(vall, 4)
valr = round(valr, 4)
if vall != self.mmcache:
self.oscServer.sendOSC('/master/meter', (vall, valr))
if vall == 0:
self.oscServer.sendOSC('/master/meter',
(0.0000000001, 0000000.1))
self.mmcache = vall
i = 0
for track in tracks:
vall = track.output_meter_left
valr = track.output_meter_right
vall = round(vall, 4)
valr = round(valr, 4)
if vall != self.mrcache[i]:
self.oscServer.sendOSC('/return/meter', (i, vall, valr))
self.mrcache[i] = vall
else:
pass
i = i + 1
def positions(self):
tracks = LiveUtils.getSong().tracks
pos = 0
ps = 0
if LiveUtils.getSong().is_playing != 4:
#self.oscServer.sendOSC("/bundle/start", 1)
for i in range(len(tracks)):
track = tracks[i]
if track.is_foldable != 1:
if track.playing_slot_index != -2:
if track.playing_slot_index != -1:
ps = track.playing_slot_index
clip = track.clip_slots[ps].clip
playing_pos = 0
pos = 0
try:
playing_pos = clip.playing_position
if clip.looping == 1:
if clip.playing_position < clip.loop_start:
#clip.looping = 0
start = clip.loop_start
end = clip.loop_end
#clip.looping = 1
pos = 1 - round(
(end - clip.playing_position) /
end, 6)
#pos = round((clip.loop_start - clip.playing_position) / (clip.loop_start - start), 3)
else:
pos = round(
(clip.playing_position -
clip.loop_start) /
(clip.loop_end - clip.loop_start),
6)
else:
pos = round(
(clip.playing_position -
clip.loop_start) /
(clip.loop_end - clip.loop_start), 6)
except:
asddd = 1
self.oscServer.sendOSC('/clip/playing_position',
(i, ps, pos, playing_pos))
else:
pass
else:
pass
else:
pass
#self.oscServer.sendOSC("/bundle/end", (1))
else:
pass
def loadAllCB(self, msg):
"""Called when a /live/tracks message is received.
Messages:
/live/tracks no argument or 'query' Returns the total number of scenes
"""
if len(msg) == 2 or (len(msg) == 3 and msg[2] == "query"):
trackTotal = len(LiveUtils.getTracks())
sceneTotal = len(LiveUtils.getScenes())
returnsTotal = len(LiveUtils.getSong().return_tracks)
self.oscServer.sendOSC("/set/size",
(trackTotal, sceneTotal, returnsTotal))
self.oscServer.sendOSC("/NSLOG_REPLACE", "set size load all cb")
return
def loadScenesStartUp(self):
sceneNumber = 0
ascnm = " "
nm = " "
all_scenes = LiveUtils.getScenes()
for scene in all_scenes:
nm = ""
if scene.name != None:
nm = touchAbleUtils.cut_string2(scene.name)
if scene.color == 0:
self.oscServer.sendOSC("/scene", (sceneNumber, touchAbleUtils.repr2(nm), 0))
else:
self.oscServer.sendOSC("/scene", (sceneNumber, touchAbleUtils.repr2(nm), scene.color))
scene_color = scene.color
if sceneNumber == 0:
self.oscServer.sendOSC("/color_pallet_start", 1)
for x in range(0, 60):
try:
scene.color_index = x
scene1_color = scene.color
self.oscServer.sendOSC("/color_pallet", (scene1_color, x - 1))
scene.color = scene_color
except:
self.oscServer.sendOSC("/color_pallet_done", 1)
pass
self.oscServer.sendOSC("/color_pallet_done", 1)
sceneNumber = sceneNumber + 1
def update_display(self):
"""
This function is run every 100ms, so we use it to initiate our Song.current_song_time
listener to allow us to process incoming OSC commands as quickly as possible under
the current listener scheme.
"""
######################################################
# START OSC LISTENER SETUP
if self.tACallbacks == None and self.did_init == 1:
# By default we have set tACallbacks to 0 so that we can assign it after
# initialization. We try to get the current song and if we can we'll
# connect our tACallbacks callbacks to the listener allowing us to
# respond to incoming OSC every 60ms.
#
# Since this method is called every 100ms regardless of the song time
# changing, we use both methods for processing incoming UDP requests
# so that from a resting state you can initiate play/clip triggering.
try:
doc = LiveUtils.getSong()
except:
self.error_log("could not get song from Live Utils")
return
try:
# LMH
self.tACallbacks = touchAbleCallbacks.touchAbleCallbacks(
self._touchAble__c_instance, self.oscServer, self)
self.tA_log("initialised tACallbacks..")
# Commented for stability
#doc.add_current_song_time_listener(self.oscServer.processIncomingUDP)
#self.oscServer.sendOSC("/server/refresh", (1))
except:
self.error_log("could not create touchAbleCallbacks")
return
# If our OSC server is listening, try processing incoming requests.
# Any 'play' initiation will trigger the current_song_time listener
# and bump updates from 100ms to 60ms.
if self.oscServer:
try:
#self.oscServer.sendOSC('/processingOSC', (1))
self.oscServer.processIncomingUDP()
except:
pass
#self.updateTime = self.updateTime +4
#if self.updateTime >= 100:
if self.oscServer:
self.sendScriptPong()
#self.tA_log("sent script pong..")
self.updateCB()
def loadReturnsStartUp(self,selected_track):
returnNumber = 0
returnsTotal = len(LiveUtils.getSong().return_tracks)
self.oscServer.sendOSC("/returns", (int(returnsTotal), 1))
all_return_tracks = LiveUtils.getSong().return_tracks
for retTrack in all_return_tracks:
name = retTrack.name
color = 0
try:
color = retTrack.color
except:
pass
self.oscServer.sendOSC("/return", (int(returnNumber), touchAbleUtils.repr2(name), int(color)))
self.oscServer.sendOSC("/return/pan", (returnNumber, float(retTrack.mixer_device.panning.value)))
self.oscServer.sendOSC("/return/mute", (returnNumber, int(retTrack.mute)))
self.oscServer.sendOSC("/return/crossfade_assign", (returnNumber, int(retTrack.mixer_device.crossfade_assign)))
self.oscServer.sendOSC("/return/solo", (returnNumber, int(retTrack.solo)))
self.oscServer.sendOSC("/return/volume", (returnNumber, float(retTrack.mixer_device.volume.value)))
try:
self.sendTrackIO(returnNumber, retTrack, "", 2)
except:
self.error_log("touchAbleCallbacks: loadReturnsStartUp : sendTrackIO for returns failed")
try:
self.load_devices_for_track(retTrack, int(returnNumber), int(2))
except:
self.error_log("touchAbleCallbacks: loadReturnsStartUp : load_devices_for_track for returns failed")
return_tracks_length = len(LiveUtils.getSong().return_tracks)
for i in range(return_tracks_length):
self.oscServer.sendOSC("/return/send", (returnNumber,i, float(retTrack.mixer_device.sends[i].value)))
if retTrack == selected_track:
selected_index = returnNumber
self.oscServer.sendOSC("/set/selected_track", (2, (selected_index)))
returnNumber = returnNumber + 1
def init_locked_device(self):
self.locked_device = LiveUtils.getSong(
).view.selected_track.view.selected_device
self.lock_to_device(self.locked_device)
self._device_appointer = None
self._device_selection_follows_track_selection = True
if self._device_selection_follows_track_selection == True:
self.tA_log("devices DO follow track selection..")
else:
self.tA_log("devices DO NOT!!! follow track selection..")
self.show_message("loading touchAble Pro Control Surface..")
try:
self._device_appointer = DeviceAppointer(
song=LiveUtils.getSong(),
appointed_device_setter=self._set_appointed_device)
except:
self.error_log("touchAble: DeviceAppointer init failed")
pass
def meters(self):
#self.oscServer.sendOSC("/bundle/start", 1)
tracks = LiveUtils.getSong().tracks
vall = 0
valr = 0
for i in range(len(tracks)):
track = tracks[i]
if track.has_audio_output:
vall = track.output_meter_left
valr = track.output_meter_right
else:
vall = -1.0 * track.output_meter_level - 1.0
valr = 0
vall = round(vall, 4)
valr = round(valr, 4)
sum = vall + valr
if sum != self.mlcache[i]:
self.oscServer.sendOSC('/track/meter', (i, vall, valr))
self.mlcache[i] = sum
else:
pass
def loadSetStartup(self):
tquant = LiveUtils.getSong().clip_trigger_quantization
rquant = LiveUtils.getSong().midi_recording_quantization
self.oscServer.sendOSC("/set/quantization", (int(LiveUtils.getSong().clip_trigger_quantization), int(LiveUtils.getSong().midi_recording_quantization)))
songtime = LiveUtils.getSong().current_song_time
denom = LiveUtils.getSong().signature_denominator
numer = LiveUtils.getSong().signature_numerator
self.oscServer.sendOSC("/set/playing_position", (float(songtime) + 0.001, float(denom), float(numer)))
overdub = LiveUtils.getSong().overdub
self.oscServer.sendOSC("/set/overdub_status", (int(overdub) + 1))
record = LiveUtils.getSong().record_mode
self.oscServer.sendOSC("/set/recording_status", (int(record) + 1))
try:
overdub = LiveUtils.getSong().session_record
self.oscServer.sendOSC("/live/set/session_record", (int(overdub)+1))
overdub = LiveUtils.getSong().session_record_status
self.oscServer.sendOSC("/live/set/session_record_status", (int(overdub)+1))
overdub = LiveUtils.getSong().re_enable_automation_enabled
self.oscServer.sendOSC("/live/set/re_enable_automation_enabled", (int(overdub)+1))
overdub = LiveUtils.getSong().session_automation_record
self.oscServer.sendOSC("/live/set/session_automation_record", (int(overdub)+1))
except:
self.oscServer.sendOSC("/live/", 8)
master_color = LiveUtils.getSong().master_track.color
self.oscServer.sendOSC("/master/color", master_color)
tempo = LiveUtils.getTempo()
self.oscServer.sendOSC("/set/tempo", (tempo))
excl_arm = LiveUtils.getSong().exclusive_arm
self.oscServer.sendOSC("/set/exclusive_arm", (int(excl_arm) + 1))
excl_solo = LiveUtils.getSong().exclusive_solo
self.oscServer.sendOSC("/set/exclusive_solo", (int(excl_solo) + 1))
value = LiveUtils.getSong().master_track.mixer_device.cue_volume.value
self.oscServer.sendOSC("/cuelevel", float(value))
metronome = LiveUtils.getSong().metronome
self.oscServer.sendOSC("/set/metronome_status", (int(metronome) + 1))
play = LiveUtils.getSong().is_playing
self.oscServer.sendOSC("/set/playing_status", (int(play) + 1))
master = LiveUtils.getSong().master_track.mixer_device.volume.value
self.oscServer.sendOSC("/master/volume", (float(master)))
crossfader = LiveUtils.getSong().master_track.mixer_device.crossfader.value
self.oscServer.sendOSC("/master/crossfader", float(crossfader))
def loadTracksStartUp(self, msg):
self.getVersion(1)
try:
self.loadSetStartup()
except:
self.error_log("touchAbleCallbacks: loadSetStartup failed")
self.oscServer.sendOSC("/bundle/start", 1)
self.oscServer.sendOSC("/song/loop", (int(LiveUtils.getSong().loop)))
trackTotal = len(LiveUtils.getTracks())
sceneTotal = len(LiveUtils.getScenes())
returnsTotal = len(LiveUtils.getSong().return_tracks)
self.oscServer.sendOSC("/set/size", (int(trackTotal), int(sceneTotal), int(returnsTotal)))
selected_track = LiveUtils.getSong().view.selected_track
selected_index = 0
selected_scene = LiveUtils.getSong().view.selected_scene
scene_index = 0
selected_scene_index = 0
all_scenes = LiveUtils.getSong().scenes
for sce in all_scenes:
if sce == selected_scene:
selected_scene_index = scene_index
scene_index = scene_index + 1
self.oscServer.sendOSC("/set/selected_scene", int(selected_scene_index+1))
trackNumber = 0
ascnm = " "
nm = " "
grouptrack = 0
is_midi_track = 0
all_tracks = LiveUtils.getTracks()
for track in all_tracks:
clipNumber = 0
if track.name != None:
nm = touchAbleUtils.cut_string2(track.name)
col = 0
try:
col = track.color
except:
pass
if track.is_foldable == 1:
grouptrack = 1
else:
grouptrack = 0
is_midi_track = track.has_midi_input
#self.touchAble._log( "track nr" + str(trackNumber), True)
live_pointer = ""
self.oscServer.sendOSC("/track", (trackNumber, touchAbleUtils.repr2(nm), col, grouptrack, int(is_midi_track),live_pointer))
self.oscServer.sendOSC("/track/volume", (trackNumber, float(LiveUtils.trackVolume(trackNumber))))
self.oscServer.sendOSC("/pan", (trackNumber, float(LiveUtils.trackPan(trackNumber))))
self.oscServer.sendOSC("/track/mute", (trackNumber, int(track.mute)))
self.oscServer.sendOSC("/track/solo", (trackNumber, int(track.solo)))
self.oscServer.sendOSC("/track/crossfade_assign", (trackNumber, int(track.mixer_device.crossfade_assign)))
self.oscServer.sendOSC("/track/is_grouped", (trackNumber, int(track.is_grouped)))
self.oscServer.sendOSC("/track/is_visible", (trackNumber, int(track.is_visible)))
try:
self.sendTrackIO(trackNumber, track, "", 0)
except:
self.error_log("touchAbleCallbacks: sendTrackIO for track " + str(trackNumber) + "failed")
try:
self.sendTrackClips(trackNumber,track)
except:
self.error_log("touchAbleCallbacks: sendTrackClips for track " + str(trackNumber) + "failed")
if track.can_be_armed == 1:
self.oscServer.sendOSC("/track/arm", (trackNumber, int(track.arm)))
self.oscServer.sendOSC("/track/current_monitoring_state", (trackNumber, track.current_monitoring_state))
else:
self.oscServer.sendOSC("/track/arm", (trackNumber, 0))
self.oscServer.sendOSC("/track/current_monitoring_state", (trackNumber, 3))
try:
self.load_devices_for_track(track, trackNumber, 0)
except:
self.error_log("touchAbleCallbacks: load_devices_for_track for track " + str(trackNumber) + " failed")
return_tracks_length = len(LiveUtils.getSong().return_tracks)
for i in range(return_tracks_length):
self.oscServer.sendOSC("/track/send", (trackNumber,i, float(LiveUtils.trackSend(trackNumber, i))))
if track == selected_track:
selected_index = trackNumber
self.oscServer.sendOSC("/set/selected_track", (0, (selected_index)))
trackNumber = trackNumber + 1
#sleep(0.02)
try:
self.load_devices_for_track(LiveUtils.getSong().master_track, int(1), int(1))
except:
self.error_log("touchAbleCallbacks: load_devices_for_track for master_track failed")
if LiveUtils.getSong().master_track == selected_track:
self.oscServer.sendOSC("/set/selected_track", (1))
try:
self.loadReturnsStartUp(selected_track)
except:
self.error_log("touchAbleCallbacks: loadReturnsStartUp failed")
self.oscServer.sendOSC("/done", (1))
self.oscServer.sendOSC("/finish_loading", (1))
self.oscServer.sendOSC("/bundle/end", (1))
try:
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid 0"))
setid = LiveUtils.getSong().get_data("setid", "")
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid 1"))
if setid == "":
#setid = self.my_random_string()
setid = "no setid"
LiveUtils.getSong().set_data("setid", setid)
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid 2"))
else:
pass
#self.oscServer.sendOSC("/NSLOG_REPLACE", (str(setid)))
self.oscServer.sendOSC("/setid", (str(setid)))
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid 3"))
except:
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid -2"))
setid = touchAbleUtils.my_random_string()
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid -3"))
LiveUtils.getSong().set_data("setid", setid)
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("setid -4"))
self.oscServer.sendOSC("/setid", (str(setid)))
self.loading = 0
if self.should_check_if_load == 1:
trackTotal2 = len(LiveUtils.getTracks())
sceneTotal2 = len(LiveUtils.getScenes())
returnsTotal2 = len(LiveUtils.getSong().return_tracks)
if (trackTotal != trackTotal2 or sceneTotal != sceneTotal2 or returnsTotal != returnsTotal2):
self.touchAble.error_log("load is needed")
self.should_check_if_load = 0
self.tracksCB(msg)
def send_update_for_device(self, device, track, tid, did, type, num,
number_of_steps, indices, i):
message = "send_update_for_device for track: " + str(
tid) + " and device: " + str(device.name)
self.ta_logger(message, 4)
"""
try:
self.expand_device(device)
#message = "expand_device here failed for track: " + str(tid) + " and device: " + str(device.name)
#self.ta_logger(message, 4)
except:
self.error_log("tochAbleCommon failed expanding:" + touchAbleUtils.repr2(device.name))
pass
"""
if i != -1:
indices.append(int(i))
number_of_steps = number_of_steps + 1
elif i == -1 and number_of_steps == 0:
indic = []
indices = list(indic)
nm = touchAbleUtils.repr2(device.name)
params = device.parameters
onoff = params[0].value
numParams = len(params)
cnam = touchAbleUtils.repr2(device.class_name)
tr = tid
dev = did
name = track.name
devicename = device.name
is_selected = 0
if device == LiveUtils.getSong().appointed_device:
is_selected = 1
po = [type]
po.append(int(tr))
po.append(int(dev))
po2 = [type]
po2.append(int(tr))
po2.append(int(dev))
po2.append(touchAbleUtils.repr2(name))
po2.append(touchAbleUtils.repr2(devicename))
po2.append(int(is_selected))
po.append(int(number_of_steps))
po2.append(int(number_of_steps))
po4 = [type]
po4.append(int(tr))
po4.append(int(dev))
po4.append(int(number_of_steps))
po5 = [type]
po5.append(int(tr))
po5.append(int(dev))
po5.append(int(number_of_steps))
for index in range(number_of_steps * 2):
po.append(int(indices[index]))
po2.append(int(indices[index]))
po4.append(int(indices[index]))
po5.append(int(indices[index]))
for j in range(len(params)):
po.append(params[j].min)
po.append(params[j].max)
po.append(params[j].is_quantized + 1)
po2.append(float(params[j].value))
po2.append(touchAbleUtils.repr2(params[j].name))
po2.append(touchAbleUtils.repr2(params[j].__str__()))
po4.append(int(params[j].is_enabled))
automation_state = 0
if params[j].automation_state:
automation_state = params[j].automation_state
po4.append(int(automation_state))
reset_value = -13337.0
if params[j].is_quantized == 0:
reset_value = float(params[j].default_value)
po5.append(float(reset_value))
try:
can_have_chains = device.can_have_chains
except:
can_have_chains = 0
try:
can_have_drumpads = device.can_have_drum_pads and device.has_drum_pads and device.class_name == 'MultiSampler' or device.class_name == "DrumGroupDevice"
except:
can_have_drumpads = 0
live_pointer = str(device._live_ptr)
if type == 0:
po3 = [
type, tid, did, nm, onoff,
int(num), numParams,
int(can_have_drumpads), cnam,
int(can_have_chains), number_of_steps
]
for index in range(number_of_steps * 2):
po3.append(int(indices[index]))
if can_have_drumpads or can_have_chains:
po3.append(int(device.has_macro_mappings))
po3.append(str(live_pointer))
self.oscServer.sendOSC('/track/device', (tuple(po3)))
self.oscServer.sendOSC("/device/range", tuple(po))
self.oscServer.sendOSC("/track/device/parameters", tuple(po2))
self.oscServer.sendOSC("/track/device/parameters/enabled",
tuple(po4))
self.oscServer.sendOSC("/track/device/parameters/default_value",
tuple(po5))
if can_have_drumpads:
drum_pads_tuple = [type, tid, did, number_of_steps]
for index in range(number_of_steps * 2):
drum_pads_tuple.append(int(indices[index]))
drum_pads_tuple.append(int(len(device.drum_pads)))
for drum_pad in device.drum_pads:
drum_pads_tuple.append(int(drum_pad.note))
drum_pads_tuple.append(touchAbleUtils.repr2(drum_pad.name))
drum_pads_tuple.append(int(drum_pad.mute))
drum_pads_tuple.append(int(drum_pad.solo))
#self.oscServer.sendOSC("/NSLOG_REPLACE", (str("SENDING DRUMPAD"), touchAbleUtils.repr2(drum_pad.name)))
self.oscServer.sendOSC("/track/device/drumpads",
tuple(drum_pads_tuple))
elif type == 2:
po3 = [
type, tid, did, nm, onoff,
int(num), numParams,
int(can_have_drumpads), cnam,
int(can_have_chains), number_of_steps
]
for index in range(number_of_steps * 2):
po3.append(int(indices[index]))
po3.append(live_pointer)
self.oscServer.sendOSC('/return/device', (tuple(po3)))
self.oscServer.sendOSC("/device/range", tuple(po))
self.oscServer.sendOSC("/return/device/parameters", tuple(po2))
self.oscServer.sendOSC("/return/device/parameters/enabled",
tuple(po4))
elif type == 1:
po3 = [
type, 0, did, nm, onoff,
int(num), numParams,
int(can_have_drumpads), cnam,
int(can_have_chains), number_of_steps
]
for index in range(number_of_steps * 2):
po3.append(int(indices[index]))
po3.append(live_pointer)
self.oscServer.sendOSC('/master/device', (tuple(po3)))
self.oscServer.sendOSC("/device/range", tuple(po))
self.oscServer.sendOSC("/master/device/parameters", tuple(po2))
self.oscServer.sendOSC("/master/device/parameters/enabled",
tuple(po4))
if device.class_name == 'OriginalSimpler':
try:
self.touchAble.tAListener.simplerListener.update_simpler_parameters(
device, track, tid, did, type, number_of_steps, indices)
except:
self.error_log(
"tochAbleCommon: update_simpler_parameters failed")
a_version = Live.Application.get_application().get_major_version()
if a_version >= 10:
try:
self.touchAble.tAListener.compressorListener.update_compressor_parameters(
device, track, tid, did, type, number_of_steps, indices)
except:
self.error_log(
"tochAbleCommon: update_compressor_parameters failed")
try:
self.touchAble.tAListener.wavetableListener.update_wavetable_parameters(
device, track, tid, did, type, number_of_steps, indices)
except:
self.error_log(
"tochAbleCommon: update_wavetable_parameters failed")
try:
self.touchAble.tAListener.pluginListener.update_plugin_parameters(
device, track, tid, did, type, number_of_steps, indices)
except:
self.error_log(
"tochAbleCommon: update_plugin_parameters failed")
if can_have_chains == 1:
for chain_id in range(len(device.chains)):
chain = device.chains[chain_id]
indis = list(indices)
indis.append(int(chain_id))
po3 = [
type, tid, did,
touchAbleUtils.repr2(chain.name), number_of_steps
]
for index in range(number_of_steps * 2 + 1):
po3.append(int(indis[index]))
self.oscServer.sendOSC('/device_chain', (tuple(po3)))
for device_id in range(len(chain.devices)):
dev = chain.devices[device_id]
lis = list(indis)
self.send_update_for_device(dev, track, tid, did, type,
len(chain.devices),
number_of_steps, lis,
device_id)
def songtime_change(self):
denom = LiveUtils.getSong().signature_denominator
numer = LiveUtils.getSong().signature_numerator
self.oscServer.sendOSC("/set/playing_position",
(LiveUtils.getSong().current_song_time,
float(numer), float(denom)))