"""
Copyright 2019 iACT, Universite de Montreal,
Jean Piche, Olivier Belanger, Jean-Michel Dumas
This file is part of Cecilia 5.
Cecilia 5 is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Cecilia 5 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Cecilia 5. If not, see .
"""
import wx
import os, math, copy, time, traceback
from cecilia.Resources import CeciliaLib
from .constants import *
from .API_interface import *
if CeciliaLib.getVar("samplePrecision") == '64 bit':
from pyo64 import *
else:
from pyo import *
class CeciliaFilein:
def __init__(self, parent, name):
self.parent = parent
self.name = name
info = CeciliaLib.getVar("userInputs")[name]
chnls = CeciliaLib.getVar("nchnls")
for filein in CeciliaLib.getControlPanel().cfileinList:
if filein.name == name:
break
offset = filein.getOffset()
mode = filein.getMode()
if mode == 0:
snd_chnls = info['nchnls' + self.name]
if snd_chnls == 1:
self.table = SndTable([info['path'] for i in range(chnls)], start=info["off" + self.name])
else:
self.table = SndTable(info['path'], start=info["off" + self.name])
else:
self.table = NewTable(length=offset, chnls=chnls, feedback=0.0)
self.livein = Input(chnl=[x for x in range(chnls)], mul=0.7)
self.filltabrec = TableRec(self.livein, self.table, fadetime=0.05).play()
def sig(self):
return self.table
class CeciliaSampler:
def __init__(self, parent, name, user_pitch, user_amp):
self.type = "sampler"
self.parent = parent
self.baseModule = parent
self.name = name
self.user_pitch = user_pitch
self.user_amp = user_amp
info = CeciliaLib.getVar("userInputs")[name]
totalTime = CeciliaLib.getVar("totalTime")
chnls = CeciliaLib.getVar("nchnls")
samplerList = CeciliaLib.getVar("userSamplers")
for sampler in samplerList:
if sampler.name == name:
sinfo = sampler.getSamplerInfo()
break
self.sampler = sampler
self.mode = self.sampler.mode
self.start_play, self.start_midi = False, False
self.dur_play, self.dur_midi = False, False
self.xfade_play, self.xfade_midi = False, False
self.gain_play, self.gain_midi = False, False
self.pitch_play, self.pitch_midi = False, False
if self.mode != 1:
graph_lines = {}
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name.startswith(self.name):
graph_lines[line.name] = line
paths = [slider.getPath() for slider in sampler.getSamplerSliders()]
################ start ################
start_init, self.start_play, self.start_rec = sinfo['loopIn'][0], sinfo['loopIn'][1], sinfo['loopIn'][2]
try:
self.start_midi, start_midictl, start_midichnl = sinfo['loopIn'][3], sinfo['loopIn'][4], sinfo['loopIn'][5]
self.start_mini, self.start_maxi = sinfo['loopIn'][6], sinfo['loopIn'][7]
self.start_osc = sinfo['loopIn'][8]
except:
self.start_midi, start_midictl, start_midichnl, self.start_mini, self.start_maxi = False, None, 1, 0, 1
self.start_osc = None
line = graph_lines[self.name + 'start']
curved = line.getCurved()
if curved:
self.start_table = CosTable()
else:
self.start_table = LinTable()
if not self.start_play and not self.start_midi:
self.start = SigTo(value=start_init, time=0.025, init=start_init)
if self.start_play:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph('start', data)
self.start = TableRead(self.start_table, freq=1.0 / totalTime).play()
elif self.start_midi:
self.start = Midictl(start_midictl, self.start_mini, self.start_maxi, start_init, start_midichnl)
elif self.start_osc is not None:
self.baseModule._addOpenSndCtrlWidget(self.start_osc[0], self.start_osc[1], self, name='start')
if self.start_rec:
self.start_record = ControlRec(self.start, filename=paths[0], rate=1000, dur=totalTime).play()
################ dur ################
dur_init, self.dur_play, self.dur_rec = sinfo['loopOut'][0], sinfo['loopOut'][1], sinfo['loopOut'][2]
try:
self.dur_midi, dur_midictl, dur_midichnl = sinfo['loopOut'][3], sinfo['loopOut'][4], sinfo['loopOut'][5]
self.dur_mini, self.dur_maxi = sinfo['loopOut'][6], sinfo['loopOut'][7]
self.dur_osc = sinfo['loopOut'][8]
except:
self.dur_midi, dur_midictl, dur_midichnl, self.dur_mini, self.dur_maxi = False, None, 1, 0, 1
self.dur_osc = None
line = graph_lines[self.name + 'end']
curved = line.getCurved()
if curved:
self.dur_table = CosTable()
else:
self.dur_table = LinTable()
if not self.dur_play and not self.dur_midi:
self.dur = SigTo(value=dur_init, time=0.025, init=dur_init)
if self.dur_play:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph('end', data)
self.dur = TableRead(self.dur_table, freq=1.0 / totalTime).play()
elif self.dur_midi:
self.dur = Midictl(dur_midictl, self.dur_mini, self.dur_maxi, dur_init, dur_midichnl)
elif self.dur_osc is not None:
self.baseModule._addOpenSndCtrlWidget(self.dur_osc[0], self.dur_osc[1], self, name='dur')
if self.dur_rec:
self.dur_record = ControlRec(self.dur, filename=paths[1], rate=1000, dur=totalTime).play()
################ xfade ################
xfade_init, self.xfade_play, self.xfade_rec = sinfo['loopX'][0], sinfo['loopX'][1], sinfo['loopX'][2]
try:
self.xfade_midi, xfade_midictl, xfade_midichnl = sinfo['loopX'][3], sinfo['loopX'][4], sinfo['loopX'][5]
self.xfade_osc = sinfo['loopX'][6]
except:
self.xfade_midi, xfade_midictl, xfade_midichnl = False, None, 1
self.xfade_osc = None
line = graph_lines[self.name + 'xfade']
curved = line.getCurved()
if curved:
self.xfade_table = CosTable()
else:
self.xfade_table = LinTable()
if not self.xfade_play and not self.xfade_midi:
self.xfade = SigTo(value=xfade_init, time=0.025, init=xfade_init)
if self.xfade_play:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph('xfade', data)
self.xfade = TableRead(self.xfade_table, freq=1.0 / totalTime).play()
elif self.xfade_midi:
self.xfade = Midictl(xfade_midictl, 0, 50, xfade_init, xfade_midichnl)
elif self.xfade_osc is not None:
self.baseModule._addOpenSndCtrlWidget(self.xfade_osc[0], self.xfade_osc[1], self, name='xfade')
if self.xfade_rec:
self.xfade_record = ControlRec(self.xfade, filename=paths[2], rate=1000, dur=totalTime).play()
################ gain ################
gain_init, self.gain_play, self.gain_rec = sinfo['gain'][0], sinfo['gain'][1], sinfo['gain'][2]
try:
self.gain_midi, gain_midictl, gain_midichnl = sinfo['gain'][3], sinfo['gain'][4], sinfo['gain'][5]
self.gain_osc = sinfo['gain'][6]
except:
self.gain_midi, gain_midictl, gain_midichnl = False, None, 1
self.gain_osc = None
line = graph_lines[self.name + 'gain']
curved = line.getCurved()
if curved:
self.gain_table = CosTable()
else:
self.gain_table = LinTable()
if not self.gain_play and not self.gain_midi:
self.gain_in = SigTo(value=gain_init, time=0.025, init=gain_init)
if self.gain_play:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph('gain', data)
self.gain_in = TableRead(self.gain_table, freq=1.0 / totalTime).play()
elif self.gain_midi:
self.gain_in = Midictl(gain_midictl, -48, 18, gain_init, gain_midichnl)
elif self.gain_osc is not None:
self.baseModule._addOpenSndCtrlWidget(self.gain_osc[0], self.gain_osc[1], self, name='gain')
if self.gain_rec:
self.gain_record = ControlRec(self.gain_in, filename=paths[3], rate=1000, dur=totalTime).play()
self.gain = Pow(10, self.gain_in * 0.05, mul=self.user_amp)
################ pitch ################
pitch_init, self.pitch_play, self.pitch_rec = sinfo['transp'][0], sinfo['transp'][1], sinfo['transp'][2]
try:
self.pitch_midi, pitch_midictl, pitch_midichnl = sinfo['transp'][3], sinfo['transp'][4], sinfo['transp'][5]
self.pitch_osc = sinfo['transp'][6]
except:
self.pitch_midi, pitch_midictl, pitch_midichnl = False, None, 1
self.pitch_osc = None
line = graph_lines[self.name + 'trans']
curved = line.getCurved()
if curved:
self.pitch_table = CosTable()
else:
self.pitch_table = LinTable()
if not self.pitch_play and not self.pitch_midi:
self.pitch_in = SigTo(value=pitch_init, time=0.025, init=pitch_init)
if self.pitch_play:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph('trans', data)
self.pitch_in = TableRead(self.pitch_table, freq=1.0 / totalTime).play()
elif self.pitch_midi:
self.pitch_in = Midictl(pitch_midictl, -48, 48, pitch_init, pitch_midichnl)
elif self.pitch_osc is not None:
self.baseModule._addOpenSndCtrlWidget(self.pitch_osc[0], self.pitch_osc[1], self, name='pitch')
if self.pitch_rec:
self.pitch_record = ControlRec(self.pitch_in, filename=paths[4], rate=1000, dur=totalTime).play()
self.pitch = Pow(1.0594630943593, self.pitch_in, self.user_pitch)
if CeciliaLib.getVar("automaticMidiBinding") and CeciliaLib.getVar("useMidi"):
self.checkNoteIn = Notein(poly=1, scale=0, first=0, last=120)
self.onNewNote = Change(self.checkNoteIn["pitch"])
self.noteTrigFunc = TrigFunc(self.onNewNote, self.newMidiPitch)
if self.mode == 0:
self.table = SndTable(info['path'], start=info["off" + self.name])
elif self.mode == 2:
self.table = NewTable(length=self.sampler.getOffset(), chnls=chnls)
self.livein = Input(chnl=[x for x in range(chnls)], mul=0.7)
self.filltabrec = TableRec(self.livein, self.table).play()
elif self.mode == 3:
self.table = NewTable(length=self.sampler.getOffset(), chnls=chnls)
self.table2 = NewTable(length=self.sampler.getOffset(), chnls=chnls)
self.livein = Input(chnl=[x for x in range(chnls)], mul=0.7)
self.rectrig = Metro(time=self.sampler.getOffset(), poly=2).play()
self.tmprec1 = TrigTableRec(self.livein, self.rectrig[0], self.table)
self.tmprec2 = TrigTableRec(self.livein, self.rectrig[1], self.table2)
self.morphind = Counter(self.rectrig.mix(1), min=0, max=2, dir=0)
self.interp = SigTo(self.morphind, time=0.1)
self.pitch_rnd = [x for x in self.parent.polyphony_spread for y in range(len(self.table))]
if self.mode != 3:
self.looper = Looper(table=self.table,
pitch=self.pitch * self.pitch_rnd,
start=self.start,
dur=self.dur,
xfade=self.xfade,
mode=sinfo['loopMode'],
xfadeshape=sinfo['xfadeshape'],
startfromloop=sinfo['startFromLoop'],
interp=4,
autosmooth=True,
mul=self.gain)
self.mix = Mix(self.looper, voices=chnls, mul=self.parent.polyphony_scaling)
else:
self.looper = Looper(table=self.table,
pitch=self.pitch * self.pitch_rnd,
start=self.start,
dur=self.dur,
xfade=self.xfade,
mode=sinfo['loopMode'],
xfadeshape=sinfo['xfadeshape'],
startfromloop=sinfo['startFromLoop'],
interp=4,
autosmooth=True,
mul=self.gain)
self.looper2 = Looper(table=self.table2,
pitch=self.pitch * self.pitch_rnd,
start=self.start,
dur=self.dur,
xfade=self.xfade,
mode=sinfo['loopMode'],
xfadeshape=sinfo['xfadeshape'],
startfromloop=sinfo['startFromLoop'],
interp=4,
autosmooth=True,
mul=self.gain)
self.loopinterp = Interp(self.looper, self.looper2, self.interp)
self.mix = Mix(self.loopinterp, voices=chnls, mul=self.parent.polyphony_scaling)
else:
self.mix = Input(chnl=[x for x in range(chnls)], mul=0.7)
def setValueFromOSC(self, val, name):
if self.mode != 1:
if name == 'start':
val = rescale(val, ymin=self.start_mini, ymax=self.start_maxi)
self.sampler.getSamplerFrame().loopInSlider.setValue(val)
if not self.sampler.getSamplerFrame().loopInSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().loopInSlider.sendValue(val)
elif name == 'dur':
val = rescale(val, ymin=self.dur_mini, ymax=self.dur_maxi)
self.sampler.getSamplerFrame().loopOutSlider.setValue(val)
if not self.sampler.getSamplerFrame().loopOutSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().loopOutSlider.sendValue(val)
elif name == 'xfade':
val = rescale(val, ymin=0, ymax=50)
self.sampler.getSamplerFrame().loopXSlider.setValue(val)
if not self.sampler.getSamplerFrame().loopXSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().loopXSlider.sendValue(val)
elif name == 'gain':
val = rescale(val, ymin=-48, ymax=18)
self.sampler.getSamplerFrame().gainSlider.setValue(val)
if not self.sampler.getSamplerFrame().gainSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().gainSlider.sendValue(val)
elif name == 'pitch':
val = rescale(val, ymin=-48, ymax=48)
self.sampler.getSamplerFrame().transpSlider.setValue(val)
if not self.sampler.getSamplerFrame().transpSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().transpSlider.sendValue(val)
def getWidget(self, name):
if name == 'start':
widget = self.sampler.getSamplerFrame().loopInSlider
elif name == 'dur':
widget = self.sampler.getSamplerFrame().loopOutSlider
elif name == 'xfade':
widget = self.sampler.getSamplerFrame().loopXSlider
elif name == 'gain':
widget = self.sampler.getSamplerFrame().gainSlider
elif name == 'pitch':
widget = self.sampler.getSamplerFrame().transpSlider
return widget
def updateWidgets(self):
if self.mode != 1:
if self.start_midi and not self.start_play:
val = self.start.get()
wx.CallAfter(self.sampler.getSamplerFrame().loopInSlider.setValue, val)
if self.dur_midi and not self.dur_play:
val = self.dur.get()
wx.CallAfter(self.sampler.getSamplerFrame().loopOutSlider.setValue, val)
if self.xfade_midi and not self.xfade_play:
val = self.xfade.get()
wx.CallAfter(self.sampler.getSamplerFrame().loopXSlider.setValue, val)
if self.gain_midi and not self.gain_play:
val = self.gain_in.get()
wx.CallAfter(self.sampler.getSamplerFrame().gainSlider.setValue, val)
if self.pitch_midi and not self.pitch_play:
val = self.pitch_in.get()
wx.CallAfter(self.sampler.getSamplerFrame().transpSlider.setValue, val)
def newMidiPitch(self):
if not self.pitch_midi:
pit = self.checkNoteIn.get()
self.sampler.getSamplerFrame().transpSlider.setValue(pit - 60)
if not self.sampler.getSamplerFrame().transpSlider.slider.IsShownOnScreen():
self.sampler.getSamplerFrame().transpSlider.sendValue(pit - 60)
def setGraph(self, which, func):
if self.mode != 1:
totalTime = CeciliaLib.getVar("totalTime")
func = [(int(x / totalTime * 8192), y) for x, y in func]
if which.endswith('start'):
self.start_table.replace(func)
elif which.endswith('end'):
self.dur_table.replace(func)
elif which.endswith('xfade'):
self.xfade_table.replace(func)
elif which.endswith('gain'):
self.gain_table.replace(func)
elif which.endswith('trans'):
self.pitch_table.replace(func)
def checkForAutomation(self):
if self.mode != 1:
if self.start_rec:
self.start_record.write()
if self.dur_rec:
self.dur_record.write()
if self.xfade_rec:
self.xfade_record.write()
if self.gain_rec:
self.gain_record.write()
if self.pitch_rec:
self.pitch_record.write()
def sig(self):
return self.mix
def getDur(self):
if self.mode != 1:
return self.table.getDur(False)
else:
return CeciliaLib.getVar("totalTime")
def setSound(self, snd):
if self.mode == 0:
self.table.setSound(snd)
def setStart(self, x):
if self.mode != 1:
if not self.start_play:
self.start.value = x
def setDur(self, x):
if self.mode != 1:
if not self.dur_play:
self.dur.value = x
def setXfade(self, x):
if self.mode != 1:
if not self.xfade_play:
self.xfade.value = x
def setGain(self, x):
if self.mode != 1:
if not self.gain_play:
self.gain_in.value = x
def setPitch(self, x):
if self.mode != 1:
if not self.pitch_play:
self.pitch_in.value = x
def setLoopMode(self, x):
if self.mode != 1:
self.looper.mode = x
if self.mode == 3:
self.looper2.mode = x
def setXfadeShape(self, x):
if self.mode != 1:
self.looper.xfadeshape = x
if self.mode == 3:
self.looper2.xfadeshape = x
class CeciliaSlider:
def __init__(self, dic, baseModule):
self.type = "slider"
self.name = dic["name"]
gliss = dic["gliss"]
up = dic["up"]
totalTime = CeciliaLib.getVar("totalTime")
self.baseModule = baseModule
if not up:
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name == self.name:
break
self.widget = line.slider
self.play = self.widget.getPlay()
self.rec = self.widget.getRec()
self.midi = self.widget.getWithMidi()
self.openSndCtrl = self.widget.getWithOSC()
curved = line.getCurved()
log = self.widget.getLog()
if curved and log:
self.table = CosLogTable()
elif curved:
self.table = CosTable()
elif log:
self.table = LogTable()
else:
self.table = LinTable()
else:
self.play = self.rec = self.midi = self.openSndCtrl = 0
for slider in CeciliaLib.getVar("userSliders"):
if slider.name == self.name:
self.widget = slider
break
init = self.widget.getValue()
mini = self.widget.getMinValue()
maxi = self.widget.getMaxValue()
log = self.widget.getLog()
self.slider = SigTo(init, time=gliss, init=init)
if self.rec:
self.record = ControlRec(self.slider, filename=self.widget.getPath(), rate=1000, dur=totalTime).play()
if self.play > 0:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph(data)
self.reader = TableRead(self.table, freq=1.0 / totalTime).play()
elif self.midi:
if log:
init = math.sqrt((init - mini) / (maxi - mini)) * (maxi - mini) + mini
exp = 2
else:
exp = 1
self.ctlin = Midictl(self.widget.getMidiCtl(), mini, maxi, init, self.widget.getMidiChannel())
self.reader = Scale(SigTo(self.ctlin), inmin=mini, inmax=maxi, outmin=mini, outmax=maxi, exp=exp)
elif self.openSndCtrl:
port, address = self.widget.getOpenSndCtrl()
self.baseModule._addOpenSndCtrlWidget(port, address, self)
def sig(self):
if self.play == 0:
return self.slider
else:
return self.reader
def setValue(self, x):
self.slider.value = x
def setGraph(self, func):
totalTime = CeciliaLib.getVar("totalTime")
func2 = [(int(x / totalTime * 8192), y) for x, y in func[:]]
oldX = -1
for i, f in enumerate(func2):
if f[0] == oldX:
func2[i] = (f[0]+1, f[1])
oldX = func2[i][0]
self.table.replace(func2)
def updateWidget(self):
val = self.reader.get()
wx.CallAfter(self.widget.setValue, val)
def setValueFromOSC(self, val):
val = rescale(val, ymin=self.widget.getMinValue(), ymax=self.widget.getMaxValue(), ylog=self.widget.getLog())
wx.CallAfter(self.widget.setValue, val)
class CeciliaRange:
def __init__(self, dic, baseModule):
self.type = "range"
self.name = dic["name"]
gliss = dic["gliss"]
up = dic["up"]
totalTime = CeciliaLib.getVar("totalTime")
self.baseModule = baseModule
self.oscTmpVals = [0, 0]
if not up:
self.graph_lines = [None, None]
for line in CeciliaLib.getVar("grapher").plotter.getData():
if self.name == line.name:
if line.suffix == "min":
self.graph_lines[0] = line
elif line.suffix == "max":
self.graph_lines[1] = line
self.widget = self.graph_lines[0].slider
self.play = self.widget.getPlay()
self.rec = self.widget.getRec()
self.midi = self.widget.getWithMidi()
self.openSndCtrl = self.widget.getWithOSC()
curved = [line.getCurved() for line in self.graph_lines]
if curved[0]:
self.table_min = CosTable()
else:
self.table_min = LinTable()
if curved[1]:
self.table_max = CosTable()
else:
self.table_max = LinTable()
else:
self.play = self.rec = self.midi = self.openSndCtrl = 0
for slider in CeciliaLib.getVar("userSliders"):
if slider.name == self.name:
self.widget = slider
break
init = self.widget.getValue()
mini = self.widget.getMinValue()
maxi = self.widget.getMaxValue()
log = self.widget.getLog()
self.slider = SigTo(init, time=gliss, init=init)
if self.rec:
self.record = ControlRec(self.slider, filename=self.widget.getPath(), rate=1000, dur=totalTime).play()
if self.play > 0:
data = self.graph_lines[0].getData()
data = [tuple(x) for x in data]
self.setGraph(0, data)
self.reader_min = TableRead(self.table_min, freq=1.0 / totalTime).play()
data = self.graph_lines[1].getData()
data = [tuple(x) for x in data]
self.setGraph(1, data)
self.reader_max = TableRead(self.table_max, freq=1.0 / totalTime).play()
self.reader = Mix([self.reader_min, self.reader_max], voices=2)
elif self.midi:
if log:
init = [math.sqrt((x - mini) / (maxi - mini)) * (maxi - mini) + mini for x in init]
exp = 2
else:
exp = 1
self.ctlin = Midictl(self.widget.getMidiCtl(), mini, maxi, init, self.widget.getMidiChannel())
self.reader = Scale(SigTo(self.ctlin), inmin=mini, inmax=maxi, outmin=mini, outmax=maxi, exp=exp)
elif self.openSndCtrl:
oscTuples = self.widget.getOpenSndCtrl()
if oscTuples[0] != ():
port, address = oscTuples[0][0], oscTuples[0][1]
self.baseModule._addOpenSndCtrlWidget(port, address, self, 0)
if oscTuples[1] != ():
port, address = oscTuples[1][0], oscTuples[1][1]
self.baseModule._addOpenSndCtrlWidget(port, address, self, 1)
def sig(self):
if self.play == 0:
return self.slider
else:
return self.reader
def setValue(self, x):
self.slider.value = x
def setGraph(self, which, func):
totalTime = CeciliaLib.getVar("totalTime")
func = [(int(x / totalTime * 8192), y) for x, y in func]
oldX = -1
for i, f in enumerate(func):
if f[0] == oldX:
func[i] = (f[0]+1, f[1])
oldX = func[i][0]
if which == 0:
self.table_min.replace(func)
else:
self.table_max.replace(func)
def updateWidget(self):
val = self.reader.get(all=True)
wx.CallAfter(self.widget.setValue, val)
def setValueFromOSC(self, val, which):
val = rescale(val, ymin=self.widget.getMinValue(), ymax=self.widget.getMaxValue(), ylog=self.widget.getLog())
wx.CallAfter(self.widget.setOneValue, val, which)
class CeciliaSplitter:
def __init__(self, dic):
self.type = "splitter"
self.name = dic["name"]
gliss = dic["gliss"]
up = dic["up"]
self.num_knobs = dic["num_knobs"]
totalTime = CeciliaLib.getVar("totalTime")
if 0: #if not up:
self.graph_lines = [None for i in range(self.num_knobs)]
for line in CeciliaLib.getVar("grapher").plotter.getData():
if self.name in line.name:
which = int(line.suffix[1:])
self.graph_lines[which] = line
self.widget = self.graph_lines[0].slider
self.play = self.widget.getPlay()
self.rec = self.widget.getRec()
self.tables = []
for curved in [line.getCurved() for line in self.graph_lines]:
if curved:
self.tables.append(CosTable())
else:
self.tables.append(LinTable())
else:
self.play = self.rec = self.midi = 0
for slider in CeciliaLib.getVar("userSliders"):
if slider.name == self.name:
self.widget = slider
break
init = self.widget.getValue()
self.slider = SigTo(init, time=gliss, init=init)
if self.rec:
self.record = ControlRec(self.slider, filename=self.widget.getPath(), rate=1000, dur=totalTime).play()
if self.play > 0:
self.readers = []
for i in range(self.num_knobs):
data = self.graph_lines[i].getData()
data = [tuple(x) for x in data]
self.setGraph(i, data)
self.readers.append(TableRead(self.tables[i], freq=1.0 / totalTime).play())
self.reader = Mix(self.readers, voices=self.num_knobs)
def sig(self):
if self.play == 0:
return self.slider
else:
return self.reader
def setValue(self, x):
self.slider.value = x
def setGraph(self, which, func):
totalTime = CeciliaLib.getVar("totalTime")
func = [(int(x / totalTime * 8192), y) for x, y in func]
oldX = -1
for i, f in enumerate(func):
if f[0] == oldX:
func[i] = (f[0]+1, f[1])
oldX = func[i][0]
self.tables[which].replace(func)
def updateWidget(self):
val = self.reader.get(all=True)
wx.CallAfter(self.widget.setValue, val)
class CeciliaGraph:
def __init__(self, dic):
self.name = dic["name"]
self.isTable = dic["table"]
self.size = dic["size"]
totalTime = CeciliaLib.getVar("totalTime")
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name == self.name:
break
func = [(int(x / totalTime * (self.size - 1)), y) for x, y in line.getData()]
oldX = -1
for i, f in enumerate(func):
if f[0] == oldX:
func[i] = (f[0]+1, f[1])
oldX = func[i][0]
curved = line.getCurved()
if curved:
self.table = CosTable(func, size=self.size)
else:
self.table = LinTable(func, size=self.size)
if not self.isTable:
self.reader = TableRead(self.table, freq=1.0 / totalTime).play()
def sig(self):
if self.isTable:
return self.table
else:
return self.reader
def setValue(self, func):
totalTime = CeciliaLib.getVar("totalTime")
func = [(int(x / totalTime * (self.size - 1)), y) for x, y in func]
oldX = -1
for i, f in enumerate(func):
if f[0] == oldX:
func[i] = (f[0]+1, f[1])
oldX = func[i][0]
self.table.replace(func)
class BaseModule:
def __init__(self):
self._fileins = {}
self._samplers = {}
self._sliders = {}
self._toggles = {}
self._popups = {}
self._buttons = {}
self._gens = {}
self._graphs = {}
self._polyphony = None
self._openSndCtrlDict = {}
self._openSndCtrlSliderDict = {}
self._OSCOutList = []
###### Public attributes ######
self.sr = CeciliaLib.getVar("sr")
self.nchnls = CeciliaLib.getVar("nchnls")
self.totalTime = CeciliaLib.getVar("totalTime")
self.server = CeciliaLib.getVar("audioServer").server
self.filepath = os.path.split(CeciliaLib.getVar("currentCeciliaFile", unicode=True))[0]
self.number_of_voices = 1
self.polyphony_spread = [1.0]
self.polyphony_scaling = 1.0
###############################
interfaceWidgets = CeciliaLib.getVar("interfaceWidgets")
for widget in interfaceWidgets:
if widget['type'] in ["cslider", "crange", "csplitter"]:
self._addSlider(widget, widget["type"])
elif widget['type'] == "cgraph":
self._addGraph(widget)
elif widget['type'] == "ctoggle":
if widget['rate'] == "k":
self._toggles[widget["name"]] = widget
elif widget['type'] == "cpopup":
if widget['rate'] == "k":
self._popups[widget["name"]] = widget
elif widget['type'] == "cbutton":
self._buttons[widget["name"]] = widget
elif widget['type'] == "cgen":
if widget['rate'] == "k":
self._gens[widget["name"]] = widget
elif widget['type'] == "cpoly" and self._polyphony is None:
self._polyphony = widget
userTogglePopups = CeciliaLib.getVar("userTogglePopups")
polyname = "noPolyphonyWidget"
if self._polyphony is not None:
polyname = self._polyphony["name"]
for togPop in userTogglePopups:
if togPop.name.startswith(polyname):
if togPop.name.endswith("num"):
self.number_of_voices = togPop.getValue() + 1
else:
self._definePolyTranspo(togPop.getLabel())
if togPop.type == "popup":
name = togPop.name
setattr(self, name + "_index", togPop.getValue())
setattr(self, name + "_value", togPop.getLabel())
elif togPop.type == "toggle":
name = togPop.name
setattr(self, name + "_value", togPop.getValue())
elif togPop.type == "gen":
name = togPop.name
setattr(self, name + "_value", togPop.getValue())
self._metro = Metro(.06).play(dur=self.totalTime)
self._updater = TrigFunc(self._metro, self._updateWidgets).play(dur=self.totalTime)
###### Public methods ######
def addFilein(self, name):
"""
Creates a SndTable object from the name of a cfilein widget.
A SndTable is a memory filled with the samples of the current audio file.
Parameters:
name : string
The name assigned to a cfilein widget in the Interface declaration.
"""
self._fileins[name] = CeciliaFilein(self, name)
return self._fileins[name].sig()
def addSampler(self, name, pitch=1, amp=1):
"""
Creates a sampler/looper from the name of a csampler widget.
A sampler comes with an interface window allowing the control of the looping
parameters (direction, start point, loop duration, crossfade duration, gain,
pitch, etc.)
Parameters:
pitch : float or PyoObject
External pitch control added to the value of the transposition slider.
amp : float or PyoObject
External amplitude control added to the value of the gain slider.
"""
self._samplers[name] = CeciliaSampler(self, name, pitch, amp)
return self._samplers[name].sig()
def getSamplerDur(self, name):
return self._samplers[name].getDur()
def duplicate(self, seq, num):
"""
Duplicates elements in a sequence according to the `num` parameter.
This method is useful to creates lists that match the number of channels
multiplied by the number of voices from a cpoly or a splitter widget.
Parameters:
seq : list
List of values to duplicate.
num : int
Number of iteration for each value in the sequence.
Example:
freqs = duplicate([100, 200, 300], 4)
print(freqs)
[100, 100, 100, 100, 200, 200, 200, 200, 300, 300, 300, 300]
"""
tmp = [x for x in seq for i in range(num)]
return tmp
def setGlobalSeed(self, x):
"""
Sets the Server's global seed used by objects from the random family.
"""
CeciliaLib.getVar("audioServer").server.globalseed = x
############################
###### Private methods ######
def _definePolyTranspo(self, chord):
if self.number_of_voices <= 1:
return
tmp = 0
for i in range(self.number_of_voices):
tmp -= {0: 0, 1: 3, 2: 3, 3: 2, 4: 2, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1}.get(i, 1)
self.polyphony_scaling = pow(10.0, tmp * 0.05)
if chord == "None":
self.polyphony_spread = [1.0] * self.number_of_voices
return
else:
self.polyphony_spread = [1.0]
pool = POLY_CHORDS[chord]
for i in range(1, self.number_of_voices):
note = pool[i % len(pool)]
if i % 2 == 1 or note < 1.0:
self.polyphony_spread.append(midiToTranspo(note + 60))
else:
self.polyphony_spread.append(midiToTranspo(note - 12 + 60))
def _deleteOscReceivers(self):
if hasattr(self, "oscReceivers"):
for key in list(self.oscReceivers.keys()):
del self.oscReceivers[key]
del self.oscReceivers
def _createOpenSndCtrlReceivers(self):
if self._openSndCtrlDict:
self.oscReceivers = {}
for key in self._openSndCtrlDict.keys():
self.oscReceivers[key] = OscReceive(key, self._openSndCtrlDict[key])
for slider in self._openSndCtrlSliderDict[key]:
if isinstance(slider, tuple):
slider, side = slider[0], slider[1]
if slider.type == "sampler": # sampler slider
widget = slider.getWidget(side)
path = widget.openSndCtrl[1]
val = rescale(widget.getValue(), xmin=widget.getMinValue(), xmax=widget.getMaxValue(), xlog=widget.getLog())
self.oscReceivers[key].setValue(path, val)
if widget.OSCOut is not None:
tmpout = OscDataSend("f", widget.OSCOut[1], widget.OSCOut[2], widget.OSCOut[0])
tmpout.send([val])
self._OSCOutList.append(tmpout)
else: # range slider
widget = slider.widget
path = widget.openSndCtrl[side][1]
val = rescale(widget.getValue()[side], xmin=widget.getMinValue(), xmax=widget.getMaxValue(), xlog=widget.getLog())
self.oscReceivers[key].setValue(path, val)
if widget.OSCOut is not None:
if widget.OSCOut[side] != ():
tmpout = OscDataSend("f", widget.OSCOut[side][1], widget.OSCOut[side][2], widget.OSCOut[side][0])
tmpout.send([val])
self._OSCOutList.append(tmpout)
else: # slider TODO: could be merged with sampler slider code.
widget = slider.widget
path = widget.openSndCtrl[1]
val = rescale(widget.getValue(), xmin=widget.getMinValue(), xmax=widget.getMaxValue(), xlog=widget.getLog())
self.oscReceivers[key].setValue(path, val)
if widget.OSCOut is not None:
tmpout = OscDataSend("f", widget.OSCOut[1], widget.OSCOut[2], widget.OSCOut[0])
tmpout.send([val])
self._OSCOutList.append(tmpout)
def _addOpenSndCtrlWidget(self, port, address, slider, side=0, name=""):
if port in self._openSndCtrlDict:
self._openSndCtrlDict[port].append(address)
if slider.type == 'sampler':
self._openSndCtrlSliderDict[port].append((slider, name))
elif slider.type == 'slider':
self._openSndCtrlSliderDict[port].append(slider)
elif slider.type == 'range':
self._openSndCtrlSliderDict[port].append((slider, side))
else:
self._openSndCtrlDict[port] = [address]
if slider.type == 'sampler':
self._openSndCtrlSliderDict[port] = [(slider, name)]
elif slider.type == 'slider':
self._openSndCtrlSliderDict[port] = [slider]
elif slider.type == 'range':
self._openSndCtrlSliderDict[port] = [(slider, side)]
def _checkForAutomation(self):
for sampler in self._samplers.values():
sampler.checkForAutomation()
for slider in self._sliders.values():
if slider.rec:
slider.record.write()
def _updateWidgets(self):
if self._samplers != {}:
for key in self._samplers.keys():
self._samplers[key].updateWidgets()
for slider in self._sliders.values():
if slider.play == 1 or slider.midi:
slider.updateWidget()
if self._openSndCtrlDict:
for key in self._openSndCtrlDict.keys():
values = self.oscReceivers[key].get(all=True)
for i in range(len(values)):
slider = self._openSndCtrlSliderDict[key][i]
if isinstance(slider, tuple):
which = slider[1]
slider[0].setValueFromOSC(values[i], which)
else:
slider.setValueFromOSC(values[i])
CeciliaLib.getVar("audioServer").updatePluginWidgets()
def _setWidgetValues(self):
# graph lines
for line in CeciliaLib.getVar("grapher").plotter.getData():
name = line.getName()
if name in self._graphs.keys():
data = line.getData()
self._graphs[name].setValue(data)
# sliders
for slider in CeciliaLib.getVar("userSliders"):
name = slider.getName()
self._sliders[name].setValue(slider.getValue())
# toggles and popups
for togPop in CeciliaLib.getVar("userTogglePopups"):
name = togPop.getName()
if name in self._toggles:
getattr(self, name)(togPop.getValue())
elif name in self._popups:
index, label = togPop.getFullValue()
getattr(self, name)(index, label)
elif name in self._gens:
getattr(self, name)(togPop.getValue())
def _addSlider(self, dic, typ):
if typ == "cslider":
self._sliders[dic["name"]] = CeciliaSlider(dic, self)
elif typ == "crange":
self._sliders[dic["name"]] = CeciliaRange(dic, self)
elif typ == "csplitter":
self._sliders[dic["name"]] = CeciliaSplitter(dic)
setattr(self, dic["name"], self._sliders[dic["name"]].sig())
def _addGraph(self, dic):
self._graphs[dic["name"]] = CeciliaGraph(dic)
setattr(self, dic["name"], self._graphs[dic["name"]].sig())
def _cleanup(self):
self.oscReceivers = {}
self._OSCOutList = []
for key in list(self.__dict__.keys()):
del self.__dict__[key]
class CeciliaPlugin:
def __init__(self, input, params=None, knobs=None):
self.input = Sig(input)
gliss = 0.05
totalTime = CeciliaLib.getVar("totalTime")
if params is None:
self._p1 = SigTo(0, time=0.025)
self._p2 = SigTo(0, time=0.025)
self._p3 = SigTo(0, time=0.025)
else:
# TODO: merge these three chunks in a single loop.
self.widget_p1 = knobs[0]
name = self.widget_p1.getName()
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name == name:
break
self.play_p1 = self.widget_p1.getPlay()
self.rec_p1 = self.widget_p1.getRec()
self.midi_p1 = self.widget_p1.getWithMidi()
curved = line.getCurved()
if curved:
self.table_p1 = CosTable()
else:
self.table_p1 = LinTable()
init = self.widget_p1.getValue()
mini = self.widget_p1.getMinValue()
maxi = self.widget_p1.getMaxValue()
log = self.widget_p1.getLog()
self._p1 = SigTo(params[0], time=gliss, init=params[0])
if self.rec_p1:
self.record_p1 = ControlRec(self._p1, filename=self.widget_p1.getPath(),
rate=1000, dur=totalTime).play()
if self.play_p1 > 0:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph(0, data)
self.reader_p1 = TableRead(self.table_p1, freq=1.0 / totalTime).play()
elif self.midi_p1:
if log:
init = math.sqrt((init - mini) / (maxi - mini)) * (maxi - mini) + mini
exp = 2
else:
exp = 1
self.ctlin_p1 = Midictl(self.widget_p1.getMidiCtl(), mini, maxi, init, self.widget_p1.getMidiChannel())
self.reader_p1 = Scale(self.ctlin_p1, inmin=mini, inmax=maxi, outmin=mini, outmax=maxi, exp=exp)
self.widget_p2 = knobs[1]
name = self.widget_p2.getName()
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name == name:
break
self.play_p2 = self.widget_p2.getPlay()
self.rec_p2 = self.widget_p2.getRec()
self.midi_p2 = self.widget_p2.getWithMidi()
curved = line.getCurved()
if curved:
self.table_p2 = CosTable()
else:
self.table_p2 = LinTable()
init = self.widget_p2.getValue()
mini = self.widget_p2.getMinValue()
maxi = self.widget_p2.getMaxValue()
log = self.widget_p2.getLog()
self._p2 = SigTo(params[1], time=gliss, init=params[1])
if self.rec_p2:
self.record_p2 = ControlRec(self._p2, filename=self.widget_p2.getPath(),
rate=1000, dur=totalTime).play()
if self.play_p2 > 0:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph(1, data)
self.reader_p2 = TableRead(self.table_p2, freq=1.0 / totalTime).play()
elif self.midi_p2:
if log:
init = math.sqrt((init - mini) / (maxi - mini)) * (maxi - mini) + mini
exp = 2
else:
exp = 1
self.ctlin_p2 = Midictl(self.widget_p2.getMidiCtl(), mini, maxi, init, self.widget_p2.getMidiChannel())
self.reader_p2 = Scale(self.ctlin_p2, inmin=mini, inmax=maxi, outmin=mini, outmax=maxi, exp=exp)
self.widget_p3 = knobs[2]
name = self.widget_p3.getName()
for line in CeciliaLib.getVar("grapher").plotter.getData():
if line.name == name:
break
self.play_p3 = self.widget_p3.getPlay()
self.rec_p3 = self.widget_p3.getRec()
self.midi_p3 = self.widget_p3.getWithMidi()
curved = line.getCurved()
if curved:
self.table_p3 = CosTable()
else:
self.table_p3 = LinTable()
init = self.widget_p3.getValue()
mini = self.widget_p3.getMinValue()
maxi = self.widget_p3.getMaxValue()
log = self.widget_p3.getLog()
self._p3 = SigTo(params[2], time=gliss, init=params[2])
if self.rec_p3:
self.record_p3 = ControlRec(self._p3, filename=self.widget_p3.getPath(),
rate=1000, dur=totalTime).play()
if self.play_p3 > 0:
data = line.getData()
data = [tuple(x) for x in data]
self.setGraph(2, data)
self.reader_p3 = TableRead(self.table_p3, freq=1.0 / totalTime).play()
elif self.midi_p3:
if log:
init = math.sqrt((init - mini) / (maxi - mini)) * (maxi - mini) + mini
exp = 2
else:
exp = 1
self.ctlin_p3 = Midictl(self.widget_p3.getMidiCtl(), mini, maxi, init, self.widget_p3.getMidiChannel())
self.reader_p3 = Scale(self.ctlin_p3, inmin=mini, inmax=maxi, outmin=mini, outmax=maxi, exp=exp)
self.preset = params[3]
def sig1(self):
if self.play_p1 == 0 and not self.midi_p1:
return self._p1
else:
return self.reader_p1
def sig2(self):
if self.play_p2 == 0 and not self.midi_p2:
return self._p2
else:
return self.reader_p2
def sig3(self):
if self.play_p3 == 0 and not self.midi_p3:
return self._p3
else:
return self.reader_p3
def setPreset(self, x, label):
self.preset = x
if self.preset == 0:
self.out.interp = 0
else:
self.out.interp = 1
def setInput(self, input):
self.input.value = input
def setGraph(self, which, func):
totalTime = CeciliaLib.getVar("totalTime")
func = [(int(x / totalTime * 8192), y) for x, y in func]
if which == 0:
self.table_p1.replace(func)
elif which == 1:
self.table_p2.replace(func)
elif which == 2:
self.table_p3.replace(func)
def stopControls(self):
self._p1.stop()
self._p2.stop()
self._p3.stop()
def startControls(self):
self._p1.play()
self._p2.play()
self._p3.play()
def setValue(self, which, x):
if which == 0:
self._p1.value = x
elif which == 1:
self._p2.value = x
elif which == 2:
self._p3.value = x
def checkForAutomation(self):
if self.rec_p1:
self.record_p1.write()
if self.rec_p2:
self.record_p2.write()
if self.rec_p3:
self.record_p3.write()
def updateWidget(self):
if self.play_p1 or self.midi_p1:
val = self.reader_p1.get()
wx.CallAfter(self.widget_p1.setValue, val)
if self.play_p2 or self.midi_p2:
val = self.reader_p2.get()
wx.CallAfter(self.widget_p2.setValue, val)
if self.play_p3 or self.midi_p3:
val = self.reader_p3.get()
wx.CallAfter(self.widget_p3.setValue, val)
class CeciliaNonePlugin(CeciliaPlugin):
def __init__(self, input):
CeciliaPlugin.__init__(self, input)
self.out = self.input
self.stopControls()
class CeciliaReverbPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
self.out = Freeverb(self.input, size=self.sig2() * 0.1, damp=self.sig3(), bal=self.sig1() * self.preset)
def setPreset(self, x, label):
self.preset = x
self.out.bal = self.sig1() * self.preset
class CeciliaWGReverbPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
self.out = WGVerb(self.input, feedback=self.sig2(), cutoff=self.sig3(), bal=self.sig1() * self.preset)
def setPreset(self, x, label):
self.preset = x
self.out.bal = self.sig1() * self.preset
class CeciliaFilterPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
typ = 0
else:
inter = 1
typ = self.preset - 1
self.filter = Biquad(self.input, freq=self.sig2(), q=self.sig3(), type=typ, mul=self.sig1())
self.out = Interp(self.input, self.filter, inter)
def setPreset(self, x, label):
self.preset = x
if self.preset == 0:
self.out.interp = 0
else:
self.filter.type = self.preset - 1
self.out.interp = 1
class CeciliaEQPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
typ = 0
else:
inter = 1
typ = self.preset - 1
self.filter = EQ(self.input, freq=self.sig1(), q=self.sig2(), boost=self.sig3(), type=typ)
self.out = Interp(self.input, self.filter, inter)
def setPreset(self, x, label):
self.preset = x
if self.preset == 0:
self.out.interp = 0
else:
self.filter.type = self.preset - 1
self.out.interp = 1
class CeciliaChorusPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
self.out = Chorus(self.input, depth=self.sig2(), feedback=self.sig3(), bal=self.sig1() * self.preset)
def setPreset(self, x, label):
self.preset = x
self.out.bal = self.sig1() * self.preset
class CeciliaEQ3BPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.low = EQ(self.input, freq=250, q=0.707, boost=self.sig1(), type=1)
self.mid = EQ(self.low, freq=1500, q=0.707, boost=self.sig2(), type=0)
self.high = EQ(self.mid, freq=2500, q=0.707, boost=self.sig3(), type=2)
self.out = Interp(self.input, self.high, inter)
class CeciliaCompressPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.dbtoamp = DBToA(self.sig3())
self.comp = Compress(self.input, thresh=self.sig1(), ratio=self.sig2(), lookahead=4, knee=.5, mul=self.dbtoamp)
self.out = Interp(self.input, self.comp, inter)
class CeciliaGatePlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.gate = Gate(self.input, thresh=self.sig1(), risetime=self.sig2(), falltime=self.sig3(), lookahead=4)
self.out = Interp(self.input, self.gate, inter)
class CeciliaDistoPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.gain = DBToA(self.sig3())
self.disto = Disto(self.input, drive=self.sig1(), slope=self.sig2(), mul=self.gain)
self.out = Interp(self.input, self.disto, inter)
class CeciliaAmpModPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
mode = self.preset - 1
inter = 1
self.zero = Sig(0)
if len(self.input) < 2:
self.lfoamp = Sine(freq=self.sig1(), mul=.5, add=.5)
self.iamp = 1.0 - self.sig2()
self.modamp = self.input * (self.lfoamp * self.sig2() + self.iamp)
self.lforing = Sine(freq=self.sig1(), mul=self.sig2())
self.modring = self.input * self.lforing
else:
self.lfoamp = Sine(freq=self.sig1(), phase=[self.zero, self.sig3()], mul=.5, add=.5)
self.iamp = 1.0 - self.sig2()
self.modamp = self.input * (self.lfoamp * self.sig2() + self.iamp)
self.lforing = Sine(freq=self.sig1(), phase=[self.zero, self.sig3()], mul=self.sig2())
self.modring = self.input * self.lforing
if mode == 0:
self.out = Interp(self.input, self.modamp, inter)
else:
self.out = Interp(self.input, self.modring, inter)
def setPreset(self, x, label):
self.preset = x
if self.preset == 0:
self.out.interp = 0
else:
if self.preset == 1:
self.out.input2 = self.modamp
else:
self.out.input2 = self.modring
self.out.interp = 1
class CeciliaPhaserPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.phaser = Phaser(self.input, freq=self.sig1(), spread=self.sig3(), q=self.sig2(), feedback=0.8, num=8, mul=.5)
self.out = Interp(self.input, self.phaser, inter)
class CeciliaDelayPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.gain = DBToA(self.sig3())
self.delaytime = SigTo(self.sig1(), time=.1, init=.1)
self.delay = Delay(self.input, delay=self.delaytime, feedback=self.sig2())
self.delaymix = Interp(self.input, self.delay, self.sig3())
self.out = Interp(self.input, self.delaymix, inter)
class CeciliaFlangePlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.lfo = Sine(freq=self.sig2(), mul=self.sig1() * 0.005, add=0.005)
self.delay = Delay(self.input, delay=self.lfo, feedback=self.sig3())
self.delaymix = self.delay + self.input
self.out = Interp(self.input, self.delaymix, inter)
class CeciliaHarmonizerPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.harmo = Harmonizer(self.input, transpo=self.sig1(), feedback=self.sig2())
self.mix = Interp(self.input, self.harmo, self.sig3())
self.out = Interp(self.input, self.mix, inter)
class CeciliaResonatorsPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.wg1 = Waveguide(self.input, freq=self.sig1(), dur=30, mul=.05)
self.f2 = self.sig1() * self.sig2()
self.wg2 = Waveguide(self.input, freq=self.f2, dur=30, mul=.05)
self.f3 = self.sig1() * self.sig2() * self.sig2()
self.wg3 = Waveguide(self.input, freq=self.f3, dur=30, mul=.05)
self.f4 = self.sig1() * self.sig2() * self.sig2() * self.sig2()
self.wg4 = Waveguide(self.input, freq=self.f4, dur=30, mul=.05)
self.total = self.wg1 + self.wg2 + self.wg3 + self.wg4
self.mix = Interp(self.input, self.total, self.sig3())
self.out = Interp(self.input, self.mix, inter)
class CeciliaDeadResonPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
if self.preset == 0:
inter = 0
else:
inter = 1
self.wg1 = AllpassWG(self.input, freq=self.sig1(), feed=.995, detune=self.sig2(), mul=.1)
self.wg2 = AllpassWG(self.input, freq=self.sig1() * 0.993, feed=.995, detune=self.sig2(), mul=.1)
self.total = self.wg1 + self.wg2
self.mix = Interp(self.input, self.total, self.sig3())
self.out = Interp(self.input, self.mix, inter)
class CeciliaChaosModPlugin(CeciliaPlugin):
def __init__(self, input, params, knobs):
CeciliaPlugin.__init__(self, input, params, knobs)
self.lfolo = Lorenz(self.sig1(), self.sig2(), stereo=True, mul=0.5, add=0.5).stop()
self.lforo = Rossler(self.sig1(), self.sig2(), stereo=True, mul=0.5, add=0.5).stop()
self.lfoch = ChenLee(self.sig1(), self.sig2(), stereo=True, mul=0.5, add=0.5).stop()
self.lfo = Sig(self.lfolo)
self.iamp = 1.0 - self.sig3()
self.modu = self.input * (self.lfo * self.sig3() + self.iamp)
if self.preset == 0:
inter = 0
else:
if self.preset == 1:
self.lfo.value = self.lfolo.play()
elif self.preset == 2:
self.lfo.value = self.lfoch.play()
else:
self.lfo.value = self.lforo.play()
inter = 1
self.out = Interp(self.input, self.modu, inter)
def setPreset(self, x, label):
self.preset = x
if self.preset == 0:
self.out.interp = 0
else:
self.lfo.value.stop()
if self.preset == 1:
self.lfo.value = self.lfolo.play()
elif self.preset == 2:
self.lfo.value = self.lfoch.play()
else:
self.lfo.value = self.lforo.play()
self.out.interp = 1
class AudioServer():
def __init__(self):
self.amp = 1.0
sr, bufsize, nchnls, duplex, host, outdev, indev, firstin, firstout = self.getPrefs()
jackname = CeciliaLib.getVar("jack").get("client", "cecilia5")
if CeciliaLib.getVar("DEBUG"):
print("AUDIO CONFIG:")
template = "sr: %s, buffer size: %s, num of channels: %s, duplex: %s, host: %s, output device: %s, input device: %s"
print(template % (sr, bufsize, nchnls, duplex, host, outdev, indev))
print("first physical input: %s, first physical output: %s\n" % (firstin, firstout))
self.server = Server(sr=sr, buffersize=bufsize, nchnls=nchnls, duplex=duplex, audio=host, jackname=jackname)
if CeciliaLib.getVar("DEBUG"):
self.server.verbosity = 15
if host == 'jack':
self.server.setJackAuto(True, True)
self.setTimeCallable()
self.timeOpened = True
self.recording = False
self.withTimer = False
self.withSpectrum = False
self.pluginObjs = [None] * NUM_OF_PLUGINS
self.out = self.spectrum = None
self.pluginDict = {"Reverb": CeciliaReverbPlugin, "WGVerb": CeciliaWGReverbPlugin, "Filter": CeciliaFilterPlugin, "Para EQ": CeciliaEQPlugin,
"Chorus": CeciliaChorusPlugin, "3 Bands EQ": CeciliaEQ3BPlugin, "Compress": CeciliaCompressPlugin, "Gate": CeciliaGatePlugin,
"Disto": CeciliaDistoPlugin, "AmpMod": CeciliaAmpModPlugin, "Phaser": CeciliaPhaserPlugin, "Delay": CeciliaDelayPlugin,
"Flange": CeciliaFlangePlugin, "Harmonizer": CeciliaHarmonizerPlugin, "Resonators": CeciliaResonatorsPlugin,
"DeadReson": CeciliaDeadResonPlugin, 'ChaosMod': CeciliaChaosModPlugin}
def updateDebug(self):
if CeciliaLib.getVar("DEBUG"):
self.server.verbosity = 15
else:
self.server.verbosity = 7
def getPrefs(self):
sr = CeciliaLib.getVar("sr")
bufsize = int(CeciliaLib.getVar("bufferSize"))
nchnls = CeciliaLib.getVar("nchnls")
duplex = CeciliaLib.getVar("enableAudioInput")
host = CeciliaLib.getVar("audioHostAPI")
outdev = CeciliaLib.getVar("audioOutput")
indev = CeciliaLib.getVar("audioInput")
firstin = CeciliaLib.getVar("defaultFirstInput")
firstout = CeciliaLib.getVar("defaultFirstOutput")
return sr, bufsize, nchnls, duplex, host, outdev, indev, firstin, firstout
def dump(self, l):
pass
def start(self, timer=True, rec=False):
if CeciliaLib.getVar("DEBUG"):
print("Audio server start: begin")
self.timeOpened = True
fade = CeciliaLib.getVar("globalFade")
self.globalamp = Fader(fadein=fade, fadeout=fade, dur=CeciliaLib.getVar("totalTime")).play()
self.out.mul = self.globalamp
if CeciliaLib.getVar("automaticMidiBinding") and CeciliaLib.getVar("useMidi"):
if CeciliaLib.getVar("DEBUG"):
print("Audio server start: use midi")
print("midi input device: %d" % CeciliaLib.getVar("midiDeviceIn"))
self.checkCtl7 = Midictl(ctlnumber=7, minscale=-48, maxscale=18, init=0)
self.onNewCtl7Value = Change(self.checkCtl7)
self.ctl7TrigFunc = TrigFunc(self.onNewCtl7Value, self.newCtl7Value)
if rec:
self.recording = True
fileformat = AUDIO_FILE_FORMATS[CeciliaLib.getVar("audioFileType")]
sampletype = CeciliaLib.getVar("sampSize")
self.recamp = SigTo(self.amp, time=0.05, init=self.amp)
self.recorder = Record(self.pluginObjs[-1].out * self.recamp,
CeciliaLib.getVar("outputFile"), CeciliaLib.getVar("nchnls"),
fileformat=fileformat, sampletype=sampletype, buffering=8)
if CeciliaLib.getVar("showSpectrum"):
self.withSpectrum = True
self.specamp = SigTo(self.amp, time=0.05, init=self.amp, mul=self.pluginObjs[-1].out)
self.spectrum = Spectrum(self.specamp, function=self.dump)
if CeciliaLib.getVar("startOffset") > 0.0:
self.server.startoffset = CeciliaLib.getVar("startOffset")
if timer:
self.withTimer = True
self.server.start()
else:
self.server.start()
CeciliaLib.resetControls()
if CeciliaLib.getVar("DEBUG"):
print("Audio server start: end\n")
def stop(self):
if CeciliaLib.getVar("DEBUG"):
print("Audio server stop: begin")
if self.withTimer:
self.withTimer = False
self.server.stop()
if self.recording:
self.recording = False
self.recorder.stop()
if self.withSpectrum:
self.withSpectrum = False
self.spectrum.poll(False)
self.spectrum.stop()
self.timeOpened = False
if CeciliaLib.getVar("grapher") is not None:
CeciliaLib.getVar("grapher").cursorPanel.setTime(CeciliaLib.getVar("startOffset"))
time.sleep(.15)
if CeciliaLib.getVar("currentModule") is not None:
CeciliaLib.getVar("currentModule")._deleteOscReceivers()
if CeciliaLib.getVar("DEBUG"):
print("Audio server stop: end\n")
def shutdown(self):
self.server.shutdown()
def boot(self):
sr, bufsize, nchnls, duplex, host, outdev, indev, firstin, firstout = self.getPrefs()
if CeciliaLib.getVar("DEBUG"):
print("AUDIO CONFIG:")
template = "sr: %s, buffer size: %s, num of channels: %s, duplex: %s, host: %s, output device: %s, input device: %s"
print(template % (sr, bufsize, nchnls, duplex, host, outdev, indev))
print("first physical input: %s, first physical output: %s\n" % (firstin, firstout))
print("MIDI CONFIG: \ninput device: %d\n" % CeciliaLib.getVar("midiDeviceIn"))
self.server.setSamplingRate(sr)
self.server.setBufferSize(bufsize)
self.server.setNchnls(nchnls)
self.server.setDuplex(duplex)
self.server.setOutputDevice(outdev)
self.server.setInputOffset(firstin)
self.server.setOutputOffset(firstout)
if CeciliaLib.getVar("enableAudioInput"):
self.server.setInputDevice(indev)
if CeciliaLib.getVar("useMidi"):
self.server.setMidiInputDevice(CeciliaLib.getVar("midiDeviceIn"))
self.server.boot()
def reinit(self):
jackname = CeciliaLib.getVar("jack").get("client", "cecilia5")
if CeciliaLib.getVar("toDac"):
sr, bufsize, nchnls, duplex, host, outdev, indev, firstin, firstout = self.getPrefs()
self.server.reinit(audio=host, jackname=jackname)
else:
self.server.reinit(audio="offline_nb", jackname=jackname)
dur = CeciliaLib.getVar("totalTime")
filename = CeciliaLib.getVar("outputFile")
fileformat = AUDIO_FILE_FORMATS[CeciliaLib.getVar("audioFileType")]
sampletype = CeciliaLib.getVar("sampSize")
self.server.recordOptions(dur=dur, filename=filename, fileformat=fileformat, sampletype=sampletype)
def setAmpCallable(self, callable):
self.server._server.setAmpCallable(callable)
def setTimeCallable(self):
self.server._server.setTimeCallable(self)
def setTime(self, *args):
if len(args) >= 4 and self.timeOpened:
time = args[1] * 60 + args[2] + args[3] * 0.001
CeciliaLib.getVar("grapher").cursorPanel.setTime(time)
CeciliaLib.getVar("interface").controlPanel.setTime(time, args[1], args[2], args[3] // 10)
if time >= (CeciliaLib.getVar("totalTime") - 0.5):
wx.CallAfter(CeciliaLib.getControlPanel().closeBounceToDiskDialog)
if time >= (CeciliaLib.getVar("totalTime")):
wx.CallAfter(CeciliaLib.stopCeciliaSound)
else:
CeciliaLib.getVar("grapher").cursorPanel.setTime(CeciliaLib.getVar("startOffset"))
CeciliaLib.getVar("interface").controlPanel.setTime(0, 0, 0, 0)
def recstart(self):
self.server.recstart()
def recstop(self):
self.server.recstop()
def newCtl7Value(self):
val = self.checkCtl7.get()
CeciliaLib.getControlPanel().gainSlider.SetValue(val)
def setAmp(self, x):
self.amp = math.pow(10.0, x * 0.05)
self.server.amp = self.amp
try:
self.recamp.value = self.amp
except:
pass
try:
self.specamp.value = self.amp
except:
pass
def setInOutDevice(self, device):
self.server.setInOutDevice(device)
def setMidiInputDevice(self, device):
self.server.setMidiInputDevice(device)
def setSamplingRate(self, sr):
self.server.setSamplingRate(sr)
def recordOptions(self, dur, filename, fileformat, sampletype):
self.server.recordOptions(dur, filename, fileformat, sampletype)
def isAudioServerRunning(self):
return self.server.getIsStarted()
def isAudioServerBooted(self):
return self.server.getIsBooted()
def compileRuntimeError(self, filepath, title, msg):
error = traceback.format_exc()
#print("============== Error:\n", error, "=====================\n")
if "exec(f.read(), globals())" in error:
pos = error.find("exec(f.read(), globals())")
error = error[pos:].replace("exec(f.read(), globals())", "")
linenum = -1
if "line " in error:
try:
pos1 = error.rfind("line ") + 5
pos2 = pos1
while error[pos2] in "0123456789":
pos2 += 1
linenum = int(error[pos1:pos2].strip())
except:
pass
codeline = ""
if linenum != -1:
try:
codeline = "Please review this part of the code and reload the module:\n\n#-----\n"
with open(filepath, "r") as f:
_text = f.readlines()
if linenum > 0:
codeline = codeline + _text[linenum-1] + _text[linenum] + "#-----\n"
else:
codeline = codeline + _text[linenum] + "#-----\n"
except:
pass
tracelines = error
tracelines = "Traceback:\n\n" + tracelines.replace("", filepath) + "\n\n"
msg = msg + tracelines + codeline
CeciliaLib.showErrorDialog(title, msg)
def openCecFile(self, filepath):
global Module, Interface
try:
del Module, Interface
except:
pass
if not serverBooted():
self.boot()
self.cleanup_module()
CeciliaLib.setVar("currentModule", None)
CeciliaLib.setVar("currentModuleRef", None)
CeciliaLib.setVar("interfaceWidgets", [])
CeciliaLib.setVar("startOffset", 0.0)
CeciliaLib.checkForPresetsInCeciliaFile(filepath)
try:
with open(filepath, "r") as f:
exec(f.read(), globals())
except Exception as e:
# If it fails, show the error and reload the current module.
msg = "Cecilia can't compile the chosen module, Current module (or a random one if this failed too) will be reloaded.\n\n"
self.compileRuntimeError(filepath, "Syntax Error!", msg)
if os.path.isfile(MODULE_COMPILE_BACKUP_PATH):
CeciliaLib.openCeciliaFile(None, MODULE_COMPILE_BACKUP_PATH,
CeciliaLib.getVar("builtinModule"))
else:
CeciliaLib.getVar("mainFrame").onOpenRandom(None)
return False
CeciliaLib.setVar("currentModuleRef", copy.deepcopy(Module))
CeciliaLib.setVar("interfaceWidgets", CeciliaLib.deepCopy(Interface))
CeciliaLib.getVar("mainFrame").onUpdateInterface(None)
return True
def cleanup_module(self):
for i in range(NUM_OF_PLUGINS):
if self.pluginObjs[i] is not None:
del self.pluginObjs[i].out
self.pluginObjs[i] = None
if self.spectrum is not None:
self.specamp.mul = 1
self.spectrum.setFunction(None)
del self.specamp
del self.spectrum._timer
del self.spectrum
self.spectrum = None
if hasattr(self, "out"):
if self.out is not None:
del self.out
self.out = None
try:
del self.globalamp
except:
pass
try:
del self.endcall
except:
pass
try:
del self.recorder
del self.recamp
except:
pass
try:
del self.checkCtl7
del self.onNewCtl7Value
del self.ctl7TrigFunc
except:
pass
try:
CeciliaLib.getVar("currentModule")._cleanup()
CeciliaLib.setVar("currentModule", None)
except:
pass
def loadModule(self, module):
self.cleanup_module()
try:
currentModule = module()
except Exception as e:
# If it fails, show the error and reload the current module.
msg = "Cecilia can't run the current module, last valid module (or a random one if this failed too) will be reloaded.\n\n"
self.compileRuntimeError(CeciliaLib.getVar("currentCeciliaFile"), "Runtime Error!", msg)
if os.path.isfile(MODULE_RUNTIME_BACKUP_PATH):
CeciliaLib.openCeciliaFile(None, MODULE_RUNTIME_BACKUP_PATH,
CeciliaLib.getVar("builtinModule"))
else:
CeciliaLib.getVar("mainFrame").onOpenRandom(None)
return False
currentModule._createOpenSndCtrlReceivers()
self.out = Sig(currentModule.out)
plugins = CeciliaLib.getVar("plugins")
for i in range(NUM_OF_PLUGINS):
if i == 0:
tmp_out = self.out
else:
tmp_out = self.pluginObjs[i - 1].out
if plugins[i] is None:
self.pluginObjs[i] = CeciliaNonePlugin(tmp_out)
self.pluginObjs[i].name = "None"
else:
pl = plugins[i]
name, params, knobs = pl.getName(), pl.getParams(), pl.getKnobs()
self.pluginObjs[i] = self.pluginDict[name](tmp_out, params, knobs)
self.pluginObjs[i].name = name
self.pluginObjs[NUM_OF_PLUGINS - 1].out.out()
CeciliaLib.setVar("currentModule", currentModule)
currentModule._setWidgetValues()
CeciliaLib.saveRuntimeBackupFile(CeciliaLib.getVar("currentCeciliaFile"))
return True
def movePlugin(self, vpos, dir):
i1 = vpos
i2 = vpos + dir
tmp = self.pluginObjs[i2]
self.pluginObjs[i2] = self.pluginObjs[i1]
self.pluginObjs[i1] = tmp
for i in range(NUM_OF_PLUGINS):
if i == 0:
tmp_out = self.out
else:
tmp_out = self.pluginObjs[i - 1].out
self.pluginObjs[i].setInput(tmp_out)
self.pluginObjs[i].out.play()
self.pluginObjs[NUM_OF_PLUGINS - 1].out.out()
def setPlugin(self, order):
plugins = CeciliaLib.getVar("plugins")
tmp = self.pluginObjs[order]
if order == 0:
tmp_out = self.out
else:
tmp_out = self.pluginObjs[order - 1].out
if plugins[order] is None:
self.pluginObjs[order] = CeciliaNonePlugin(tmp_out)
self.pluginObjs[order].name = "None"
else:
pl = plugins[order]
name, params, knobs = pl.getName(), pl.getParams(), pl.getKnobs()
self.pluginObjs[order] = self.pluginDict[name](tmp_out, params, knobs)
self.pluginObjs[order].name = name
if order < (NUM_OF_PLUGINS - 1):
self.pluginObjs[order + 1].setInput(self.pluginObjs[order].out)
else:
self.pluginObjs[order].out.out()
del tmp
def checkForAutomation(self):
plugins = CeciliaLib.getVar("plugins")
for i in range(NUM_OF_PLUGINS):
if plugins[i] is not None:
if plugins[i].getName() == self.pluginObjs[i].name:
self.pluginObjs[i].checkForAutomation()
def updatePluginWidgets(self):
plugins = CeciliaLib.getVar("plugins")
for i in range(NUM_OF_PLUGINS):
if plugins[i] is not None:
if plugins[i].getName() == self.pluginObjs[i].name:
self.pluginObjs[i].updateWidget()
def setPluginValue(self, order, which, x):
plugins = CeciliaLib.getVar("plugins")
if plugins[order] is not None:
if plugins[order].getName() == self.pluginObjs[order].name:
self.pluginObjs[order].setValue(which, x)
def setPluginPreset(self, order, which, label):
plugins = CeciliaLib.getVar("plugins")
if plugins[order] is not None:
if plugins[order].getName() == self.pluginObjs[order].name:
self.pluginObjs[order].setPreset(which, label)
def setPluginGraph(self, order, which, func):
plugins = CeciliaLib.getVar("plugins")
if plugins[order] is not None:
if plugins[order].getName() == self.pluginObjs[order].name:
self.pluginObjs[order].setGraph(which, func)
def getMidiCtlNumber(self, number, midichnl=1):
if not self.midiLearnRange:
self.midiLearnSlider.setMidiChannel(midichnl)
self.midiLearnSlider.setMidiCtl(number)
if CeciliaLib.getVar("systemPlatform") == "darwin":
self.tmpScanCallback = CallAfter(self.stop, .25)
else:
wx.CallLater(250, self.stop)
else:
tmp = [number, midichnl]
if tmp not in self.midiLearnCtlsAndChnls:
self.midiLearnCtlsAndChnls.append(tmp)
if len(self.midiLearnCtlsAndChnls) == 2:
self.midiLearnSlider.setMidiChannel([self.midiLearnCtlsAndChnls[0][1], self.midiLearnCtlsAndChnls[1][1]])
self.midiLearnSlider.setMidiCtl([self.midiLearnCtlsAndChnls[0][0], self.midiLearnCtlsAndChnls[1][0]])
if CeciliaLib.getVar("systemPlatform") == "darwin":
self.tmpScanCallback = CallAfter(self.stop, .25)
else:
wx.CallLater(250, self.stop)
def midiLearn(self, slider, rangeSlider=False):
self.midiLearnSlider = slider
self.midiLearnRange = rangeSlider
self.midiLearnCtlsAndChnls = []
self.shutdown()
self.boot()
self.scan = CtlScan2(self.getMidiCtlNumber, False)
self.server.start()
def getAvailableAudioMidiDrivers(self):
inputDriverList, inputDriverIndexes = pa_get_input_devices()
try:
defaultInputDriver = inputDriverList[inputDriverIndexes.index(pa_get_default_input())]
except:
defaultInputDriver = ""
outputDriverList, outputDriverIndexes = pa_get_output_devices()
try:
defaultOutputDriver = outputDriverList[outputDriverIndexes.index(pa_get_default_output())]
except:
defaultOutputDriver = ""
midiDriverList, midiDriverIndexes = pm_get_input_devices()
try:
defaultMidiDriver = midiDriverList[midiDriverIndexes.index(pm_get_default_input())]
except:
defaultMidiDriver = ""
if len(midiDriverList) > 1:
midiDriverList.append("all")
midiDriverIndexes.append(99)
return inputDriverList, inputDriverIndexes, defaultInputDriver, outputDriverList, outputDriverIndexes, \
defaultOutputDriver, midiDriverList, midiDriverIndexes, defaultMidiDriver
def validateAudioFile(self, path):
return sndinfo(path) is not None
def getSoundInfo(self, path):
"""
Retrieves information of the sound and prints it to the console.
return (number of channels, sampling rate, duration, fraction of a table, length in samples, bitrate)
"""
if CeciliaLib.getVar("DEBUG"):
print('--------------------------------------')
print(path)
info = sndinfo(path)
if info is not None:
samprate = info[2]
chnls = info[3]
nsamps = info[0]
dur = info[1]
bitrate = info[5]
format = info[4]
for i in range(24):
size = math.pow(2, (i + 1))
if size > nsamps:
break
tableFrac = nsamps / size
if CeciliaLib.getVar("DEBUG"):
print("channels = %d" % chnls)
print("sampling rate = %s" % samprate)
print("number of samples = %s" % nsamps)
print("duration in sec. = %s" % dur)
print("bitrate = %s" % bitrate)
print("file format = %s" % format)
return (chnls, samprate, dur, tableFrac, nsamps, bitrate, format)
else:
if CeciliaLib.getVar("DEBUG"):
print('Unable to get sound infos. "%s" bypassed!' % path)
return None
def getSoundsFromList(self, pathList):
soundDict = dict()
for path in pathList:
if os.path.isfile(path):
infos = self.getSoundInfo(path)
if infos is not None:
sndfile = os.path.split(path)[1]
if sndfile not in soundDict.keys():
soundDict[CeciliaLib.ensureNFD(sndfile)] = {'samprate': infos[1],
'chnls': infos[0],
'dur': infos[2],
'bitrate': infos[5],
'type': infos[6],
'path': path}
else:
if CeciliaLib.getVar("DEBUG"):
print('not a file')
if CeciliaLib.getVar("DEBUG"):
print()
return soundDict