def __init__(self, playbackchannels=1, recordchannels=1):
"""
@param playbackchannels: the number of channels for playback (can not be changed later)
@param recordchannels: the number of channels for recording (can not be changed later)
"""
self.__deleted = True
# set up jack
self.__prefix = "SuMPF"
self.__inputs = []
self.__outputs = []
jack.attach(self.__prefix)
self.__deleted = False
for i in range(recordchannels):
portname = "in_" + str(i + 1)
self.__inputs.append(self.__prefix + ":" + portname)
jack.register_port(portname, jack.IsInput)
for i in range(playbackchannels):
portname = "out_" + str(i + 1)
self.__outputs.append(self.__prefix + ":" + portname)
jack.register_port(portname, jack.IsOutput)
jack.activate()
# other stuff
BaseIO.__init__(self, playbackchannels, recordchannels)
# self.__periods = self.__GetNumberOfPeriods()
self.__periods = 2
self.__buffer_size = 0 # This will be set when the interaction with the sound card starts
def TestPyJack(self):
CHANNELS=len(self.jaoutlist.curselection())
self.fs = float(jack.get_sample_rate())
print(self.jaoutlist.curselection())
for i in range(0,len(self.jaoutlist.curselection())):
print(self.jaoutlist.get(self.jaoutlist.curselection()[i]))
jack.activate()
for i in range(0,len(self.jaoutlist.curselection())):
jack.register_port('output_'+str(i), jack.IsOutput)
jack.connect('measure:output_'+str(i), self.jaoutlist.get(self.jaoutlist.curselection()[i]))
# Dummy Input
jack.register_port('dummy_input', jack.IsInput)
print(jack.get_ports())
N = jack.get_buffer_size()
input = np.zeros((1,len(self.signal)),'f')
output = np.array(np.tile(self.signal,(CHANNELS,1)),'f')
x = 0
while x < output.shape[1] - N:
try:
jack.process(output[:,x:x+N], input[:,x:x+N])
x += N
except jack.InputSyncError:
pass
except jack.OutputSyncError:
pass
for i in range(0,len(self.jaoutlist.curselection())):
jack.unregister_port('output_'+str(i))
jack.unregister_port('dummy_input')
jack.deactivate()
def __init__(self, client, name, number):
self.client = client
self.name = name
self.number = number
self.port = "%s:%s%d" %(self.client, self.name, self.number)
self.monitor_port = "monitor_%s_%s%d" % (self.client, self.name, self.number)
jack.register_port(self.monitor_port, jack.IsInput)
jack.connect(self.port, "%s:%s" % (jack.get_client_name(), self.monitor_port))
def __init__(self, url):
log.info("Opening JACK input")
jack.attach("Noter Virtual Keyboard")
self.rate = jack.get_sample_rate()
jack.activate()
jack.register_port("Input 1", jack.IsInput)
jack.register_port("Input 2", jack.IsInput)
jack.connect("system:capture_1", "Noter Virtual Keyboard:Input 1")
jack.connect("system:capture_2", "Noter Virtual Keyboard:Input 2")
self.buffer_size = jack.get_buffer_size()
self.input = numpy.zeros((2, self.buffer_size), 'f')
self.output = numpy.zeros((2, self.buffer_size), 'f')
def establish_connection(pcm, channel):
myname = jack.get_client_name()
capture_name = pcm + ":capture_" + channel
port_name = "in_" + channel
connection_name = myname + ":" + port_name
print capture_name, port_name, connection_name
print "Jack ports (before):", jack.get_ports()
jack.register_port(port_name, jack.IsInput)
jack.activate()
print "Jack ports (after):", jack.get_ports()
jack.connect(capture_name, connection_name)
print jack.get_connections(connection_name)
def MesPyJack(self):
OCHANNELS=len(self.jaoutlist.curselection())
ICHANNELS=len(self.jainplist.curselection())
print(self.jainplist.curselection())
self.fs = float(jack.get_sample_rate())
jack.activate()
# Register and Connect Output Ports
for i in range(0,OCHANNELS):
jack.register_port('output_'+str(i), jack.IsOutput)
jack.connect('measure:output_'+str(i), self.jaoutlist.get(self.jaoutlist.curselection()[i]))
# Register and Connect Input Ports
for i in range(0,ICHANNELS):
jack.register_port('input_'+str(i), jack.IsInput)
jack.connect(self.jainplist.get(self.jainplist.curselection()[i]), 'measure:input_'+str(i))
N = jack.get_buffer_size()
input = np.zeros((ICHANNELS,len(self.signal)),'f')
output = np.array(np.tile(self.signal,(OCHANNELS,1)),'f')
x = 0
while x < output.shape[1] - N:
try:
jack.process(output[:,x:x+N], input[:,x:x+N])
x += N
except jack.InputSyncError:
pass
except jack.OutputSyncError:
pass
for i in range(0,OCHANNELS):
jack.unregister_port('output_'+str(i))
for i in range(0,ICHANNELS):
jack.unregister_port('input_'+str(i))
jack.deactivate()
if self.rawcheck.get():
#rawfile=self.get#self.filepath.get()+os.sep+self.prefix.get()+'_RAW_'+self.counter.get()+'_AVG_'+str(int(self.siavg.get())-self.cursiavg)+'.wav'
rawfile=self.getRawFilename(int(int(self.siavg.get())-self.cursiavg))#self.filepath.get()+os.sep+self.prefix.get()+'_RAW_'+self.counter.get()+'_AVG_'+str(int(self.siavg)-self.cursiavg)+'.wav'
toSave = np.array(input.transpose(),dtype=('float32'))
scipy.io.wavfile.write(rawfile,int(self.fs), toSave)
print(rawfile+' saved')
self.cursiavg-=1
#if self.impcheck.get():
self.raw.append(input)
print('PyJack: append to raw')
if (self.cursiavg==0) and (self.impcheck.get()):
self.generateIR()
def __init__(self):
jack.attach("stream_grapher")
jack.register_port("in_1", jack.IsInput)
jack.register_port("in_2", jack.IsInput)
jack.register_port("out_1", jack.IsOutput)
jack.register_port("out_2", jack.IsOutput)
jack.activate()
try:
jack.connect("system:capture_1", "stream_grapher:in_1")
jack.connect("system:capture_2", "stream_grapher:in_2")
jack.connect("stream_grapher:out_1", "system:playback_1")
jack.connect("stream_grapher:out_2", "system:playback_2")
except jack.UsageError:
pass
buff_size = jack.get_buffer_size()
if buff_size < 1024:
print >> sys.stderr, "Jack buffer size is %d. If you have sync problems try a buff size >= 1024." % (buff_size, )
self.buff_size = jack.get_buffer_size()
sample_rate = jack.get_sample_rate()
Backend.__init__(self, ports=2, sample_rate=sample_rate)
self.capture = numpy.zeros((2, self.buff_size), 'f')
self.output = numpy.zeros((2, self.buff_size), 'f')
self.counter = [0]
self.last_counter = 0
# Time to sleep between calls to jack.process
# R should be at least 1.0
# To never get InputSyncErrors R should be like 2.0 or higher
R = 1.2
self.sleep = self.buff_size / float(self.sample_rate) / R
def __init__(self, nscopes, subsamp_factor, length, zoom):
self.scopes = range(nscopes)
jack.attach("jscope")
print(jack.get_ports())
for i in self.scopes:
jack.register_port("in_%d" %(i), jack.IsInput)
jack.activate()
print jack.get_ports()
#jack.connect(jack.get_ports()[-2], "jscope:in_1")
# CONSTANTS
self.N = jack.get_buffer_size()
self.Sr = float(jack.get_sample_rate())
self.plotlength = length # plot length in seconds
self.abscissa = -np.arange(self.Sr*self.plotlength) / self.Sr
self.input_slice = np.zeros((nscopes, self.N), dtype='f')
self.output_slice = self.input_slice.copy()
self.fig = Figure()
self.subsamp_factor = subsamp_factor
self.ax = []
self.plot_data = []
self.l_plot_data = []
self.input_ring = []
self.output_ring = []
for i in self.scopes:
self.ax.append(self.fig.add_subplot(nscopes, 1, i+1))
self.ax[i].set_ylim(-zoom, zoom)
self.plot_data.append([])
foo, = self.ax[i].plot([], self.plot_data[i])
self.l_plot_data.append(foo)
self.input_ring.append(RingBuffer(self.abscissa.size))
self.output_ring.append(RingBuffer(self.abscissa.size))
self.ax[i].set_xlim(self.abscissa[0], self.abscissa[-1])
self.ax[i].grid()
FigureCanvas.__init__(self, self.fig)
self.fig.canvas.draw()
self.timerEvent(None)
self.timer = self.startTimer(0)
def __init__(self, nscopes, subsamp_factor, length, zoom):
self.scopes = range(nscopes)
jack.attach("jscope")
print(jack.get_ports())
for i in self.scopes:
jack.register_port("in_%d" % (i), jack.IsInput)
jack.activate()
print jack.get_ports()
#jack.connect(jack.get_ports()[-2], "jscope:in_1")
# CONSTANTS
self.N = jack.get_buffer_size()
self.Sr = float(jack.get_sample_rate())
self.plotlength = length # plot length in seconds
self.abscissa = -np.arange(self.Sr * self.plotlength) / self.Sr
self.input_slice = np.zeros((nscopes, self.N), dtype='f')
self.output_slice = self.input_slice.copy()
self.fig = Figure()
self.subsamp_factor = subsamp_factor
self.ax = []
self.plot_data = []
self.l_plot_data = []
self.input_ring = []
self.output_ring = []
for i in self.scopes:
self.ax.append(self.fig.add_subplot(nscopes, 1, i + 1))
self.ax[i].set_ylim(-zoom, zoom)
self.plot_data.append([])
foo, = self.ax[i].plot([], self.plot_data[i])
self.l_plot_data.append(foo)
self.input_ring.append(RingBuffer(self.abscissa.size))
self.output_ring.append(RingBuffer(self.abscissa.size))
self.ax[i].set_xlim(self.abscissa[0], self.abscissa[-1])
self.ax[i].grid()
FigureCanvas.__init__(self, self.fig)
self.fig.canvas.draw()
self.timerEvent(None)
self.timer = self.startTimer(0)
def start(self):
import jack
jack.attach("NoteRecogniser Recorder")
jack.register_port("in_1", jack.IsInput)
jack.activate()
try:
jack.connect("system:capture_1", "NoteRecogniser Recorder:in_1")
jack.connect("system:capture_2", "NoteRecogniser Recorder:in_1")
except err:
print("Unable to connect to system:capture")
buffer_size = jack.get_buffer_size()
sample_rate = float(jack.get_sample_rate())
print "Buffer Size:", buffer_size, "Sample Rate:", sample_rate
output = scipy.zeros((1, buffer_size), 'f')
while True:
try:
input = scipy.zeros((1, buffer_size), 'f')
jack.process(output, input)
#print len(input)
fft = numpy.fft.rfft(input[0])
fft = map(
lambda c: math.sqrt(c.real * c.real + c.imag * c.imag),
fft)
#print(len(fft))
dominant = reduce(lambda y, x: x if x[1] > y[1] else y,
zip(range(len(fft)), fft), [0, 0])
print dominant
except jack.InputSyncError:
print "Input Sync Error"
pass
except jack.OutputSyncError:
print "Output Sync Error"
pass
def __init__(self, output='jack', numChannels = 2):
self.numChannels = numChannels
self.output = output
if output == 'jack':
# use pyjack
import jack
try:
jack.get_client_name()
except jack.NotConnectedError:
jack.attach('remix')
# not registering an input port makes the output sync
# consistently break after processing 2 buffers
# - bug in pyjack?
jack.register_port("in_1", jack.IsInput)
for i in range(0, self.numChannels):
jack.register_port("out_" + str(i+1), jack.IsOutput)
jack.activate()
for i in range(0, self.numChannels):
jack.connect("remix:out_" + str(i+1), "alsa_pcm:playback_" + str(i+1))
self.n = jack.get_buffer_size()
self.jackSampleRate = float(jack.get_sample_rate())
# loosing a buffer, here, see below
self._reset_jack()
def start(self):
import jack
jack.attach("NoteRecogniser Recorder")
jack.register_port("in_1", jack.IsInput)
jack.activate()
try:
jack.connect("system:capture_1", "NoteRecogniser Recorder:in_1")
jack.connect("system:capture_2", "NoteRecogniser Recorder:in_1")
except err:
print ("Unable to connect to system:capture")
buffer_size = jack.get_buffer_size()
sample_rate = float(jack.get_sample_rate())
print "Buffer Size:", buffer_size, "Sample Rate:", sample_rate
output = scipy.zeros((1,buffer_size), 'f')
while True:
try:
input = scipy.zeros((1,buffer_size), 'f')
jack.process(output, input)
#print len(input)
fft = numpy.fft.rfft(input[0])
fft = map(lambda c : math.sqrt(c.real*c.real + c.imag*c.imag), fft)
#print(len(fft))
dominant = reduce(lambda y,x: x if x[1] > y[1] else y, zip(range(len(fft)), fft), [0,0])
print dominant
except jack.InputSyncError:
print "Input Sync Error"
pass
except jack.OutputSyncError:
print "Output Sync Error"
pass
def open(self):
self.client = jack.attach('PythonClient')
myname = jack.get_client_name()
jack.register_port("in_1", jack.IsInput)
jack.register_port("in_2", jack.IsInput)
jack.register_port("out", jack.IsOutput)
self.client.activate()
print "Jack ports (before):", jack.get_ports()
jack.connect("system:capture_1", myname+":in_1")
def add_ports(self, widget=None):
if (self.output_n == 10 and channels == 2) or (self.output_n == 20):
return
self.output_n += 1
item = gtk.CheckButton(label='output {}'.format(self.output_n))
self.outport_box.pack_start(item, False, False, 0)
item.show()
self.group.append(item)
self.output_ports.append(False)
if channels == 2:
jack.register_port('output {} L'.format(self.output_n), jack.IsOutput)
jack.register_port('output {} R'.format(self.output_n), jack.IsOutput)
else:
jack.register_port('output {}'.format(self.output_n), jack.IsOutput)
item.connect('toggled', self.selector, self.output_n-1)
self.bind(self.output_n)
elif opc.startswith("name="):
ownname = str(opc.split("=")[-1])
elif opc == "-d":
disconnect = True
elif "-h" in opc:
print __doc__
sys.exit()
# Nos atachamos a jackd
jack.attach(ownname)
# Creamos los puertos de esta instancia
for i in range(1, 1 + nchannels):
jack.register_port('out_' + str(i), jack.IsOutput)
jack.register_port("in_" + str(i), jack.IsInput)
# Activamos los puertos
jack.activate()
# Conectamos los puertos de captura y playback deseados:
if source:
if disconnect:
conecta(source, sink, mode='disconnect')
conecta(source, ownname, mode='connect')
if sink:
if disconnect:
conecta(source, sink, mode='disconnect')
conecta(ownname, sink, mode='connect')
output_ports = [True] + [False]*(output_n-1) if output_n>0 else []
active = 0
jack.attach(client_name)
buf_size = jack.get_buffer_size()
#sam_size = float(jack.get_sample_rate())
#capture = numpy.zeros((2,int(sam_size)), 'f')
input_stream = numpy.zeros((channels, buf_size), 'f')
empty_stream = numpy.zeros((channels, buf_size), 'f')
#output_stream = numpy.zeros((4, buf_size), 'f')
#input_buffer = numpy.zeros((2, buf_size), 'f')
input_ports = []
if channels == 2:
jack.register_port('input L', jack.IsInput)
input_ports.append(client_name + ':' + 'input L')
jack.register_port('input R', jack.IsInput)
input_ports.append(client_name + ':' + 'input R')
else:
input_ports.append(jack.register_port('input', jack.IsInput))
for i in range(output_n):
if channels == 2:
jack.register_port('output {} L'.format(i+1), jack.IsOutput)
jack.register_port('output {} R'.format(i+1), jack.IsOutput)
else:
jack.register_port('output {}'.format(i+1), jack.IsOutput)
jack.activate()
# Parse LED specification, create multiclient
leds = arguments["<leds>"].split(",")
client = clients[0]
ledtuples = []
for led in leds:
led = led.split(":", 1)
if len(led) >= 2:
client = clients[int(led.pop(0)) - 1]
ledtuples.append((client, int(led[0])))
client = ledp.MultiClient(ledtuples)
leds = range(len(ledtuples))
# Setup JACK interface
jack.attach(arguments["--name"])
jack.register_port("input",
jack.IsInput | jack.IsTerminal | jack.IsPhysical)
buffer_size = jack.get_buffer_size()
sample_rate = jack.get_sample_rate()
def buffer_size_callback():
raise Exception("buffer size changed and I can't take that")
exit(2)
#jack.set_buffer_size_callback(buffer_size_callback) #FIXME
def sample_rate_callback():
raise Exception("sample rate changed and I can't take that")
exit(2)
#jack.set_sample_rate_callback(sample_rate_callback) #FIXME
jack_input = np.zeros((1, buffer_size), 'f')
telephones.append(telephone.telephone(12, phonemap[12], ringerpinnum=(0,4),onhookpinnum=[0,'12'],channelnum=12, conversations=conversations, telephones=telephones,barqueue=barqueue))
telephones.append(telephone.telephone(13, phonemap[13], ringerpinnum=(0,5),onhookpinnum=[0,'a0'],channelnum=13, conversations=conversations, telephones=telephones,barqueue=barqueue))
telephones.append(telephone.telephone(14, phonemap[14], ringerpinnum=(0,6),onhookpinnum=[0,'a1'],channelnum=14, conversations=conversations, telephones=telephones,barqueue=barqueue))
#telephones.append(telephone.telephone(15, phonemap[15], ringerpinnum=(0,7),onhookpinnum=[0,'a2'],channelnum=15, conversations=conversations, telephones=telephones,barqueue=barqueue))
else:
channels = 2
telephones.append(telephone.telephone(0, "Phone 52", ringerpinnum=None,onhookpinnum=None,channelnum=0,conversations= conversations, telephones=telephones))
telephones.append(telephone.telephone(1, "Phone 53", ringerpinnum=None,onhookpinnum=None,channelnum=1,conversations= conversations, telephones=telephones))
print "There are %d phones." % (len(telephones))
for x in range(channels):
num = str(x+1)
jack.register_port("out_"+num, jack.IsOutput)
jack.register_port("in_"+num, jack.IsInput)
jack.activate()
num_telephones = channels # Create 8 telephones for now
for x in range(num_telephones):
num = str(x+1)
if x < 8:
jack.connect("system:capture_"+num, "pleasehold:in_"+num)
jack.connect("pleasehold:out_"+num, "system:playback_"+num)
else:
alsa_num = str(x-7)
jack.connect("alsa_in:capture_"+alsa_num, "pleasehold:in_"+num)
jack.connect("pleasehold:out_"+num, "alsa_out:playback_"+alsa_num)
r, g, b = 1, scaler, 0
elif hue < 2 / 6.0:
r, g, b = 1 - scaler, 1, 0
elif hue < 3 / 6.0:
r, g, b = 0, 1, scaler
elif hue < 4 / 6.0:
r, g, b = 0, 1 - scaler, 1
elif hue < 5 / 6.0:
r, g, b = scaler, 0, 1
else:
r, g, b = 1, 0, 1 - scaler
return r, g, b
jack.attach("colours")
jack.register_port("in", jack.IsInput)
jack.activate()
jack.connect("system:capture_1", "colours:in")
buff = jack.get_buffer_size()
rate = jack.get_sample_rate()
freqs = np.fft.fftfreq(buff, 1.0 / rate)[: buff / 2]
hues = array([(log2(F) - log2(440)) % 1 for F in freqs])
hue_order = array(sorted(enumerate(hues[1:], 1), key=lambda f: f[1]), "i").T[0]
freq_rgb = array([hue_to_rgb(h) for h in hues])
capture = np.zeros((1, buff), "f")
dummy = np.zeros((0, 0), "f")
pygame.init()
# Parse LED specification, create multiclient
leds = arguments["<leds>"].split(",")
client = clients[0]
ledtuples = []
for led in leds:
led = led.split(":", 1)
if len(led) >= 2:
client = clients[int(led.pop(0)) - 1]
ledtuples.append((client, int(led[0])))
client = ledp.MultiClient(ledtuples)
leds = range(len(ledtuples))
# Setup JACK interface
jack.attach(arguments["--name"])
jack.register_port("input", jack.IsInput | jack.IsTerminal | jack.IsPhysical)
buffer_size = jack.get_buffer_size()
sample_rate = jack.get_sample_rate()
def buffer_size_callback():
raise Exception("buffer size changed and I can't take that")
exit(2)
#jack.set_buffer_size_callback(buffer_size_callback) #FIXME
def sample_rate_callback():
raise Exception("sample rate changed and I can't take that")
exit(2)
#jack.set_sample_rate_callback(sample_rate_callback) #FIXME
jack_input = np.zeros((1, buffer_size), 'f')
jack_output = np.zeros((0, buffer_size), 'f')
output_buffer = range(buffer_size)
pass
except jack.OutputSyncError:
print "Output Sync Error"
pass
def reset_view():
[p.setYRange(-1, 1) for p in plots]
[p.enableAutoRange(axis=pg.ViewBox.XAxis, enable=True)]
# initialize jack connections
nscopes = 1
jack.attach("jscope")
for i in range(nscopes):
jack.register_port("in_%d" % (i), jack.IsInput)
jack.activate()
N = jack.get_buffer_size()
Sr = float(jack.get_sample_rate())
print (Sr)
plotlength = 0.3
abscissa = np.flipud(-np.arange(Sr * plotlength) / Sr)
print (len(abscissa))
resample_factor = int(abscissa.size / 1000)
rings = [RingBuffer(len(abscissa)) for i in range(nscopes)]
input_slice = np.zeros((nscopes, N), dtype="f")
output_slice = input_slice.copy()
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Plays a 440.0 Hz test tone for 3 seconds to alsa_pcm:playback_1.
#
# Copyright 2003, Andrew W. Schmeder
# This source code is released under the terms of the GNU Public License.
# See LICENSE for the full text of these terms.
import numpy
import jack
jack.attach("testtone")
jack.register_port("in_1", jack.IsInput)
jack.register_port("out_1", jack.IsOutput)
jack.activate()
jack.connect("testtone:out_1", "alsa_pcm:playback_1")
N = jack.get_buffer_size()
Sr = float(jack.get_sample_rate())
print "Buffer Size:", N, "Sample Rate:", Sr
sec = 3.0
input = numpy.zeros((1,N), 'f')
output = numpy.reshape(
numpy.sin(
2*numpy.pi*440.0 * (numpy.arange(0, sec, 1.0/(Sr), 'f')[0:int(Sr*sec)])
), (1, Sr*sec)).astype('f')
i = 0
while i < output.shape[1] - N:
try:
vu_value = TARGET_CHANNELS * [0]
random_gain = TARGET_CHANNELS * [1.0]
net = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
net.connect((CCC_HOST, CCC_PORT))
net.send('VU')
time_update = time.time()
time_random = time_update
if AUDIO_MODE == 'alsa':
framesize = 1024
rate = 22050
pipe = os.popen('arecord -N -c 1 -r %d -f S16_LE' % (rate,), 'r', 0)
elif AUDIO_MODE == 'jack':
jack.attach('VU-Meter')
jack.register_port('in_1', jack.IsInput)
jack.register_port('out_1', jack.IsOutput)
jack.activate()
# jack.connect('alsa_pcm:capture_1', 'VU-Meter:in_1')
jack.connect('system:capture_1', 'VU-Meter:in_1')
framesize = jack.get_buffer_size()
rate = jack.get_sample_rate()
input_array = numpy.zeros((1, framesize), 'f')
output_array = numpy.zeros((1, framesize), 'f')
try:
while True:
if AUDIO_MODE == 'alsa':
rms = 0.0
frame = pipe.read(framesize * 2) # 2 bytes per sample (16-bit)
if len(frame) == framesize * 2: