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 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 _Record(self):
"""
Starts the playback and recording process.
"""
self.__buffer_size = jack.get_buffer_size()
playback = []
record = []
record_length = self._record_length
if record_length == JackIO.SAME_AS_PLAYBACK or record_length == JackIO.WAIT_FOR_STOP:
record_length = len(self._playback)
# cut the playback signal in chunks of the size of the buffer and write it into a list of numpy arrays
b = 0
while b < record_length:
playbuffer = numpy.zeros(shape=(self._playbackchannels, self.__buffer_size), dtype=numpy.float32)
for c in range(self._playbackchannels):
if c < len(self._playback.GetChannels()):
for s in range(self.__buffer_size):
if b + s < len(self._playback):
playbuffer[c][s] = self._playback.GetChannels()[c][b + s]
playback.append(playbuffer)
b += self.__buffer_size
for i in range(self.__periods):
playbuffer = numpy.zeros(shape=(self._playbackchannels, self.__buffer_size), dtype=numpy.float32)
playback.append(playbuffer)
# play empty buffer to avoid InputSyncErrors
playbuffer = numpy.zeros(shape=(self._playbackchannels, self.__buffer_size), dtype=numpy.float32)
self.__PlayAndRecord(playbuffer, "while not recording")
# play and record with playback signal
for b in playback:
if not self._recording:
break
recorded = self.__PlayAndRecord(b)
record.append(recorded)
# play and record until the Stop method is called
if self._record_length == JackIO.WAIT_FOR_STOP:
while self._recording:
playbuffer = numpy.zeros(shape=(self._recordchannels, self.__buffer_size), dtype=numpy.float32)
recorded = self.__PlayAndRecord(playbuffer)
record.append(recorded)
record_length = (len(record) - self.__periods) * self.__buffer_size
# play empty buffer to avoid crackling noises at playback stop
playbuffer = numpy.zeros(shape=(self._playbackchannels, self.__buffer_size), dtype=numpy.float32)
self.__PlayAndRecord(playbuffer, "while not recording")
# create output Signal
channels = []
for c in range(self._recordchannels):
channel = []
for b in range(self.__periods, len(record)):
for s in record[b][c]:
channel.append(s)
channels.append(tuple(channel[0:record_length]))
self._record = sumpf.Signal(channels=channels, samplingrate=self.GetSamplingRate(), labels=self._GetLabels())
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 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, 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
# 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:
jack.process(output[:,i:i+N], input)
i += N
def __GetNumberOfPeriods(self):
"""
Querys the number of buffer periods of the jack server.
Since neither the Jack latency functions nor the querying of the number
of buffer periods are available in PyJack, this method is a dirty workaround
to obtain this number.
@retval : The number of buffer periods of the Jack server
"""
for p in self.GetCapturePorts():
if jack.get_port_flags(p) & jack.IsPhysical:
return int(subprocess.check_output(["jack_lsp", "-l", p]).split("\n")[1].strip().split(" ")[-2]) / jack.get_buffer_size()
return 2
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:
for sample in struct.unpack('<' + framesize * 'h', frame):
rms += (sample / 32768.0) ** 2
rms = math.sqrt(rms / framesize)
else:
print 'Error in audio subprocess, restarting...'
def start_recording_jack(event_queue, control_queue, pcm, birdname, channel,
rate, format, chunk, silence_limit, prev_audio_time,
min_dur, max_dur, threshold, outdir):
stream = None
print birdname
if uname == "Linux":
channel = str(channel)
establish_connection(pcm, channel)
chunk = jack.get_buffer_size()
print "Buffer Size:", chunk, "Sample Rate:", rate
cur_data = np.zeros((1, chunk), 'f')
dummy = np.zeros((1, 0), 'f')
else:
pass
print "AudioRecorder started (listening...)"
audio2send = []
rel = rate / chunk
slid_win = deque(maxlen=silence_limit *
rel) #amplitude threshold running buffer
slid_win_short = Ringbuffer(0.5 * rate) #freq calc running buffer
prev_audio = Ringbuffer(prev_audio_time *
rate) #prepend audio running buffer
started = False
control_force_record = True
control_force_record_just_stopped = False
if uname == "Linux":
try:
jack.process(dummy, cur_data)
except jack.InputSyncError:
pass
else:
pass
slid_win.append(get_audio_power_jack(cur_data[0, :]))
slid_win_short.extend(cur_data[0, :])
while True:
## check whether any events are in queue and if so change control_force_record accordingly
command = None
control_force_record_just_stopped = False
if not control_queue.empty():
command = control_queue.get(block=True)
if control_force_record:
if command == "start":
pass
elif command == "stop":
control_force_record = False
#control_force_record_just_stopped = True
control_force_record_just_stopped = False #temporary fix
pass
else:
if command == "start":
control_force_record = True
elif command == "stop":
pass
pass
#if len(slid_win)>0:
# print max(slid_win) #uncomment if you want to print intensity values
if uname == "Linux":
try:
jack.process(dummy, cur_data)
except jack.InputSyncError:
pass
else:
pass
try:
slid_win.append(get_audio_power_jack(cur_data[0, :]))
slid_win_short.extend(cur_data[0, :])
except audioop.error:
print "invalid number of blocks for threshold calculation, but continuing"
if (sum([x > threshold
for x in slid_win]) > 0) and control_force_record:
if (not started):
event_queue.put((time.time(), "Audio Recording Started",
slid_win_short.get()))
prev_audio_time_emperical = float(len(prev_audio)) / rel
recording_start_time = time.time() - prev_audio_time_emperical
sys.stdout.flush()
started = True
audio2send = np.array(cur_data[0, :])
else:
audio2send = np.append(audio2send, cur_data[0, :])
event_queue.put((time.time(), 'audio_threshold_crossing',
slid_win_short.get()))
#audio2send.append(cur_data)
elif (started is True and np.shape(audio2send)[0] > min_dur * rate
and np.shape(audio2send)[0] < max_dur * rate
or control_force_record_just_stopped):
today = datetime.date.today().isoformat()
outdir_date = "/".join([outdir, today])
if not os.path.exists(outdir_date): os.makedirs(outdir_date)
filename = save_audio_jack(np.append(prev_audio.get(), audio2send),
recording_start_time, outdir_date, rate)
event_queue.put((time.time(), "Audio File Saved: %s" % filename))
event_queue.put((time.time(), "stop_triggered_audio"))
event_queue.put((time.time(), "audio_saved"))
started = False
slid_win = deque(maxlen=silence_limit * rel)
#prev_audio = deque(maxlen=prev_audio_time * rel)
prev_audio = Ringbuffer(prev_audio_time *
rate) #prepend audio running buffer
prev_audio.extend(audio2send)
event_queue.put((time.time(), "Listening"))
audio2send = np.array(cur_data[0, :])
elif (started is True):
event_queue.put((time.time(), "stop_triggered_audio"))
event_queue.put(
(time.time(), "Duration Criteria not met, listening"))
started = False
slid_win = deque(maxlen=silence_limit * rel)
#prev_audio = deque(maxlen=prev_audio_time * rel)
prev_audio = Ringbuffer(prev_audio_time *
rate) #prepend audio running buffer
prev_audio.extend(audio2send)
audio2send = np.array(cur_data[0, :])
#audio2send=[]
else:
prev_audio.extend(cur_data[0, :])
#prev_audio.append(cur_data)
else:
#print "done recording"
jack.deactivate()
jack.detach()
return
