def __init__ (self):
self._soundRate = 8000
self._chunkSize = 160
self._chunkPack = '160h'
self.decoder = speex.new()
self.encoder = speex.new()
self._voicePlayQueue = Queue.Queue(200)
self._voicePlayed = False
self.sendCount = 0
self.recvCount = 0
self.connector = None
self.destAddr = []
self.voiceSendThread = LoopingCall(self.sendVoice)
self.voicePlayThread = LoopingCall(self.playVoice)
self.sendVoiceEnabled = True
self.playVoiceEnabled = True
self.echoMode = False
self._inputStream = None
self._outputStream = None
def __init__(self):
self._soundRate = 8000
self._chunkSize = 160
self._chunkPack = '160h'
self.decoder = speex.new()
self.encoder = speex.new()
self._voicePlayQueue = Queue.Queue(200)
self._voicePlayed = False
self.sendCount = 0
self.recvCount = 0
self.connector = None
self.destAddr = []
self.voiceSendThread = LoopingCall(self.sendVoice)
self.voicePlayThread = LoopingCall(self.playVoice)
self.sendVoiceEnabled = True
self.playVoiceEnabled = True
self.echoMode = False
self._inputStream = None
self._outputStream = None
def _load_audio(self):
'''Appends the audio entry at 'self.fp' to 'self.adats'.'''
# tstamp (ms), bytes of (compressed) audio data
self.log.write( "We're at self.fp.tell():%d\n" % self.fp.tell())
t, sz = DCB.bin_read(self.fp, "<QQ")
self.log.write(' %d bytes at %.1fs\n' % (sz, t / 1000.))
self.log.flush()
# data
adat = AudioData(t / 1000.0)
cdat = self.fp.read(sz)
if self.v[1] == 1:
adat.add_type(AudioData.ZLB, cdat)
raw_dat = zlib.decompress(cdat)
elif self.v[1] == 2:
if use_speex:
adat.add_type(AudioData.SPX, cdat)
s = speex.new(raw = True)
raw_dat = s.decode(cdat)
else:
sys.stdout.flush()
sys.stderr.write("Warning: Speex not imported!")
traceback.print_stack()
sys.stderr.flush()
else:
raw_dat = cdat
adat.add_type(AudioData.RAW, raw_dat)
ar = AudioRecord(t / 1000.0, len(self.lec.adats), adat)
self.lec.adats.append(adat)
for i in reversed(xrange(len(self.lec))): # TODO optimize
if self.lec[-1].utime() < self.lec[i].utime():
break
self.lec.events.insert(i, ar)
def main():
host, cport, mport = parse_args()
use_codec = False
Registry.DBPOOL = adbapi.ConnectionPool(
'sqlite3', "sequoia/tests/auth/server_1/database.db",
check_same_thread=False)
mixer = AudioMixer()
reactor.callWhenRunning(mixer.start)
codec = speex.new() if use_codec else None
media_tx = ServerMediaProtocol(codec, mixer)
clients_factory = ServerClientsFactory(media_tx, use_codec)
ctx_factory = ServerContextFactory(
"sequoia/tests/auth/server_1/private_key.pem",
"sequoia/tests/auth/server_1/certificate.pem",
"sequoia/tests/auth/root/root_ca.crt")
clients_listener = reactor.listenSSL(cport, clients_factory, ctx_factory,
interface=host)
show_connector_info(clients_listener, "Listening clients")
media_listener = reactor.listenUDP(mport, media_tx,
interface=host)
show_connector_info(media_listener, "Serving media")
reactor.run()
def main():
host, cport, mport = parse_args()
use_codec = False
Registry.DBPOOL = adbapi.ConnectionPool(
'sqlite3',
"sequoia/tests/auth/server_1/database.db",
check_same_thread=False)
mixer = AudioMixer()
reactor.callWhenRunning(mixer.start)
codec = speex.new() if use_codec else None
media_tx = ServerMediaProtocol(codec, mixer)
clients_factory = ServerClientsFactory(media_tx, use_codec)
ctx_factory = ServerContextFactory(
"sequoia/tests/auth/server_1/private_key.pem",
"sequoia/tests/auth/server_1/certificate.pem",
"sequoia/tests/auth/root/root_ca.crt")
clients_listener = reactor.listenSSL(cport,
clients_factory,
ctx_factory,
interface=host)
show_connector_info(clients_listener, "Listening clients")
media_listener = reactor.listenUDP(mport, media_tx, interface=host)
show_connector_info(media_listener, "Serving media")
reactor.run()
def __init__(self, audio):
self.audio = audio
self.spx = speex.new()
gladefile = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"glade/p2p.glade")
self.wTree = gtk.Builder()
self.wTree.add_from_file(gladefile)
key = self.wTree.get_object('local_key').get_text()
self.cipher = Cipher(key)
key = self.wTree.get_object('remote_key').get_text()
self.decipher = Cipher(key)
self.w_local_address = self.wTree.get_object('local_address')
self.w_remote_address = self.wTree.get_object('remote_address')
self.wnd = self.wTree.get_object('wnd')
dic = {
'on_run_conversation_toggled': self.on_run_conversation_toggled,
'on_local_key_focus_out_event': self.on_local_key_focus_out_event,
'on_remote_key_focus_out_event':
self.on_remote_key_focus_out_event,
'on_wnd_delete_event': self.delete_event,
}
self.wTree.connect_signals(dic)
self.wnd.show()
def main(self):
speexobj = speex.new(self.quality)
while 1:
if self.dataReady("inbox"):
ret = speexobj.decode(self.recv("inbox"))
if ret is not "": # Speex objects use internal buffering
result = []
for mixed in ret:
if mixed < 0:
mixed = 65536 + mixed
mixed_lsb = mixed % 256
mixed_msb = mixed >> 8
result.append(chr(mixed_lsb))
result.append(chr(mixed_msb))
data = "".join(result)
#print ret
#ret = str(ret)
self.send(data, "outbox")
yield 1
def main():
spx = speex.new()
buf = []
def callback(in_data, frame_count, time_info, status):
dlen = frame_count*WIDTH
din = list(struct.unpack('h'*(dlen/2), in_data))
encoded = spx.encode(din)
dout = spx.decode(encoded)
delta = len(din)-len(dout)
if delta > 0:
x = min(delta, len(buf))
dout += map(buf.pop, [0,]*x)
dout += [0,]*(delta-x)
elif delta < 0:
buf.extend(dout[len(din):len(dout)])
dout = dout[:len(din)]
out = struct.pack('h'*len(dout), *dout)
return (out, pyaudio.paContinue)
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(WIDTH),
channels=CHANNELS,
rate=RATE,
input=True,
output=True,
stream_callback=callback)
from twisted.internet import reactor
reactor.callWhenRunning(stream.start_stream)
reactor.run()
def connection_done(self, result):
if result.get('use_codec') and self.codec is None:
self.codec = speex.new()
keys_pair_num = str(result.pop('keys_pair'))
keys = self.media_keys[keys_pair_num]
keys.reverse()
mport = result.pop('mport')
remote_media_addr = (self.client.transport.getPeer().host, mport)
self.stream = self.audio.open(format=pyaudio.paInt16,
channels=AUDIO['channels'],
rate=AUDIO['rate'],
input=True,
output=True,
stream_callback=self.on_audio_ready)
self.media_tx.configure(self.codec, keys, remote_media_addr)
self.media_tx.channel.do_cipher = self.settings['do_cipher']
reactor.callLater(0, self.stream.start_stream)
self.store.append((result['self_nick'] + " (you)", ))
for nick_name in result['participants']:
self.store.append((nick_name, ))
self.buttons['connection'].set_label(gtk.STOCK_DISCONNECT)
def main(self):
speexobj = speex.new(self.quality, raw=True)
shutdown=False
while self.dataReady("inbox") or not shutdown:
if not self.dataReady("inbox"):
print ".",
while self.dataReady("inbox"):
data = self.recv("inbox")
#print data
ret = speexobj.encode(data)
if ret is not "": # Speex objects use internal buffering
self.send(ret, "outbox")
# yield 1
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, (Axon.Ipc.shutdownMicroprocess,Axon.Ipc.producerFinished)):
shutdown=True
self.send(msg,"signal")
if not shutdown:
self.pause()
def main(self):
speexobj = speex.new(self.quality, raw=True)
shutdown = False
while self.dataReady("inbox") or not shutdown:
if not self.dataReady("inbox"):
print(".", )
while self.dataReady("inbox"):
data = self.recv("inbox")
#print data
ret = speexobj.encode(data)
if ret is not "": # Speex objects use internal buffering
self.send(ret, "outbox")
# yield 1
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, (Axon.Ipc.shutdownMicroprocess,
Axon.Ipc.producerFinished)):
shutdown = True
self.send(msg, "signal")
if not shutdown:
self.pause()
def main(self):
speexobj = speex.new(self.quality)
while 1:
if self.dataReady("inbox"):
ret = speexobj.decode(self.recv("inbox"))
if ret is not "": # Speex objects use internal buffering
result = []
for mixed in ret:
if mixed < 0:
mixed = 65536 + mixed
mixed_lsb= mixed %256
mixed_msb= mixed >>8
result.append(chr(mixed_lsb))
result.append(chr(mixed_msb))
data = "".join(result)
#print ret
#ret = str(ret)
self.send(data, "outbox")
yield 1
def main(self):
speexobj = speex.new(self.quality)
while 1:
if self.dataReady("inbox"):
data = self.recv("inbox")
#print data
ret = speexobj.encode(data)
if ret is not "": # Speex objects use internal buffering
#print ret
self.send(ret, "outbox")
yield 1
def main(self):
speexobj = speex.new(self.quality)
while 1:
if self.dataReady("inbox"):
data = self.recv("inbox")
#print data
ret = speexobj.encode(data)
if ret is not "": # Speex objects use internal buffering
#print ret
self.send(ret, "outbox")
yield 1
def main():
spx = speex.new()
buf = []
def callback(in_data, frame_count, time_info, status):
dlen = frame_count * WIDTH
din = list(struct.unpack('h' * (dlen / 2), in_data))
encoded = spx.encode(din)
dout = spx.decode(encoded)
delta = len(din) - len(dout)
if delta > 0:
x = min(delta, len(buf))
dout += map(buf.pop, [
0,
] * x)
dout += [
0,
] * (delta - x)
elif delta < 0:
buf.extend(dout[len(din):len(dout)])
dout = dout[:len(din)]
out = struct.pack('h' * len(dout), *dout)
return (out, pyaudio.paContinue)
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(WIDTH),
channels=CHANNELS,
rate=RATE,
input=True,
output=True,
stream_callback=callback)
from twisted.internet import reactor
reactor.callWhenRunning(stream.start_stream)
reactor.run()
def main(self):
speexobj = speex.new(self.quality, raw=True)
shutdown=False
while self.dataReady("inbox") or not shutdown:
while self.dataReady("inbox"):
data = self.recv("inbox")
ret = speexobj.decode(data)
if ret:
self.send(ret, "outbox")
# yield 1
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, (Axon.Ipc.shutdownMicroprocess,Axon.Ipc.producerFinished)):
shutdown=True
self.send(msg,"signal")
if not shutdown:
self.pause()
def __init__(self, audio):
self.audio = audio
self.spx = speex.new()
gladefile = os.path.join(os.path.dirname(os.path.abspath(__file__)), "glade/p2p.glade")
self.wTree = gtk.Builder()
self.wTree.add_from_file(gladefile)
key = self.wTree.get_object('local_key').get_text()
self.cipher = Cipher(key)
key = self.wTree.get_object('remote_key').get_text()
self.decipher = Cipher(key)
self.w_local_address = self.wTree.get_object('local_address')
self.w_remote_address = self.wTree.get_object('remote_address')
self.wnd = self.wTree.get_object('wnd')
dic = {
'on_run_conversation_toggled' : self.on_run_conversation_toggled,
'on_local_key_focus_out_event': self.on_local_key_focus_out_event,
'on_remote_key_focus_out_event': self.on_remote_key_focus_out_event,
'on_wnd_delete_event': self.delete_event,
}
self.wTree.connect_signals(dic)
self.wnd.show()
def main(self):
speexobj = speex.new(self.quality, raw=True)
shutdown = False
while self.dataReady("inbox") or not shutdown:
while self.dataReady("inbox"):
data = self.recv("inbox")
ret = speexobj.decode(data)
if ret:
self.send(ret, "outbox")
# yield 1
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, (Axon.Ipc.shutdownMicroprocess,
Axon.Ipc.producerFinished)):
shutdown = True
self.send(msg, "signal")
if not shutdown:
self.pause()
def _save_audio(self, audio):
'''Writes audio data to file in DCB format.'''
if self.v[1] == 1:
c_data = zlib.compress(audio[1], zlib.Z_BEST_COMPRESSION)
elif self.v[1] == 2:
if use_speex:
s = speex.new(raw = True)
c_data = s.encode(audio[1])
else:
sys.stdout.flush()
sys.stderr.write("Warning: Speex not imported!")
traceback.print_stack()
sys.stderr.flush()
else:
sys.stdout.flush()
sys.stderr.write("Warning: Unhandled file version! " + self.v)
traceback.print_stack()
sys.stderr.flush()
# tstamp (ms), bytes of data in audio file
DCB.bin_write(self.fp, "<QQ", int(audio[0] * 1000), len(c_data))
self.log.write(' audio @ %.2fs with %d bytes\n' % (audio[0], len(c_data)))
self.log.flush()
self.fp.write(c_data) # (compressed) audio data
def __init__(self): self.speex = speex.new(Config.speex_quality)
def __init__(self):
self.speex = speex.new(Config.speex_quality)
self.counter = 0
""" Record audio from the microphone and encode as x-speex-with-header-byte to pass to Google
for speech recognition.
Aaron J. Miller, 2012. No copyright held. Use freely for your purposes.
I provide this code for informational purposes only.
"""
import sys
import pyaudio, speex
import numpy as np # just for doing a standard deviation for audio level checks
import urllib2
#e = speex.Encoder()
#e.initialize(speex.SPEEX_MODEID_WB)
e = speex.new()
#d = speex.Decoder()
#d.initialize(speex.SPEEX_MODEID_WB)
#chunk = 320 # tried other numbers... some don't work
chunk = 1024
FORMAT = pyaudio.paInt16
bytespersample=2
CHANNELS = 1
RATE = 16000 # "wideband" mode for speex. May work with 8000. Haven't tried it.
p = pyaudio.PyAudio()
# Start the stream to record the audio
stream = p.open(format = FORMAT,
channels = CHANNELS,
rate = RATE,
