def index():
ports = None
try:
ports = jack.get_ports()
except (jack.NotConnectedError, jack.Error):
try:
jack.detach('studio-webapp')
jack.attach('studio-webapp')
ports = jack.get_ports()
except (jack.NotConnectedError, jack.Error):
return render_template('jack_device_error.html')
inports = []
outports = []
connects = {}
for port in ports:
if (jack.get_port_flags(port) & jack.IsInput) > 0:
inports.append(port)
connects[port] = jack.get_connections(port)
if (jack.get_port_flags(port) & jack.IsOutput) > 0:
outports.append(port)
try:
otg_systemd_status = subprocess.check_output(['sudo',
'systemctl',
'is-active',
'studio-gaudio_in'])
except subprocess.CalledProcessError, e:
otg_systemd_status = 'failed'
def stop(self):
self.running = False
self.event_queue.put(1)
if self.audio_server == 'jack':
self.jack_client_process.kill()
jack.deactivate()
jack.detach()
def button_event(evt):
global play_button
currentJackFrame = jack.get_current_transport_frame()
if evt == BEV_PLAY: #play/pause
if play_button.val == 1:
jack.transport_start()
else:
jack.transport_stop()
elif evt == BEV_START: #back to 0
jack.transport_locate(0)
elif evt == BEV_PREV: #go back
nextJackFrame = currentJackFrame - 200000
if (nextJackFrame < 0): nextJackFrame = 0
jack.transport_locate(nextJackFrame)
elif evt == BEV_NEXT: #go forward
nextJackFrame = currentJackFrame + 200000
jack.transport_locate(nextJackFrame)
elif evt == BEV_EXIT: #quit script
jack.detach()
Draw.Exit()
def arranca_resampler(card, rate, mode):
""" mode puede ser: zita-a2j, zita-j2a, alsa_in, alsa_out
"""
resamplerIsRunning = False
if "zita" in mode:
# este es el verdadero arranque de zita:
resamplerIsRunning = zitaJack(card, rate, mode,
log=False) # ver la funcion zitaJack
elif "alsa" in mode:
resamplerIsRunning = alsaInOut(card, rate, mode)
if resamplerIsRunning:
# esperamos a que los puertos zita aparezcan en jack
jack.attach('tmp')
intentos = 8
encontrado = False
while intentos:
for port in jack.get_ports():
if bareCard(card) in port:
encontrado = True
if encontrado:
print "(soundcards) Se ha reiniciado " + mode + " " + card + " " + rate
break
intentos -= 1
print "(soundcards) Esperando a " + mode + "." * (8 - intentos + 1)
sleep(.25)
if not intentos:
print "(soundcards) (!) No está disponible el puerto " + bareCard(
card) + " en jack"
jack.detach()
else:
print "(soundcards) <!> No se ha podido reiniciar " + mode + " en " + card + " " + rate
def Delete(self):
"""
Shuts down the jack connection and prepares the instance for garbage collection.
"""
if not self.__deleted:
jack.deactivate()
jack.detach()
sumpf.destroy_connectors(self)
BaseIO.Delete(self)
self.__deleted = True
def load_jt(options):
""" arranca jacktrip y lo primero que hacemos es deshacer la conexión
automática que jacktrip hace a los puertos system de jack (!)
Las opciones pueden ser:
-c remoteHost (modo cliente)
-s (modo servidor)
"""
# muteamos la tarjeta de sonido
sc.alsa_mute_system_card("on")
# arranca jacktrip
Popen("killall jacktrip", shell=True)
sleep(.5)
Popen("jacktrip -z -q 8 -r 2 " + options + " >/dev/null 2>&1", shell=True)
# esperamos a jacktrip:
intentos = 20 # * 0.25 = 5 segundos
while intentos:
try:
if "JackTrip" in check_output("jack_lsp", shell=True):
print "(jacktrip.py) Ha arrancado Jacktrip."
break
except:
pass
intentos -= 1
sleep(.25)
if not intentos:
print "(jacktrip.py) Error arrancando Jacktrip"
sys_exit(-1)
# (!) lo primero deshacemos la conexión automática a system
jack.attach("tmp")
jack.disconnect("JackTrip:receive_1", "system:playback_1")
jack.disconnect("JackTrip:receive_2", "system:playback_2")
try:
jack.disconnect("system:capture_1", "JackTrip:send_1")
jack.disconnect("system:capture_2", "JackTrip:send_2")
except:
# es posible que sea un FIRtro pequeño sin system:capture
pass
jack.detach()
# modo client
if "-c" in options:
# La conexión a FIRtro se gestiona cambiando la input en FIRtro.
pass
# modo server
if "-s" in options:
connect_source2jacktrip()
sc.alsa_mute_system_card("off")
def change_input(input_name, in_ports, out_ports, resampled="no"):
# 'in_ports': Lista [L,R] de los puertos capture de jack de la fuente elegida
# 'out_ports': Lista de los puertos de la variable 'firtro_ports' que se resuelve
# en server_process en función de si se usa Brutefir/Ecasound
# FIRtro2: evaluamos si la entrada requiere resampling por estar en una tarjeta adicional
if resampled <> "no":
sc.external_card_resync(in_ports, resampled)
# CONMUTADOR, como el original de FIRtro1.
try:
jack.attach("tmp")
# Desconectamos todo lo que hubiera en la entrada de FIRtro (y en los posibles monitores):
desconecta_fuentes_de(out_ports)
# Posibles PAUSAS opcionales en los PLAYERS INTEGRADOS (ahorro de %CPU):
players.manage_pauses(input_name)
# Y ahora conectamos la entrada deseada a FIRtro y a los monitores:
for i in range(len(in_ports)):
# Entradas a FIRtro
try:
jack_connect(in_ports[i], out_ports[i])
except:
logging.exception("error conectando " + in_ports[i] + " <> " +
out_ports[i])
# Los monitores opcionales:
try:
if ext_monitor_ports:
jack_connect(in_ports[i], ext_monitor_ports[i])
jack_connect(in_ports[i], int_monitor_ports[i])
except:
logging.exception("error en conexion de monitores")
jack.detach()
except:
# Si hay alguna excepción devolvemos boolean False
logging.exception("error en cuerpo ppal")
jack.detach()
print "(server_input) Problemas (ver ~/tmp/server_input.log)"
return False
# Y si todo ha ido bien, devolvemos el boolean True
return True
def run(self):
while self.nonstop_event.isSet():
try:
jack.process(self.output, self.capture)
# Add a Lock
self.output = self.capture.copy()
self.counter[0] += 1
time.sleep(self.sleep)
except jack.InputSyncError:
print >> sys.stderr, "Input Sync Error, samples lost"
except jack.OutputSyncError:
print >> sys.stderr, "Output Sync"
# Workarround to put output buffer to zero. If not for some reason
# jackd will constantly output the last buffer, making noise
self.output = self.output*0
jack.process(self.output, self.capture)
time.sleep(0.2) # "Waiting" the jack thread to sync.
jack.deactivate()
jack.detach()
self.nonstop_event.set()
def main():
try:
# Nos conectamos al servidor jack bajo el nombre "pecador"
jack.attach("pecador")
except:
print "algo va mal no puedorrr conectar a jack"
sys.exit()
# Lanzamos ebumeter. Ebumeter no admite argumentos,
# requiere conectar sus puertos en jack a posteriori.
dummy = Popen(["killall", "ebumeter"], stdout=None, stderr=None)
time.sleep(.5)
dummy = Popen(["ebumeter"], stdout=None, stderr=None)
time.sleep(.5)
# Conectamos a Ebumeter los mismos puertos que están conectados a Brutefir:
conect2ebumeter(BrutefirPorts())
# Nos desconectamos de Jack
jack.detach()
def jackConexiones(nombrePuerto="", direccion="*"):
""" direccion: > | < | *
Devuelve una lista de tripletas:
(puerto, conexion, puerto)
"""
ports = []
jack.attach("tmp")
for puerto in [x for x in jack.get_ports() if nombrePuerto in x]:
conexiones = jack.get_connections(puerto)
for conexion in conexiones:
flags = jack.get_port_flags(conexion)
# Returns an integer which is the bitwise-or of all flags for a given port.
# haciendo pruebas veamos algunos flags de puertos:
# puertos escribibles (playback): 1 21 impares, ultimo bit a 1
# puertos leibles (capture) : 2 18 22 pares, ultimo bit a 0
if flags % 2:
direc = ">"
else:
direc = "<"
if direc == direccion or direccion == "*":
ports.append((puerto, " --" + direc + "-- ", conexion))
jack.detach()
return ports
def conecta_tarjeta(vias):
jack.attach("tmp")
# Disponemos de la funcion brutefir.outputsMap que contiene
# el mapeo de vias tal como esta definido en brutefir_config, por ejemplo:
# system:playback_3/hi_L
# system:playback_4/hi_R
# system:playback_7/lo_L
# system:playback_8/lo_R
# system:playback_5/sw1
# system:playback_6/sw2
to_disconnect=[]
to_connect = []
# Ahora debemos evaluar si es una salida a activar:
for bfOutMap in brutefir.outputsMap:
conectar = False
jackDest, bfOut = bfOutMap.split('/')
jackOrig = "brutefir:" + bfOut
for via in vias:
if via.lower() in bfOut.lower():
conectar = True
if conectar:
to_connect.append( (jackOrig, jackDest) )
else:
to_disconnect.append( (jackOrig, jackDest) )
for pair in to_disconnect:
jack.disconnect(pair[0], pair[1])
for pair in to_connect:
jack.connect(pair[0], pair[1])
jack.detach()
def connect_source2jacktrip():
jack.attach("tmp")
# Desconectamos lo que hubiera en JackTrip
c1_ports = jack.get_connections("JackTrip:send_1")
c2_ports = jack.get_connections("JackTrip:send_2")
for p1 in c1_ports:
jack.disconnect(p1, "JackTrip:send_1")
for p2 in c2_ports:
jack.disconnect(p2, "JackTrip:send_2")
try:
# conectamos las fuente del FIRtro a jacktrip
s1_ports = jack.get_connections(firtro_ports[0])
s2_ports = jack.get_connections(firtro_ports[1])
for s1 in s1_ports:
jack.connect(s1, "JackTrip:send_1")
for s2 in s2_ports:
jack.connect(s2, "JackTrip:send_2")
except:
# el motivo del fallo es que los puertos de JackTrip no están activos:
# "Cannot connect ports owned by inactive clients: "JackTrip" is not active"
# porque no ha sincronizado todavía con un cliente.
print "(jacktrip.py) (i) para conectar puertos se necesita que estén"
print " activos (con una conexion cliente jacktrip en red)"
jack.detach()
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
except jack.InputSyncError:
pass
except jack.OutputSyncError:
pass
jack.deactivate()
jack.detach()
def cleanup(self):
jack.deactivate()
jack.detach()
self.player.set_state(gst.STATE_NULL)
del(self.player)
def quit(self, *args):
jack.deactivate()
jack.detach()
gtk.main_quit()
print ''
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
def __del__(self):
jack.detach()
def close(self):
jack.detach()
jack.deactivate()
def jack_cleanup():
jack.deactivate()
jack.detach()
print ("jscope detached from jack")
def __del__(self): self.p.terminate() if self.jack_running: jack.detach()
def on_stop(self):
print "Detaching from JACK"
jack.detach()
