def record():
pa = PyAudio()
in_stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=BUFFER_SIZE)
out_stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE,output=True)
save_count = 0
save_buffer = []
save_data = []
save_count = SAVE_LENGTH
print 'start recording'
while save_count>0:
string_audio_data = in_stream.read(BUFFER_SIZE)
audio_data = np.fromstring(string_audio_data, dtype=np.short)
print type(audio_data)
save_buffer.append( string_audio_data )
save_data.append( audio_data )
save_count = save_count - 1
#print 'save %s' % (wav.fileName)
#save_wave_file(wav.fileName, save_buffer)
save_wave_file("test.wav", save_buffer)
pa.terminate()
def record(self):
pa = PyAudio()
in_stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=BUFFER_SIZE)
save_count = 0
save_buffer = []
save_count = SAVE_LENGTH
print 'start recording'
while save_count>0:
string_audio_data = in_stream.read(BUFFER_SIZE)
audio_data = np.fromstring(string_audio_data, dtype=np.short)
save_buffer.append( string_audio_data )
save_count = save_count - 1
print 'save %s' % (self.fileName)
pa.terminate()
wf = wave.open(self.fileName, 'wb')
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(SAMPLING_RATE)
wf.writeframes("".join(save_buffer))
wf.close()
self.stringAudioData = "".join(save_buffer)
save_data = np.fromstring(self.stringAudioData, dtype=np.short)
self.audioData = save_data[10000:10000+4608*4]
self.stringAudioData = self.audioData.tostring()
self.cutAudio = self.audioData
# self.cut2()
self.getFeature()
def record(self, time):
audio = PyAudio()
stream = audio.open(input_device_index=self.device_index,
output_device_index=self.device_index,
format=self.format,
channels=self.channel,
rate=self.rate,
input=True,
frames_per_buffer=self.chunk
)
print "Recording..."
frames = []
for i in range(0, self.rate / self.chunk * time):
data = stream.read(self.chunk)
frames.append(data)
stream.stop_stream()
print "Recording Complete"
stream.close()
audio.terminate()
write_frames = open_audio(self.file, 'wb')
write_frames.setnchannels(self.channel)
write_frames.setsampwidth(audio.get_sample_size(self.format))
write_frames.setframerate(self.rate)
write_frames.writeframes(''.join(frames))
write_frames.close()
self.convert()
class AudioBackend(QtCore.QObject):
underflow = QtCore.pyqtSignal()
new_data_available_from_callback = QtCore.pyqtSignal(
bytes, int, float, int)
new_data_available = QtCore.pyqtSignal(ndarray, float, int)
def callback(self, in_data, frame_count, time_info, status):
# do the minimum from here to prevent overflows, just pass the data to the main thread
input_time = time_info['input_buffer_adc_time']
# some API drivers in PortAudio do not return a valid time, so fallback to the current stream time
if input_time == 0.:
input_time = time_info['current_time']
if input_time == 0.:
input_time = self.stream.get_time()
self.new_data_available_from_callback.emit(in_data, frame_count,
input_time, status)
return (None, 0)
def __init__(self, logger):
QtCore.QObject.__init__(self)
self.logger = logger
self.duo_input = False
self.terminated = False
self.logger.push("Initializing PyAudio")
self.pa = PyAudio()
# look for devices
self.input_devices = self.get_input_devices()
self.output_devices = self.get_output_devices()
self.device = None
self.first_channel = None
self.second_channel = None
# we will try to open all the input devices until one
# works, starting by the default input device
for device in self.input_devices:
self.logger.push("Opening the stream")
try:
self.stream = self.open_stream(device)
self.stream.start_stream()
self.device = device
self.logger.push("Success")
break
except:
self.logger.push("Fail")
if self.device is not None:
self.first_channel = 0
nchannels = self.get_current_device_nchannels()
if nchannels == 1:
self.second_channel = 0
else:
self.second_channel = 1
# counter for the number of input buffer overflows
self.xruns = 0
self.chunk_number = 0
self.new_data_available_from_callback.connect(self.handle_new_data)
def close(self):
if self.stream is not None:
self.stream.stop_stream()
self.stream.close()
self.stream = None
if not self.terminated:
# call terminate on PortAudio
self.logger.push("Terminating PortAudio")
self.pa.terminate()
self.logger.push("PortAudio terminated")
# avoid calling PortAudio methods in the callback/slots
self.terminated = True
# method
def get_readable_devices_list(self):
devices_list = []
default_device_index = self.get_default_input_device()
for device in self.input_devices:
dev_info = self.pa.get_device_info_by_index(device)
api = self.pa.get_host_api_info_by_index(
dev_info['hostApi'])['name']
if device is default_device_index:
extra_info = ' (system default)'
else:
extra_info = ''
nchannels = self.pa.get_device_info_by_index(
device)['maxInputChannels']
desc = "%s (%d channels) (%s) %s" % (dev_info['name'], nchannels,
api, extra_info)
devices_list += [desc]
return devices_list
# method
def get_readable_output_devices_list(self):
devices_list = []
default_device_index = self.get_default_output_device()
for device in self.output_devices:
dev_info = self.pa.get_device_info_by_index(device)
api = self.pa.get_host_api_info_by_index(
dev_info['hostApi'])['name']
if device is default_device_index:
extra_info = ' (system default)'
else:
extra_info = ''
nchannels = self.pa.get_device_info_by_index(
device)['maxOutputChannels']
desc = "%s (%d channels) (%s) %s" % (dev_info['name'], nchannels,
api, extra_info)
devices_list += [desc]
return devices_list
# method
def get_default_input_device(self):
try:
index = self.pa.get_default_input_device_info()['index']
except IOError:
index = None
return index
# method
def get_default_output_device(self):
try:
index = self.pa.get_default_output_device_info()['index']
except IOError:
index = None
return index
# method
def get_device_count(self):
return self.pa.get_device_count()
# method
# returns a list of input devices index, starting with the system default
def get_input_devices(self):
device_count = self.get_device_count()
device_range = list(range(0, device_count))
default_input_device = self.get_default_input_device()
if default_input_device is not None:
# start by the default input device
device_range.remove(default_input_device)
device_range = [default_input_device] + device_range
# select only the input devices by looking at the number of input channels
input_devices = []
for device in device_range:
n_input_channels = self.pa.get_device_info_by_index(
device)['maxInputChannels']
if n_input_channels > 0:
input_devices += [device]
return input_devices
# method
# returns a list of output devices index, starting with the system default
def get_output_devices(self):
device_count = self.get_device_count()
device_range = list(range(0, device_count))
default_output_device = self.get_default_output_device()
if default_output_device is not None:
# start by the default input device
device_range.remove(default_output_device)
device_range = [default_output_device] + device_range
# select only the output devices by looking at the number of output channels
output_devices = []
for device in device_range:
n_output_channels = self.pa.get_device_info_by_index(
device)['maxOutputChannels']
if n_output_channels > 0:
output_devices += [device]
return output_devices
# method.
# The index parameter is the index in the self.input_devices list of devices !
# The return parameter is also an index in the same list.
def select_input_device(self, index):
device = self.input_devices[index]
# save current stream in case we need to restore it
previous_stream = self.stream
previous_device = self.device
self.logger.push("Trying to open input device #%d" % (index))
try:
self.stream = self.open_stream(device)
self.device = device
self.stream.start_stream()
success = True
except:
self.logger.push("Fail")
success = False
if self.stream is not None:
self.stream.close()
# restore previous stream
self.stream = previous_stream
self.device = previous_device
if success:
self.logger.push("Success")
previous_stream.close()
self.first_channel = 0
nchannels = self.get_current_device_nchannels()
if nchannels == 1:
self.second_channel = 0
else:
self.second_channel = 1
return success, self.input_devices.index(self.device)
# method
def select_first_channel(self, index):
self.first_channel = index
success = True
return success, self.first_channel
# method
def select_second_channel(self, index):
self.second_channel = index
success = True
return success, self.second_channel
# method
def open_stream(self, device):
# by default we open the device stream with all the channels
# (interleaved in the data buffer)
max_input_channels = self.pa.get_device_info_by_index(
device)['maxInputChannels']
stream = self.pa.open(format=paInt16,
channels=max_input_channels,
rate=SAMPLING_RATE,
input=True,
input_device_index=device,
stream_callback=self.callback,
frames_per_buffer=FRAMES_PER_BUFFER)
lat_ms = 1000 * stream.get_input_latency()
self.logger.push("Device claims %d ms latency" % (lat_ms))
return stream
# method
def open_output_stream(self, device, callback):
# by default we open the device stream with all the channels
# (interleaved in the data buffer)
max_output_channels = self.pa.get_device_info_by_index(
device)['maxOutputChannels']
stream = self.pa.open(format=paInt16,
channels=max_output_channels,
rate=SAMPLING_RATE,
output=True,
frames_per_buffer=FRAMES_PER_BUFFER,
output_device_index=device,
stream_callback=callback)
return stream
def is_output_format_supported(self, device, output_format):
max_output_channels = self.pa.get_device_info_by_index(
device)['maxOutputChannels']
success = self.pa.is_format_supported(
SAMPLING_RATE,
output_device=device,
output_channels=max_output_channels,
output_format=output_format)
return success
# method
# return the index of the current input device in the input devices list
# (not the same as the PortAudio index, since the latter is the index
# in the list of *all* devices, not only input ones)
def get_readable_current_device(self):
return self.input_devices.index(self.device)
# method
def get_readable_current_channels(self):
dev_info = self.pa.get_device_info_by_index(self.device)
nchannels = dev_info['maxInputChannels']
if nchannels == 2:
channels = ['L', 'R']
else:
channels = []
for channel in range(0, dev_info['maxInputChannels']):
channels += ["%d" % channel]
return channels
# method
def get_current_first_channel(self):
return self.first_channel
# method
def get_current_second_channel(self):
return self.second_channel
# method
def get_current_device_nchannels(self):
return self.pa.get_device_info_by_index(
self.device)['maxInputChannels']
def get_device_outputchannels_count(self, device):
return self.pa.get_device_info_by_index(device)['maxOutputChannels']
def handle_new_data(self, in_data, frame_count, input_time, status):
if self.terminated:
return
if status & paInputOverflow:
print("Stream overflow!")
self.xruns += 1
self.underflow.emit()
intdata_all_channels = fromstring(in_data, int16)
int16info = iinfo(int16)
norm_coeff = max(abs(int16info.min), int16info.max)
floatdata_all_channels = intdata_all_channels.astype(float64) / float(
norm_coeff)
channel = self.get_current_first_channel()
nchannels = self.get_current_device_nchannels()
if self.duo_input:
channel_2 = self.get_current_second_channel()
if len(floatdata_all_channels) != frame_count * nchannels:
print(
"Incoming data is not consistent with current channel settings."
)
return
floatdata1 = floatdata_all_channels[channel::nchannels]
if self.duo_input:
floatdata2 = floatdata_all_channels[channel_2::nchannels]
floatdata = vstack((floatdata1, floatdata2))
else:
floatdata = floatdata1
floatdata.shape = (1, floatdata.size)
self.new_data_available.emit(floatdata, input_time, status)
self.chunk_number += 1
def set_single_input(self):
self.duo_input = False
def set_duo_input(self):
self.duo_input = True
# returns the stream time in seconds
def get_stream_time(self):
try:
return self.stream.get_time()
except OSError:
return 0
def pause(self):
self.stream.stop_stream()
def restart(self):
self.stream.start_stream()
def play(): wavName = 'test.wav' print "play %s" % (wavName) wf = wave.open(wavName, 'rb') pa = PyAudio() stream = pa.open(format=pa.get_format_from_width(wf.getsampwidth()), channels=wf.getnchannels(), rate=wf.getframerate(), output=True) data = wf.readframes(CHUNK) td = threading.Thread(target=startGame) td.start() while data != '': stream.write(data) data = wf.readframes(CHUNK) audio_data = np.fromstring(data, dtype=np.short) print data stream.stop_stream() stream.close() pa.terminate()
def record():
pa = PyAudio()
in_stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=NUM_SAMPLES)
out_stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE,output=True)
save_count = 0
save_buffer = []
save_data = []
save_count = SAVE_LENGTH
while save_count>0:
string_audio_data = in_stream.read(NUM_SAMPLES)
audio_data = np.fromstring(string_audio_data, dtype=np.short)
save_buffer.append( string_audio_data )
save_data.append( audio_data )
save_count = save_count - 1
print 'save to test.wav'
save_wave_file("test.wav",save_buffer)
def sine_tone(frequency, duration, volume=1, sample_rate=22050):
n_samples = int(sample_rate * duration)
restframes = n_samples % sample_rate
p = PyAudio()
stream = p.open(format=p.get_format_from_width(2), # 16 bit
channels=2,
rate=sample_rate,
output=True)
for i in xrange(0, 10):
if i % 2 == 0:
frequency = ZERO_FREQUENCY
else:
frequency = ONE_FREQUENCY
s = lambda t: volume * math.sin(2 * math.pi * frequency * t / sample_rate)
samples = (int(s(t) * 0x7f + 0x80) for t in xrange(n_samples))
for buf in izip(*[samples]*sample_rate): # write several samples at a time
stream.write(bytes(bytearray(buf)))
# fill remainder of frameset with silence
stream.write(b'\x80' * restframes)
stream.stop_stream()
stream.close()
p.terminate()
def __init__(self): self.THRESHOLD = 200 self.CHUNK_SIZE = 1024 self.RATE = 22100 p = PyAudio() self.stream = p.open(format=paInt16, channels=1, rate=self.RATE, input=True, output=True, frames_per_buffer=self.CHUNK_SIZE)
class pybeeptone:
def __init__(self, rate=44100):
self.rate = 44100
self.pyaudio = PyAudio()
self.stream = self.pyaudio.open(
format = self.pyaudio.get_format_from_width(1),
channels = 1, rate = self.rate, output = True)
def play_tone(self, freq=1000, duration=0.3):
rate = self.rate
length = int(math.ceil(self.rate*duration))
data = ''.join( [chr(int(math.sin(x/((rate/freq)/math.pi))*127+128))
for x in xrange(length)] )
self.stream.write(data)
def play_rest(self, duration):
rate = self.rate
length = int(math.ceil(self.rate*duration))
data = ''.join( [chr(int(128)) for x in xrange(length)] )
self.stream.write(data)
def close(self):
self.stream.stop_stream()
self.stream.close()
self.pyaudio.terminate()
def rec_audio(stat,filename,queue):
NUM_SAMPLES = 200
SAMPLING_RATE = 8000
pa = PyAudio()
stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=NUM_SAMPLES)
save_count = 0
save_buffer = []
while True:
signal=queue.get()
if(signal=="audio_start"):
break
time_start=clock()
while True:
string_audio_data = stream.read(NUM_SAMPLES)
save_buffer.append( string_audio_data )
if(stat.value==1):
break
time_finish=clock()
wf = wave.open("./temp_frame/"+filename+".wav", 'wb')
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(SAMPLING_RATE)
wf.writeframes("".join(save_buffer))
wf.close()
save_buffer = []
print("audio_start: "+str(time_start))
print("audio_end: "+str(time_finish))
print("audio_duration (sec): "+str(time_finish-time_start)) #duration (second)
print ("audio_file: ", filename, "saved" )
queue.put("wav_sav_ok")
def sine_tone(frequencies, amplitudes, duration, volume=1.0, sample_rate=22050):
n_samples = int(sample_rate * duration)
restframes = n_samples % sample_rate
p = PyAudio()
stream = p.open(format=p.get_format_from_width(1), # 8bit
channels=1, # mono
rate=sample_rate,
output=True)
def s(t):
r = 0
for i in range(0, len(frequencies)):
r += volume * amplitudes[i] * math.sin(2 * math.pi * frequencies[i] * t / sample_rate)
return r
samples = (int(s(t) * 0x7f + 0x80) for t in range(n_samples))
for buf in zip(*[samples]*sample_rate): # write several samples at a time
stream.write(bytes(bytearray(buf)))
# fill remainder of frameset with silence
stream.write(b'\x80' * restframes)
stream.stop_stream()
stream.close()
p.terminate()
def __init__(self):
super(VCGame, self).__init__(255, 255, 255, 255, 800, 600)
# 初始化参数
# frames_per_buffer
self.numSamples = 1000
# 声控条
self.vbar = Sprite('black.png')
self.vbar.position = 20, 450
self.vbar.scale_y = 0.1
self.vbar.image_anchor = 0, 0
self.add(self.vbar)
# 皮卡丘类
self.pikachu = Pikachu()
self.add(self.pikachu)
# cocosnode精灵类
self.floor = cocos.cocosnode.CocosNode()
self.add(self.floor)
position = 0, 100
for i in range(120):
b = Block(position)
self.floor.add(b)
position = b.x + b.width, b.height
# 声音输入
audio = PyAudio()
SampleRate = int(audio.get_device_info_by_index(0)['defaultSampleRate'])
self.stream = audio.open(format=paInt16,
channels=1,
rate=SampleRate,
input=True,
frames_per_buffer=self.numSamples)
self.schedule(self.update)
def main():
# read in some block data from pyaudio
RATE=44100
INPUT_BLOCK_TIME=0.2
INPUT_FRAMES_PER_BLOCK=int(RATE*INPUT_BLOCK_TIME)
pa=PyAudio()
data=True
fmt="%dh"%INPUT_FRAMES_PER_BLOCK
total_rms=0
total_blocks=0
while data:
for dr,subdr,fnames in os.walk(path):
for filename in fnames:
try:
print filename
wf=wave.open("%s/%s"%(path,filename),'rb')
strm=pa.open(format=pa.get_format_from_width(wf.getsampwidth()),
channels=wf.getnchannels(),
rate=wf.getframerate(),
input=True)
strm.stop_stream()
strm.close()
d=wf.readframes(INPUT_FRAMES_PER_BLOCK)
d=struct.unpack(fmt,d)
wf.close()
total_rms+=calc_rms(d)
total_blocks+=1
except:
#print e
print "*** ERROR ***"
data=False
avg=total_rms/total_blocks
print "The average is %f"%avg
def record(self):
#open the input of wave
pa = PyAudio()
stream = pa.open(format = paInt16, channels = 1,
rate = self.getRate(pa), input = True,
frames_per_buffer = self.NUM_SAMPLES)
save_buffer = []
record_start = False
record_end = False
no_record_times = 0
while 1:
#read NUM_SAMPLES sampling data
string_audio_data = stream.read(self.NUM_SAMPLES)
if record_start == True :save_buffer.append(string_audio_data)
print max(array('h', string_audio_data))
if max(array('h', string_audio_data)) >5000:
record_start = True
no_record_times = 0
else:
no_record_times += 1
if record_start == False:continue
if no_record_times >10:
break
stream.close()
pa.terminate()
return save_buffer
class Stream(Thread):
def __init__(self, f, on_terminated):
self.__active = True
self.__path = f
self.__paused = True
self.on_terminated = on_terminated
self.__position = 0
self.__chunks = []
self.__pyaudio = PyAudio()
Thread.__init__(self)
self.start()
def play(self):
self.__paused = False
def seek(self, seconds):
self.__position = int(seconds * 10)
def is_playing(self):
return self.__active and not self.__paused
def get_position(self):
return int(self.__position / 10)
def get_duration(self):
return int(len(self.__chunks) / 10)
def pause(self):
self.__paused = True
def kill(self):
self.__active = False
def __get_stream(self):
self.__segment = AudioSegment.from_file(self.__path)
self.__chunks = make_chunks(self.__segment, 100)
return self.__pyaudio.open(format=self.__pyaudio.get_format_from_width(self.__segment.sample_width),
channels=self.__segment.channels,
rate=self.__segment.frame_rate,
output=True)
def run(self):
stream = self.__get_stream()
while self.__position < len(self.__chunks):
if not self.__active:
break
if not self.__paused:
# noinspection PyProtectedMember
data = self.__chunks[self.__position]._data
self.__position += 1
else:
free = stream.get_write_available()
data = chr(0) * free
stream.write(data)
stream.stop_stream()
self.__pyaudio.terminate()
if self.__active:
self.on_terminated()
def worker():
p = PyAudio()
stream = p.open(format=p.get_format_from_width(2),
channels=1, rate=44100, output=True)
while True:
self.lock.acquire()
stream.write(self.wavdata.tostring())
self.lock.release()
def Audio_record_play(seconds,play,filename):
'''
This function include record and play, if you want to play and record,
please set the play is True.
The sample rate is 44100
Bit:16
'''
CHUNK = 1024
CHANNELS = 2
SAMPLING_RATE = 44100
FORMAT = paInt16
NUM = int(SAMPLING_RATE/CHUNK * seconds)
save_buffer = []
if play is True:
source_file = autohandle_directory + '/audio_lib/'+'source1.wav'
swf = wave.open(source_file, 'rb')
#open audio stream
pa = PyAudio()
default_input = pa.get_default_host_api_info().get('defaultInputDevice')
stream = pa.open(
format = FORMAT,
channels = CHANNELS,
rate = SAMPLING_RATE,
input = True,
output = play,
frames_per_buffer = CHUNK,
input_device_index = default_input
)
logging.info(">> START TO RECORD AUDIO")
while NUM:
save_buffer.append(stream.read(CHUNK))
NUM -= 1
if play is True:
data = swf.readframes(CHUNK)
stream.write(data)
if data == " ": break
#close stream
stream.stop_stream()
stream.close()
pa.terminate()
# save wav file
def save_wave_file(filename,data):
wf_save = wave.open(filename, 'wb')
wf_save.setnchannels(CHANNELS)
wf_save.setsampwidth(pa.get_sample_size(FORMAT))
wf_save.setframerate(SAMPLING_RATE)
wf_save.writeframes("".join(data))
wf_save.close()
save_wave_file(filename, save_buffer)
del save_buffer[:]
class RadioServer:
def __init__(self):
self.pa=PyAudio()
self.input_names={}
self.output_names={}
self.listeners=[]
def registerDevices(self,inputDevice=None,outputDevice=None):
if inputDevice==None:
self.inputDevice=InputDevice(self.pa)
else:
self.inputDevice=inputDevice
if outputDevice==None:
self.outputDevice=OutputDevice(self.pa)
else:
self.outputDevice=outputDevice
def registerInput(self,descriptor,name):
self.input_names[name]=descriptor
def registerOutput(self,descriptor,name):
self.output_names[name]=descriptor
def subscribeToInput(self,name,queue):
self.inputDevice.subscribe(queue,self.input_names[name])
def subscribeToOutput(self,name,queue):
self.outputDevice.subscribe(queue,self.output_names[name])
def addListener(self,listener):
self.listeners.append(listener)
listener.bind(self)
def start(self):
for l in self.listeners:
l.start()
self.inputDevice.start()
self.outputDevice.start()
def stop(self):
self.inputDevice.stop()
self.outputDevice.stop()
for l in self.listeners:
l.stop()
self.pa.terminate()
def sigint(self,signal,frame):
self.stop()
def run_forever(self):
self.start()
signal.signal(signal.SIGINT,lambda s,f:self.sigint(s,f))
signal.pause()
def playWaveData(self, waveData):
p = PyAudio()
stream = p.open(format = p.get_format_from_width(1),
channels = 1,
rate = self.bitRate,
output = True)
stream.write(waveData)
stream.stop_stream()
stream.close()
p.terminate()
def record_wave(self):
#open the input of wave
pa = PyAudio()
stream = pa.open(format = paInt16, channels = 1,
rate = self.framerate, input = True,
frames_per_buffer = self.NUM_SAMPLES)
save_buffer = []
count = 0
while count < self.TIME*5:
string_audio_data = stream.read(self.NUM_SAMPLES)
audio_data = np.fromstring(string_audio_data, dtype=np.short)
# 得到audio_data中大约level的数据个数
large_sample_count = np.sum( audio_data > self.LEVEL )
#print large_sample_count
#print 'mute_begin' + str(self.mute_begin)
#print 'mute_end' + str(self.mute_end)
#未开始计时，出现静音
# 如果一帧数据数据的有效数据小于mute_count_limit，则认为是静音
if large_sample_count < self.mute_count_limit :
# 初始化静音计数
self.mute_begin=1
else:
# 如果有声音出现
save_buffer.append(string_audio_data)
# 静音标记为否
self.mute_begin=0
# 静音时长为0
self.mute_end=1
count += 1
# 如果静音时长大于5
if (self.mute_end - self.mute_begin) > 3:
# 还原变量
self.mute_begin=0
# 还原变量
self.mute_end=1
# 结束本次从声卡取值，本次录音结束
break
# 如果是静音，那么自增静音时长mute_end
if self.mute_begin:
self.mute_end+=1
save_buffer=save_buffer[:]
if save_buffer:
if self.file_name_index < 11:
pass
else:
self.file_name_index = 1
filename = str(self.file_name_index)+'.wav'
self.save_wave_file(filename=filename, data=save_buffer)
self.writeQ(queue=self.wav_queue, data=filename)
self.file_name_index+=1
save_buffer = []
#在嵌入式设备上必须加这一句，否则只能录音一次，下次录音时提示stram overflow 错误。
stream.close()
def play(self): print "play %s" % (self.fileName) pa = PyAudio() stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, output=True, frames_per_buffer=BUFFER_SIZE) stream.write(self.stringAudioData) # stream.write(self.cutAudio) stream.stop_stream() stream.close() pa.terminate()
def Record(self):
global CHANNELS
# 开启声音输入
pa = PyAudio()
stream = pa.open(format=paInt16, channels=CHANNELS, rate=self.sampling_rate, input=True,
frames_per_buffer=self.cacheblock_size)
save_count = 0 # 已经保存的样本块
silence_count = 0 # 持续无声音的样本块
save_buffer = [] # 音频缓冲
try:
print "start recording"
while True:
# 录音、取样
string_audio_data = stream.read(self.cacheblock_size)
# 将读入的数据转换为数组
audio_data = np.fromstring(string_audio_data, dtype=np.short)
# 样本值大于LEVEL的取样为成功取样，计算成功取样的样本的个数
large_sample_count = np.sum(audio_data > self.level)
print "Peak:",np.max(audio_data)," Sum:",large_sample_count
# 如果成功取样数大于SAMPLING_NUM，则当前数据块取样都成功
if large_sample_count > self.sampling_num:
# 有成功取样的数据块时，样本计数+1
save_count += 1
else:
# 有成功录取的块后，若取样失败，此时可能处于静音状态，静音计数+1
if(save_count > 0):
silence_count += 1
# 取样失败次数是否超过最大值
if (save_count <= self.max_save_length) and (silence_count <= self.max_silence_length):
# 将要保存的数据存放到save_buffer中
save_buffer.append(string_audio_data)
else:
# 将save_buffer中的数据写入WAV文件，WAV文件的文件名是保存的时刻
if len(save_buffer) > 0:
self.filename = datetime.now().strftime("%Y-%m-%d_%H_%M_%S") + ".wav"
self.__Save_wave_file(self.filename, save_buffer)
save_buffer = []
print self.filename, "saved"
break
except KeyboardInterrupt:
print "manual exit"
finally:
# stop stream
stream.stop_stream()
stream.close()
# close PyAudio
pa.terminate()
print "exit recording"
return self.filename
def recode(self):
pa = PyAudio()
stream = pa.open(format=paInt16, channels=self.nchannel, rate=self.SAMPLING_RATE, input=True, frames_per_buffer=self.NUM_SAMPLES)
save_count = 0
save_buffer = []
time_out = self.TIME_OUT
NO_WORDS=self.NO_WORDS
while True and NO_WORDS:
time_out -= 1
print 'time_out in', time_out # 读入NUM_SAMPLES个取样
string_audio_data = stream.read(self.NUM_SAMPLES) # 将读入的数据转换为数组
audio_data = np.fromstring(string_audio_data, dtype=np.short)
# 查看是否没有语音输入
NO_WORDS -= 1
if np.max(audio_data) > self.UPPER_LEVEL:
NO_WORDS=self.NO_WORDS
print 'self.NO_WORDS ', NO_WORDS
print 'np.max(audio_data) ', np.max(audio_data)
# 计算大于LOWER_LEVEL的取样的个数
large_sample_count = np.sum( audio_data > self.LOWER_LEVEL )
# 如果个数大于COUNT_NUM，则至少保存SAVE_LENGTH个块
if large_sample_count > self.COUNT_NUM:
save_count = self.SAVE_LENGTH
else:
save_count -= 1
#print 'save_count',save_count
# 将要保存的数据存放到save_buffer中
if save_count < 0:
save_count = 0
elif save_count > 0 :
save_buffer.append( string_audio_data )
else:
pass
# 将save_buffer中的数据写入WAV文件，WAV文件的文件名是保存的时刻
if len(save_buffer) > 0 and NO_WORDS==0:
self.Voice_String = save_buffer
save_buffer = []
rospy.loginfo( "Recode a piece of voice successfully!")
#return self.Voice_String
elif len(save_buffer) > 0 and time_out==0:
self.Voice_String = save_buffer
save_buffer = []
rospy.loginfo( "Recode a piece of voice successfully!")
#return self.Voice_String
else:
pass
def main(): # 开启声音输入 pa = PyAudio() stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=NUM_SAMPLES); time = np.arange(0, NUM_SAMPLES) * (1.0/SAMPLING_RATE); delta = 0 while True: print "delta = ", delta delta += NUM_SAMPLES * (1.0/SAMPLING_RATE) # 读入NUM_SAMPLES个取样 string_audio_data = stream.read(NUM_SAMPLES) # 将读入的数据转换为数组 audio = np.fromstring(string_audio_data, dtype=np.short) curr = [] for i in range(1, len(time)): dy = audio[i] - audio[i-1] if (abs(dy) > THRESHOLD): # print abs(dy) curr.append(delta + time[i]) blk_sum = 0 blk_num = 0 for i in range(1, len(curr)): if (curr[i] - curr[i-1] < MAXDELTA): blk_sum += curr[i] blk_num += 1 else: if (blk_num > 60): print "blk::sum, num = ", blk_sum/blk_num, blk_num push(blk_sum/blk_num) blk_sum = 0 blk_num = 0 if (blk_num > 60): print "blk::sum, num = ", blk_sum/blk_num, blk_num push(blk_sum/blk_num) cnt = 0 for i in range(1, len(event)): if (event[i] - event[i-1] < 0.4): cnt += 1 else: cnt = 0 if (cnt >= 2): thread.start_new_thread(play, ()) print "-- shuia" del event[0:i+1] break print event
def record_wav(self,save_file_name):
pa = PyAudio()
stream = pa.open(format = paInt16
,channels = 1
,rate = self.framerate
,input = True
,frames_per_buffer = self.NUM_SAMPLES)
buf = []
while self.isRecording:
audio_data = stream.read(self.NUM_SAMPLES)
buf.append(audio_data)
self.save_wav_file(save_file_name, buf)
stream.close()
def __init__(self, file="audio"):
self.format = paInt16
audio = PyAudio()
if hasattr(settings, 'AUDIO_DEVICE_INDEX'):
self.device_index = settings.AUDIO_DEVICE_INDEX
elif hasattr(settings, 'AUDIO_DEVICE'):
for i in range(audio.get_device_count()):
curr_device = audio.get_device_info_by_index(i)
print 'Found device: %s' % curr_device['name']
if curr_device['name'] == settings.AUDIO_DEVICE:
print 'Assigning %s (Index: %s)' % (
settings.AUDIO_DEVICE, i
)
self.device_index = i
elif not hasattr(self, 'device_index'):
print 'No Audio device specified. Discovering...'
for i in range(audio.get_device_count()):
curr_device = audio.get_device_info_by_index(i)
print 'Found device: %s' % curr_device['name']
if curr_device['maxInputChannels'] > 0:
self.device_index = curr_device['index']
print 'Using device: %s' % curr_device['name']
break
print audio.get_device_info_by_index(self.device_index)
try:
device = audio.get_device_info_by_index(self.device_index)
calc_rate = device['defaultSampleRate']
print 'Discovered Sample Rate: %s' % calc_rate
self.rate = int(calc_rate)
except:
print 'Guessing sample rate of 44100'
self.rate = 44100
self.channel = 1
self.chunk = 1024
self.file = file
def openWav(self):
chunk = 1024
wf = wave.open(r"result.wav", 'rb')
p = PyAudio()
stream = p.open(format = p.get_format_from_width(wf.getsampwidth()), channels = wf.getnchannels(), rate = wf.getframerate(), output = True)
while True:
data = wf.readframes(chunk)
if data == "":break
stream.write(data)
stream.close()
p.terminate()
class AudioStream(object):
def __init__(self, sample_rate=44100, channels=1, width=2, chunk=1024,
input_device_index=None):
self.sample_rate = sample_rate
self.channels = channels
self.width = width
self.chunk = chunk
self.input_device_index = input_device_index
def __enter__(self):
self._pa = PyAudio()
if self.input_device_index is None:
self.input_device_index = \
self._pa.get_default_input_device_info()['index']
self._stream = self._pa.open(
format=self._pa.get_format_from_width(self.width),
channels=self.channels,
rate=self.sample_rate,
input=True,
frames_per_buffer=self.chunk,
input_device_index=self.input_device_index)
self._stream.start_stream()
return self
def read(self):
''' On a buffer overflow this returns 0 bytes. '''
try:
return self._stream.read(self.chunk)
except IOError:
return ''
except AttributeError:
raise Exception('Must be used as a context manager.')
def stream(self):
try:
while True:
bytes = self.read()
if bytes:
self.handle(bytes)
except (KeyboardInterrupt, SystemExit):
pass
def __exit__(self, type, value, traceback):
self._stream.stop_stream()
self._stream.close()
self._pa.terminate()
def handle(self, bytes):
pass
def loaddb(self): print 'load', self.fileName pa = PyAudio() wf = wave.open(self.fileName, 'rb') save_buffer = [] string_audio_data = wf.readframes(BUFFER_SIZE) while string_audio_data != '': audio_data = np.fromstring(string_audio_data, dtype=np.short) save_buffer.append( string_audio_data ) string_audio_data = wf.readframes(BUFFER_SIZE) pa.terminate() self.stringAudioData = "".join(save_buffer) save_data = np.fromstring(self.stringAudioData, dtype=np.short) self.audioData = save_data
def play(wave_data):
chunk_size = BITRATE/10
p = PyAudio()
stream = p.open(format = p.get_format_from_width(1),
channels = 1,
rate = BITRATE,
output = True)
for chunk in itertools.islice(wave_data, chunk_size):
stream.write(chunk)
stream.stop_stream()
stream.close()
p.terminate()
def throw_process_loop(self, q: Queue):
""" A sound loop. """
import sounddevice
p = PyAudio()
stream = p.open(
format=self.formatting,
channels=self.channels,
rate=self.rate,
output=True
)
while q.empty():
stream.write(self.data)
p.terminate()
stream.close()
from pyaudio import PyAudio
import math
import time
p = PyAudio()
BITRATE = 16000 #number of frames per second/frameset.
LENGTH = 3 #seconds to play sound
THRESHOLD = -1.0
def play_tone(frequency, delay):
SILENCEFRAMES = int(BITRATE * LENGTH * delay)
NUMBEROFFRAMES = int(BITRATE * LENGTH)
RESTFRAMES = (SILENCEFRAMES + NUMBEROFFRAMES) % BITRATE
WAVEDATA = ''
for x in xrange(SILENCEFRAMES):
WAVEDATA = WAVEDATA+chr(128)
for x in xrange(NUMBEROFFRAMES):
WAVEDATA = WAVEDATA+chr(int(math.sin(x/((BITRATE/frequency)/math.pi))*127+128))
for x in xrange(RESTFRAMES):
WAVEDATA = WAVEDATA+chr(128)
return WAVEDATA
def actually_play(wavedatas):
wavedatas = [data for data in wavedatas if data]
n_datas = len(wavedatas)
actual_data = ''
for data in zip(*wavedatas):
def recoder(self):
pa = PyAudio()
stream = pa.open(format=paInt16,
channels=1,
rate=self.SAMPLING_RATE,
input=True,
frames_per_buffer=self.NUM_SAMPLES)
save_count = 0
save_buffer = []
time_count = self.TIME_COUNT
while True:
time_count -= 1
# print time_count
# 读入NUM_SAMPLES个取样
# print('又回来了')
string_audio_data = stream.read(self.NUM_SAMPLES)
# 将读入的数据转换为数组
audio_data = np.fromstring(string_audio_data, dtype=np.short)
# 计算大于LEVEL的取样的个数
large_sample_count = np.sum(audio_data > self.LEVEL)
print(np.max(audio_data))
# 如果个数大于COUNT_NUM，则至少保存SAVE_LENGTH个块
if large_sample_count > self.COUNT_NUM:
save_count = self.SAVE_LENGTH
else:
save_count -= 1
if save_count < 0:
save_count = 0
if save_count > 0:
# 将要保存的数据存放到save_buffer中
#print save_count > 0 and time_count >0
save_buffer.append(string_audio_data)
else:
#print save_buffer
# 将save_buffer中的数据写入WAV文件，WAV文件的文件名是保存的时刻
#print "debug"
if len(save_buffer) > 0:
self.Voice_String = save_buffer
save_buffer = []
# modified by jxc 20180912
client = AipSpeech(self.BAIDU_APP_ID, self.BAIDU_API_KEY,
self.BAIDU_SECRET_KEY)
voice_buffer = np.array(self.Voice_String).tostring()
result = client.asr(voice_buffer, 'wav', 16000, {
'dev_pid': 1936,
})
'''
1536 普通话(支持简单的英文识别) 搜索模型 无标点 支持自定义词库
1537 普通话(纯中文识别) 输入法模型 有标点 不支持自定义词库
1737 英语 有标点 不支持自定义词库
1637 粤语 有标点 不支持自定义词库
1837 四川话 有标点 不支持自定义词库
1936 普通话远场 远场模型 有标点 不支持
'''
print("hear : ")
# print(result['result'])
ppt_send = ''
# 需要判断是否为空！
# ppt 区域，专门设置ppt需要的内容
if (result.get('result') == None):
print(' get none ')
break
for item in self.key_words:
if item in result.get('result')[0]:
ppt_send = item
'''
if(item == '手作'):
ppt_send = 'diy'
elif(item == '订阅'):
ppt_send = 'RSS'
'''
ws = create_connection("ws://127.0.0.1:9001")
ws.send(ppt_send)
ws.close()
'''
# server.send_message_to_all('北京欢迎你')
ws = create_connection("ws://127.0.0.1:9001")
ws.send("Hello, PeKing! ")
ws.close()
'''
# modified end by jxc
print("Recode a piece of voice successfully! 1 ")
time_count = self.TIME_COUNT
return True # modified by jxc 20180912 for loop again and again
# return True
if time_count == 0:
if len(save_buffer) > 0:
self.Voice_String = save_buffer
save_buffer = []
# added by jxc 20180913
client = AipSpeech(self.BAIDU_APP_ID, self.BAIDU_API_KEY,
self.BAIDU_SECRET_KEY)
voice_buffer = np.array(self.Voice_String).tostring()
result = client.asr(voice_buffer, 'wav', 16000, {
'dev_pid': 1936,
})
'''
1536 普通话(支持简单的英文识别) 搜索模型 无标点 支持自定义词库
1537 普通话(纯中文识别) 输入法模型 有标点 不支持自定义词库
1737 英语 有标点 不支持自定义词库
1637 粤语 有标点 不支持自定义词库
1837 四川话 有标点 不支持自定义词库
1936 普通话远场 远场模型 有标点 不支持
'''
print("hear : ")
# print(result['result'])
ppt_send = ''
# 需要判断是否为空！
# ppt 区域，专门设置ppt需要的内容
if (result.get('result') == None):
print(' get none ')
break
for item in self.key_words:
if item in result.get('result')[0]:
ppt_send = item
'''
if(item == '手作'):
ppt_send = 'diy'
elif(item == '订阅'):
ppt_send = 'RSS'
'''
ws = create_connection("ws://127.0.0.1:9001")
ws.send(ppt_send)
ws.close()
'''
# server.send_message_to_all('北京欢迎你')
ws = create_connection("ws://127.0.0.1:9001")
ws.send("Hello, PeKing! ")
ws.close()
'''
time_count = self.TIME_COUNT
# add end by jxc
print("Recode a piece of voice successfully! 2 ")
time_count = self.TIME_COUNT
return True
else:
return True
def robot_state_abnormal():
rospy.init_node('robot_state_abnormal', anonymous=True)
pub = rospy.Publisher('robot_state/abnormal_detection',
RobotState,
queue_size=1)
rate = rospy.Rate(100) # 10hz
seq = 0
background_eng = 0
Fs = 11026 # 采样频率
pt_step = math.floor(Fs / 2) # 0.5s的采样点数，求能量点的数据长度
delta_time = 2.5 # 以2.5s为间隔进行平均
avrg_time = 10 # 选取10个能量点求平均能量
# last_time=10# 求10次录音进行监测，求完终止整个程序！！！即最大的录音次数。
# last_time=2 # 10+5=15s录音
last_time = 16 # 10s + 40s =50s录音
alarm_cnt = 0 # 报警计数
NUM_SAMPLES = int(Fs * delta_time) # pyAudio内部缓存的块的大小，2.5s读取点数
NUM_TEST = 4 * NUM_SAMPLES # 一次读取4个2.5s，即10s数据的总点数
# 初始化变量为列表， list
save_count = 0
save_buffer = []
eng_step = [] # 0.5s为间隔计算能量
avrg_eng_step = [] # 10个能量点求平均能量
alarm_all = [] # 每个时间点报警状态记录
bkgrd_eng = [] # 背景数据汇总数组记录每个背景点的值
########################################################################
# 先读10s录音，进行初次报警监测
########################################################################
# 开启声音输入 & 读取录音数据
pa = PyAudio()
stream = pa.open(format=paInt16,
channels=1,
rate=Fs,
input=True,
frames_per_buffer=NUM_SAMPLES)
string_audio_data = stream.read(NUM_TEST) # !!!!!! 读取10s录音 !!!!!!
y1 = np.fromstring(string_audio_data, dtype=np.short) # 读取录音数据：y1
ny = len(y1) # 10s录音数据长度
N_step = int(math.floor(ny / pt_step)) # 10s录音中的能量点数 (20)
# 求所有能量点 & 求平均能量
# for循环，求10s内所有能量点
for i_step in range(0, N_step): # 循环从0开始，循环次数为 N_step(20)
abs_y1_smth = np.abs(y1[i_step * pt_step:(i_step + 1) *
pt_step]) # 0.5s内能量取绝对值
eng_step.append(np.sum(abs_y1_smth)) # 再求和
# for循环，求平均能量(2.5s内平均) (5为2.5/0.5 2.5秒内的能量点数)
for i_avrg in range(0, int(math.floor(
N_step / 5))): # 循环从0开始，循环次数为后面int结果(20/5 = 4)
# avrg_eng_step.append(np.sum(eng_step[(i_avrg * 5):(i_avrg + 1) * 5]) / avrg_time)
avrg_eng_step.append(
np.sum(eng_step[(i_avrg * 5):(i_avrg + 1) * 5]) /
avrg_time) # ??为什么求平均用10
# 对10s录音的平均能量点进行报警监测
# if判断，根据左右两边点比较确定当前点的报警状态
# if (avrg_eng_step[2]>(avrg_eng_step[0]*5)):# 报警点
if avrg_eng_step[2] > (avrg_eng_step[0] * 2): # 报警点
alarm_sign = 1
background_eng = avrg_eng_step[0]
# elseif (avrg_eng_step(3)>(background_eng*2))% possible changing point
# elif (avrg_eng_step[2]>(avrg_eng_step[0]*2)): # 过渡点
elif avrg_eng_step[2] > (avrg_eng_step[0] * 1.5): # 过渡点
alarm_sign = -1
background_eng = avrg_eng_step[0]
else: # 背景点
alarm_sign = 0
background_eng = avrg_eng_step[1]
# 报警状态记录，报警次数累加
alarm_all.append(alarm_sign)
alarm_cnt += 1
# bkgrd_cnt=1# 记录背景点点数
# bkgrd_cnt = bkgrd_cnt+1# 背景点数累加一次
# background_eng = avrg_eng_step[0]# 背景能量初始化
# bkgrd_eng[bkgrd_cnt] = background_eng# 背景数据汇总数组记录每个背景点的值
bkgrd_eng.append(background_eng)
while not rospy.is_shutdown():
n_eng_step = len(eng_step) # 已计算的能量点序列的当前长度
n_avrg_eng_step = len(avrg_eng_step) # 已计算的平均能量点序列的当前长度
# 开启录音2.5s & 求新的平均能量点
print "读取2.5s"
string_audio_data = stream.read(
NUM_SAMPLES) # !!!!!! 读取 2.5s 录音 !!!!!!
print "读取结束"
y_next = np.fromstring(string_audio_data,
dtype=np.short) # 读取录音数据：y_next
ny = len(y_next) # 新的录音数据长度
N_step = int(math.floor(ny / pt_step)) # 新的录音数据包含的能量点数
# 输出当前录音数据的能量点数和录音长度
# print "!!!!"
# print N_step
# print ny
# print "!!!!"
# for循环，求新的2.5s录音数据的所有能量点
# for i_step in range(1,N_step):
for i_step in range(0, N_step): # 循环从0开始，次数为 N_step
abs_y1_smth = np.abs(y_next[i_step * pt_step:(i_step + 1) *
pt_step])
eng_step.append(np.sum(abs_y1_smth)) # 将新计算点加入list的尾部
# 输出所求新的能量点
# print "****eng_step"
# print(eng_step)
# 求新的平均能量点
# avrg_eng_step.append(np.sum(eng_step[((n_avrg_eng_step-1)*5):(n_eng_step+4)])/ avrg_time)
avrg_eng_step.append(
np.sum(eng_step[n_avrg_eng_step * 5:(n_avrg_eng_step + 1) * 5]) /
avrg_time)
print "#######"
print avrg_eng_step[-1]
print background_eng
print "&&&&&&&"
# 输出新求的能量点和平均能量点
# print "****"
# print eng_step[(n_avrg_eng_step * 5):(n_eng_step + 4)]# 新求的能量点
# print "****avrg_eng_step"
# print (avrg_eng_step)# 新求的平均能量点
# 判断新点报警状态
# if判断，决定新的平均能量点的报警状态
if alarm_sign == 0: # 当前是非报警状态
# if (avrg_eng_step[n_avrg_eng_step] > (avrg_eng_step[n_avrg_eng_step - 1] * 2)):
# if (avrg_eng_step[n_avrg_eng_step] > (avrg_eng_step[n_avrg_eng_step-2]*5)):# 是报警点
# if (avrg_eng_step[n_avrg_eng_step] > (background_eng*5)):# 是报警点
if avrg_eng_step[n_avrg_eng_step] > (background_eng * 2.4): # 是报警点
alarm_sign = 1 # 报警
# elif (avrg_eng_step[n_avrg_eng_step-1] > (background_eng*2)):# 是过渡点
elif avrg_eng_step[n_avrg_eng_step] > (background_eng *
1.5): # 是过渡点
alarm_sign = -1 # 过渡点
else: # 是非报警点
alarm_sign = 0 # 非报警
# background_eng = avrg_eng_step[n_avrg_eng_step]
background_eng = avrg_eng_step[n_avrg_eng_step] # 更新背景值
bkgrd_eng.append(background_eng) # 增添新的背景值
elif alarm_sign == 1: # 当前是报警状态
# if (avrg_eng_step[n_avrg_eng_step] > (background_eng * 2)):
# if (avrg_eng_step[n_avrg_eng_step - 1] > (background_eng * 2)):
# if (avrg_eng_step[n_avrg_eng_step-1] > (background_eng*5)):# 是报警点
if avrg_eng_step[n_avrg_eng_step] > (background_eng * 2.4): # 是报警点
alarm_sign = 1 # 报警
# elif (avrg_eng_step[n_avrg_eng_step-1] > (background_eng*2)): # 是过渡点
elif avrg_eng_step[n_avrg_eng_step] > (background_eng *
1.5): # 是过渡点
alarm_sign = -1 # 过渡点
else: # 是非报警点
alarm_sign = 0 # 非报警
# background_eng = avrg_eng_step[n_avrg_eng_step]
background_eng = avrg_eng_step[n_avrg_eng_step] # 更新背景值
bkgrd_eng.append(background_eng) # 增添新的背景值
elif alarm_sign == -1: # 当前是过渡点状态
# if (avrg_eng_step[n_avrg_eng_step-1] > (background_eng*5)): # 是报警点
if avrg_eng_step[n_avrg_eng_step] > (background_eng * 2.4): # 是报警点
alarm_sign = 1 # 报警
# elif (avrg_eng_step[n_avrg_eng_step-1] > (background_eng*2)): # 是过渡点
elif avrg_eng_step[n_avrg_eng_step] > (background_eng *
1.5): # 是过渡点
alarm_sign = -1 # 过渡点
else: # 是非报警点
alarm_sign = 0 # 非报警
# background_eng = avrg_eng_step[n_avrg_eng_step]
background_eng = avrg_eng_step[n_avrg_eng_step] # 更新背景值
bkgrd_eng.append(background_eng) # 增添新的背景值
# else:
# alarm_sign = 0
# background_eng = avrg_eng_step[n_avrg_eng_step - 1]
# 增添新的报警状态记录 & 报警次数累加
alarm_all.append(alarm_sign)
alarm_cnt += 1
if alarm_sign == 1:
print "AAAAAAAAAAAAA"
robot_state.abnormal_detection = True
else:
robot_state.abnormal_detection = False
# if判断，决定while循环何时终止
# if alarm_cnt > 20:
# if alarm_cnt > 10:
# if alarm_cnt > last_time:
# loop_sign = 1
robot_state.header.stamp = rospy.Time.now()
robot_state.header.frame_id = ''
robot_state.header.seq = seq
pub.publish(robot_state)
seq = seq + 1
#print array
rate.sleep()
class Listener:
def __init__(self, **kwargs) -> None:
super().__init__()
self.sample_rate = kwargs.get('sample_rate', 44100)
self.buffer_size = kwargs.get('buffer_size', 1024)
self.pa = PyAudio()
self.pitch = pitch('default', self.buffer_size, self.buffer_size // 2,
self.sample_rate)
self.pitch.set_unit('midi')
self.pitch.set_tolerance(0.7)
self.tempo = tempo('default', self.buffer_size, self.buffer_size // 2,
self.sample_rate)
low_filter = digital_filter(3)
low_filter.set_biquad(7.89276652e-4, 0.00157855, 7.89276652e-4,
-1.94146067, 0.94461777)
mid_filter = digital_filter(3)
mid_filter.set_biquad(0.13357629, 0.0, -0.13357629, -1.64841689,
0.73284743)
high_filter = digital_filter(3)
high_filter.set_biquad(0.72530667, -1.45061333, 0.72530667,
-1.32614493, 0.57508174)
self.filters = [low_filter, mid_filter, high_filter]
self.stream = None
def start_stream(self):
self.stream = self.pa.open(format=paFloat32,
channels=1,
rate=self.sample_rate,
input=True,
frames_per_buffer=self.buffer_size)
def stop_stream(self):
self.stream.stop_stream()
self.stream.close()
self.pa.terminate()
self.stream = None
def listen(self, data_queues, stop_event: Event):
if self.stream is None:
self.start_stream()
try:
def loop():
# Get microphone data
data = self.stream.read(self.buffer_size // 2)
signal = np.fromstring(data, dtype=np.float32)
for queue in data_queues:
queue.put_nowait(signal)
# for i, signal_filter in enumerate(self.filters):
# f_sig = signal_filter(signal)
# pitch = self.pitch(f_sig)[0] / 128.0
# is_beat = self.tempo(f_sig)
# if is_beat > 0.:
# # print(f'[{", ".join(str(p) for p in pitches)}]')
# callback(pitch, i)
while True:
try:
loop()
except KeyboardInterrupt:
print("Ctrl-C Terminating...")
break
except Exception as e:
print(e)
print("ERROR Terminating...")
break
finally:
stop_event.set()
# stop_callback()
self.stop_stream()
class Noise:
chunk = 1024
def __init__(self):
"""Init noise"""
self.wf = wave.open(os.path.join(os.path.dirname(__file__), "noise/noise.wav"), 'rb');
self.p = PyAudio()
self.fftArray = []
self.fft()
self.curentIndex = 0
def callback(in_data, frame_count, time_info, status):
data = self.wf.readframes(frame_count)
self.curentIndex += 1
if len(data) < 2*frame_count:
self.wf.rewind()
self.curentIndex = 0
data = self.wf.readframes(frame_count)
return (data, paContinue)
self.stream = self.p.open(
format = self.p.get_format_from_width(self.wf.getsampwidth()),
channels = self.wf.getnchannels(),
rate = self.wf.getframerate(),
output = True,
frames_per_buffer=self.chunk,
start=False,
stream_callback=callback
)
def wav2array(self, nchannels, sampwidth, data):
num_samples, remainder = divmod(len(data), sampwidth * nchannels)
if remainder > 0:
raise ValueError('The length of data is not a multiple of '
'sampwidth * num_channels.')
if sampwidth > 4:
raise ValueError("sampwidth must not be greater than 4.")
if sampwidth == 3:
a = np.empty((num_samples, nchannels, 4), dtype=np.uint8)
raw_bytes = np.fromstring(data, dtype=np.uint8)
a[:, :, :sampwidth] = raw_bytes.reshape(-1, nchannels, sampwidth)
a[:, :, sampwidth:] = (a[:, :, sampwidth - 1:sampwidth] >> 7) * 255
result = a.view('<i4').reshape(a.shape[:-1])
else:
dt_char = 'u' if sampwidth == 1 else 'i'
a = np.fromstring(data, dtype='<%s%d' % (dt_char, sampwidth))
result = a.reshape(-1, nchannels)
return result
def fft(self):
self.wf.rewind()
while True:
data = self.wf.readframes(self.chunk)
if len(data) < 2*self.chunk:
break
array = self.wav2array(self.wf.getnchannels(), self.wf.getsampwidth(), data)
fs = self.wf.getframerate()
ff = np.fft.fft(array)
freq = np.fft.fftfreq(len(array), d=1./fs)
ff += 0.00001 # da ne bi desio log od 0
ffDec = 20*np.log10(np.abs(ff[0:ff.shape[0]//2]))
ffDec -= np.max(ffDec)
freq = freq[0:len(freq)//2]
result = dict(zip(freq.tolist(), ffDec.tolist()));
self.fftArray.append(result)
self.wf.rewind()
def close(self):
self.stream.close()
self.p.terminate()
def __init__(self, args):
super().__init__(args)
self.orig_settings = tcgetattr(stdin)
self.p = PyAudio()
class PreciseRunner(object):
"""
Wrapper to use Precise. Example:
>>> def on_act():
... print('Activation!')
...
>>> p = PreciseRunner(PreciseEngine('./precise-engine'), on_activation=on_act)
>>> p.start()
>>> from time import sleep; sleep(10)
>>> p.stop()
Args:
engine (Engine): Object containing info on the binary engine
trigger_level (int): Number of chunk activations needed to trigger on_activation
Higher values add latency but reduce false positives
sensitivity (float): From 0.0 to 1.0, relates to the network output level required
to consider a chunk "active"
stream (BinaryIO): Binary audio stream to read 16000 Hz 1 channel int16
audio from. If not given, the microphone is used
on_prediction (Callable): callback for every new prediction
on_activation (Callable): callback for when the wake word is heard
"""
def __init__(self,
engine,
trigger_level=3,
sensitivity=0.5,
stream=None,
on_prediction=lambda x: None,
on_activation=lambda: None):
self.engine = engine
self.trigger_level = trigger_level
self.sensitivity = sensitivity
self.stream = stream
self.on_prediction = on_prediction
self.on_activation = on_activation
self.chunk_size = engine.chunk_size
self.pa = None
self.thread = None
self.running = False
self.is_paused = False
atexit.register(self.stop)
def start(self):
"""Start listening from stream"""
if self.stream is None:
from pyaudio import PyAudio, paInt16
self.pa = PyAudio()
self.stream = self.pa.open(16000,
1,
paInt16,
True,
frames_per_buffer=self.chunk_size)
self.engine.start()
self.running = True
self.is_paused = False
self.thread = Thread(target=self._handle_predictions)
self.thread.daemon = True
self.thread.start()
def stop(self):
"""Stop listening and close stream"""
if self.thread:
self.running = False
self.thread.join()
self.thread = None
self.engine.stop()
if self.pa:
self.pa.terminate()
self.stream.stop_stream()
self.stream = self.pa = None
def pause(self):
self.is_paused = True
def play(self):
self.is_paused = False
def _handle_predictions(self):
"""Continuously check Precise process output"""
activation = 0
while self.running:
chunk = self.stream.read(self.chunk_size // 2)
if self.is_paused:
continue
prob = self.engine.get_prediction(chunk)
self.on_prediction(prob)
if prob > 1 - self.sensitivity or activation < 0:
activation += 1
if activation > self.trigger_level:
activation = -self.chunk_size // 50
self.on_activation()
elif activation > 0:
activation -= 1
from pprint import pprint
from pyaudio import PyAudio
pyaud = PyAudio()
for i in range(pyaud.get_device_count()):
dev = pyaud.get_device_info_by_index(i)
pprint(dev)
def __init__(self, postProcessCallback=None):
super().__init__(postProcessCallback=postProcessCallback)
self.pyaudio = PyAudio()
self.stream = None
class PreciseRunner(object):
"""
Wrapper to use Precise. Example:
>>> def on_act():
... print('Activation!')
...
>>> p = PreciseRunner(PreciseEngine('./precise-engine'), on_activation=on_act)
>>> p.start()
>>> from time import sleep; sleep(10)
>>> p.stop()
Args:
engine (Engine): Object containing info on the binary engine
trigger_level (int): Number of chunk activations needed to trigger on_activation
Higher values add latency but reduce false positives
sensitivity (float): From 0.0 to 1.0, relates to the network output level required
to consider a chunk "active"
stream (BinaryIO): Binary audio stream to read 16000 Hz 1 channel int16
audio from. If not given, the microphone is used
on_prediction (Callable): callback for every new prediction
on_activation (Callable): callback for when the wake word is heard
"""
def __init__(self,
engine,
trigger_level=3,
sensitivity=0.5,
stream=None,
on_prediction=lambda x: None,
on_activation=lambda: None):
self.engine = engine
self.trigger_level = trigger_level
self.sensitivity = sensitivity
self.stream = stream
self.on_prediction = on_prediction
self.on_activation = on_activation
self.chunk_size = engine.chunk_size
self.read_divisor = 1
print('sensitivity: ', self.sensitivity)
self.pa = None
self.thread = None
self.running = False
self.is_paused = False
self.detector = TriggerDetector(self.chunk_size, sensitivity,
trigger_level)
atexit.register(self.stop)
def _calc_read_divisor(self):
"""
pyaudio.Stream.read takes samples as n, not bytes
so read(n) should be read(n // sample_depth
"""
try:
import pyaudio
if isinstance(self.stream, pyaudio.Stream):
return 2
except ImportError:
pass
return 1
def start(self):
"""Start listening from stream"""
if self.stream is None:
from pyaudio import PyAudio, paInt16
self.pa = PyAudio()
print("================================================")
info = self.pa.get_host_api_info_by_index(0)
numdevices = info.get('deviceCount')
for i in range(0, numdevices):
if (self.pa.get_device_info_by_host_api_device_index(
0, i).get('maxInputChannels')) > 0:
print(
"Input Device id ", i, " - ",
self.pa.get_device_info_by_host_api_device_index(
0, i).get('name'),
self.pa.get_device_info_by_index(i).get(
'defaultSampleRate'))
print("================================================")
self.stream = self.pa.open(rate=16000,
channels=1,
format=paInt16,
input=True,
frames_per_buffer=self.chunk_size,
input_device_index=2)
self.read_divisor = self._calc_read_divisor()
self.engine.start()
self.running = True
self.is_paused = False
self.thread = Thread(target=self._handle_predictions)
self.thread.daemon = True
self.thread.start()
def stop(self):
"""Stop listening and close stream"""
if self.thread:
self.running = False
if isinstance(self.stream, ReadWriteStream):
self.stream.write(b'\0' * self.chunk_size)
self.thread.join()
self.thread = None
self.engine.stop()
if self.pa:
self.pa.terminate()
self.stream.stop_stream()
self.stream = self.pa = None
def pause(self):
self.is_paused = True
def play(self):
self.is_paused = False
def _handle_predictions(self):
"""Continuously check Precise process output"""
while self.running:
# print('chunk_size: ', self.chunk_size, ' read_divisor: ', self.read_divisor)
chunk = self.stream.read(self.chunk_size // self.read_divisor,
exception_on_overflow=False)
if self.is_paused:
continue
prob = self.engine.get_prediction(chunk)
self.on_prediction(prob)
if self.detector.update(prob):
self.on_activation()
#Actualizción de la leyenda que actúa como frecuencímetro
def set_legend(values):
legend.clear()
for item in values:
legend.addItem(traces['spectrum'], "f = " + str(floor(item)) + " Hz")
#Configuración de canal de entrada de audio
BUFF = 1024 * 3
FORMAT = paInt16
bits = 16
bitFormat = 'h'
RATE = 44100
ts = 1 / RATE
audio = PyAudio()
stream = audio.open(format=FORMAT,
channels=1,
rate=RATE,
input=True,
output=False,
frames_per_buffer=BUFF)
#Inicialización de vectores de tiempo y frecuencia
t = arange(0, ts * BUFF, ts)
F = fft.fftfreq(BUFF, ts)
F = split(F, 2)[0]
Threshold = 50
#Funciones de identificación y ordenamiento de picos
voice_fp = open(filename, 'wb+')
voice_fp.write(voice_data)
voice_fp.close()
pass
#百度语音合成--------------------------------------
NUM_SAMPLES = 2000 # pyAudio内部缓存的块的大小
SAMPLING_RATE = 8000 # 取样频率
LEVEL = 1500 # 声音保存的阈值
COUNT_NUM = 20 # NUM_SAMPLES个取样之内出现COUNT_NUM个大于LEVEL的取样则记录声音
SAVE_LENGTH = 8 # 声音记录的最小长度：SAVE_LENGTH * NUM_SAMPLES 个取样
exception_on_overflow = False
# 开启声音输入ｐｙａｕｄｉｏ对象
pa = PyAudio()
stream = pa.open(format=paInt16,
channels=1,
rate=SAMPLING_RATE,
input=True,
frames_per_buffer=NUM_SAMPLES)
token = get_token() #获取ｔｏｋｅｎ
key = '35ff2856b55e4a7f9eeb86e3437e23fe'
api = 'http://www.tuling123.com/openapi/api?key=' + key + '&info='
#百度语音合成--------------------------------------
if __name__ == "__main__":
# 我的api_key,供大家测试用，在实际工程中请换成自己申请的应用的key和secert
api_key = "SrhYKqzl3SE1URnAEuZ0FKdT"
api_secert = "hGqeCkaMPb0ELMqtRGc2VjWdmjo7T89d"
# 初始化
########################################################################################################################
# Author: Enders Kong #
# Some very basic framework double buffering for "real time" audio processing, need to use this as main and pass funs #
# for trueRealTime no need for buffers. Functions may not perform well on single threaded CPUS, try multithread #
########################################################################################################################
from pyaudio import PyAudio
import threading
# TODO: update chunks1 val
chunks1 = 0
# opening and initializing audio streams, should be using .wav files
wavStreamOpen = PyAudio()
wavStream = wavStreamOpen.open(format="format1",
channels="channels1",
rate="rate1",
input="input1",
frames_per_buffer="chunks1")
# initializing both buffers
buff1 = [0 for n in range(chunks1)]
buff2 = [0 for n in range(chunks1)]
# write to buffer1 before loop
buff1 = wavStream.read(chunks1)
def foo():
i = 0
print("you're still using foo, swap it with your actual function")
return i
gtL = [[96], [8, 4, 2, 2], [4, 4, 8], gtD[3], gtD[4], gtD[5], gtD[6], gtD[7],
[b, c, b, c, b, b], [4, 4, 8]]
gt = [
0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 5, 4, 4, 4, 6, 4, 4, 4, 5, 4, 4,
4, 7, 1, 1, 1, 1, 2, 2, 2, 2, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8
]
sg["bd"] = [bd, bdN, bdD, bdL]
sg["mn"] = [mn, mnN, mnD, mnL]
sg["cr"] = [cr, crN, crD, crL]
sg["rc"] = [rc, rcN, rcD, rcL]
sg["bs"] = [bs, bsN, bsD, bsL]
sg["sy"] = [sy, syN, syD, syL]
sg["sc"] = [sc, scN, scD, scL]
sg["gt"] = [gt, gtN, gtD, gtL]
z = [[] for i in X(8)]
p = PyAudio()
st = p.open(format=p.get_format_from_width(1), channels=1, rate=R, output=True)
os.system("clear")
for i in X(R):
sD.append(math.sin(tp * (float(i) / R)))
tP = 0
for tk in sg:
A = z[tP].append
for pt in sg[tk][0]:
pP = 0
nP = 0
for n in sg[tk][1][pt]:
ss = int(qL * sg[tk][3][pt][nP] * R)
du = int(qL * sg[tk][2][pt][nP] * R)
if n != g:
F = 440 * pow(1.059463094, n)
def __init__(self):
super(VoiceGame, self).__init__(255, 255, 255, 255, WIDTH, HEIGHT)
pygame.mixer.init()
global random_seed
self.random_seed = random_seed
self.gameover = None
self.score = 0 #记录分数
self.txt_score = cocos.text.Label(u'分数：0',
font_name=FONTS,
font_size=24,
color=BLACK)
self.txt_score.position = 500, 440
self.add(self.txt_score, 99999)
self.top = '', 0
self.top_notice = cocos.text.Label(u'',
font_name=FONTS,
font_size=18,
color=BLACK)
self.top_notice.position = 400, 410
self.add(self.top_notice, 99999)
self.name = ''
# init voice
self.NUM_SAMPLES = 2048 # pyAudio内部缓存的块的大小
self.LEVEL = 1500 # 声音保存的阈值
self.voicebar = Sprite('black.png', color=(0, 0, 255))
self.voicebar.position = 20, 450
self.voicebar.scale_y = 0.1
self.voicebar.image_anchor = 0, 0
self.add(self.voicebar)
self.ruc = RUC(self)
self.add(self.ruc)
self.floor = cocos.cocosnode.CocosNode()
self.add(self.floor)
self.last_block = 0, 100
for i in range(5):
b = Block(self)
self.floor.add(b)
pos = b.x + b.width, b.height
# 开启声音输入
pa = PyAudio()
SAMPLING_RATE = int(
pa.get_device_info_by_index(0)['defaultSampleRate'])
self.stream = pa.open(format=paInt16,
channels=1,
rate=SAMPLING_RATE,
input=True,
frames_per_buffer=self.NUM_SAMPLES)
self.stream.stop_stream()
# pygame.mixer.music.load('bgm.wav')
# pygame.mixer.music.play(-1)
self.schedule(self.update)
self.vol_manager = socket_vol()
self.vol_manager.start()
class Playlist:
def __init__(self, filepath, repeat=True, verbose=True):
self.alive, self.lock = True, Lock()
self.player, self.files = PyAudio(), []
self.current, self.index = None, 0
self.repeat, self.repeated = repeat, 0
self.verbose = verbose
self._skipper = deque((False, ), maxlen=1)
self._scaler = deque((0.5, ), maxlen=1)
self.scan(filepath)
self.current = self.files[0]
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.stop()
def __iter__(self):
self.index = 0
self.current = self.sounds[self.index]
return self
def __next__(self):
try:
self.current = self.sounds[self.index]
except IndexError:
if self.repeat is True:
pass
elif self.repeated < self.repeat:
self.repeated += 1
else:
raise StopIteration()
self.index = 0
return next(self)
else:
self.index += 1
return self.current
def __len__(self):
return len(self.sounds)
def __gt__(self, other):
return self.sounds > other.sounds
def __ge__(self, other):
return self.sounds >= other.sounds
def __lt__(self, other):
return self.sounds < other.sounds
def __le__(self, other):
return self.sounds <= other.sounds
@property
def sounds(self):
return sorted(self.files, key=lambda f: path.basename(f))
@property
def repeat(self):
return self._repeat
@repeat.setter
def repeat(self, val):
if val is True:
self._repeat = True
elif not val:
self._repeat = 0
elif isinstance(val, int):
self._repeat = val
elif isinstance(val, float):
self._repeat = int(val)
else:
raise IndexError('Must be bool, int, or float')
@property
def scale(self):
with self.lock:
return self._scaler[0]
@scale.setter
def scale(self, val):
assert isinstance(val, (int, float)), 'Must be int or float'
if val <= 0:
scaled = 0
elif val >= 1:
scaled = 1
else:
scaled = round(val, 2)
if scaled > 0:
self.lastScaled = scaled
with self.lock:
self._scaler.append(scaled)
if self.verbose:
print('Scale: {}'.format(self._scaler[0]))
@property
def skipTrack(self):
return self._skipper[0]
@skipTrack.setter
def skipTrack(self, val):
self._skipper.append(bool(val))
def increment_scale(self, increment=.1):
self.scale += increment
def scan(self, filepath, recursive=True):
assert isinstance(filepath, str), 'Must be str'
try:
for f in scandir(filepath):
if not f.is_dir():
self.add(f.path)
elif recursive:
self.scan(f.path)
except NotADirectoryError:
if path.exists:
self.add(filepath)
def add(self, filepath):
assert isinstance(filepath, str), 'Must be str'
self.files.append(filepath)
def play(self, filepath, **kwargs):
assert self.alive
self.skipTrack = False
try:
with Sound(self.player, filepath, **kwargs) as sound:
if self.verbose:
print('Playing {}'.format(path.basename(filepath)))
sound.play(self._skipper, scaler=self._scaler)
except SkipTrack:
return
def skip(self):
if self.verbose:
print('Skipping')
self.skipTrack = True
def mute(self):
print('Muting')
self.lastScale = self.scale
self.scale = 0
def unmute(self):
print('Unmuting')
self.scale = self.lastScale
def toggle_mute(self):
if self.scale > 0:
self.mute()
else:
self.unmute()
def stop(self):
self.alive = False
self.player.terminate()
def start(self, loop=True):
if not self.sounds:
raise MissingAssetsException('Must add files to play')
for sound in self:
try:
self.play(self.current, loop=loop)
except KeyboardInterrupt:
return
from pyaudio import PyAudio, paContinue, paFloat32, paInt16
from time import sleep
import numpy as np
from ctypes import *
pa = PyAudio()
#audio = CDLL('./RealTimeAudioFilter.so')
NORM_CONST = 32768.0
D_TYPE = np.int16
def callback(in_data, frame_count, time_info, status):
# audio_data = np.fromstring(in_data, dtype=D_TYPE)
# out = audio.RealTimeAudioFilter(in_data)
return (in_data, paContinue)
stream = pa.open(format = paInt16,
channels = 1,
rate = 44100,
input = True,
output = True,
frames_per_buffer = 1024,
stream_callback = callback)
while stream.is_active():
sleep(0.1)
stream.close()
pa.terminate()
def __init__(self):
self._recorder = PyAudio()
self.recording = False
self.playing = False
#plot.add_plot("cross_sec6", yname="Macvec6", ydata=td)
#plot.add_img_plot(mag_vec, yok, linspace(0, len(anr)-1, len(anr)))
#zplot.add_img_plot(zname="blah", zdata=mag_vec)#z, ydata=linspace(0, len(anr)-1, len(anr)), xdata=linspace(0, len(yok)-1, len(yok)))
#plot.add_plot("cross_sec", yname="Macvec1", ydata=c)
# plot.add_plot("cross_se2", yname="Macvec2", ydata=mag_vec[:, 75])
plot.show()
for x in xrange(NUMBEROFFRAMES):
WAVEDATA = WAVEDATA + chr(c[x])
#fill remainder of frameset with silence
for x in xrange(RESTFRAMES):
WAVEDATA = WAVEDATA + chr(128)
p = PyAudio()
FORMAT = p.get_format_from_width(1)
#pyaudio.paInt16 = 8 corresponds to FORMAT=p.get_format_from_width(2)
#pyaudio.paInt24 = 4 corresponds to FORMAT=p.get_format_from_width(3)
print FORMAT
if 1:
stream = p.open(format=p.get_format_from_width(1),
channels=1,
rate=sample_rate,
output=True)
stream.write(WAVEDATA)
stream.stop_stream()
stream.close()
def get_audio_info():
audio = PyAudio()
info = audio.get_host_api_info_by_index(0)
print(info, '\n')
for i in range(audio.get_device_count()):
print(audio.get_device_info_by_index(i))
def Monitor():
print ("声音检测实现语音识别和合成，Press Ctrl+C to exit ")
pa = PyAudio() # 实例化pyaudio
stream = pa.open(format = paInt16,
channels=1,
rate=16000,
input=True,
frames_per_buffer=NUM_SAMPLES)
print('开始缓存录音')
# 初始化缓存数组
audioBuffer = []
rec = []
# 初始化标志位
audioFlag = False
t = False
while True:
try:
# 读取采样音频并获取特征信息
data = stream.read(NUM_SAMPLES,exception_on_overflow = False) #add exception para
audioBuffer.append(data) #录音源文件
audioData = np.fromstring(data,dtype=np.short) #字符串创建矩阵
largeSampleCount = np.sum(audioData >1000) # 采样变量
temp = np.max(audioData) # 获取声音强度
#print (temp)
if temp >3000 and t == False: # 设置声音检测阈值，需根据麦克风适当调整
t = 1 # 开始录音
print ("检测到语音信号，开始录音")
begin = time.time()
print (temp)
if t:
end = time.time()
if end-begin > 5:
timeFlag = 1 # 5s录音结束
if largeSampleCount > 20:
saveCount = 4
else:
saveCount -=1
if saveCount <0:
saveCount =0
if saveCount >0:
rec.append(data) # 合成数据
else:
if len(rec) >0 or timeFlag:
save_wave_file('detected_voice.wav',rec) # 保存检测的语音
voice.identify_synthesize('detected_voice.wav') # 调用百度语音实现语音识别和语音合成
#os.system('mplayer %s' % 'synthesis.mp3') # play synthesis
# 清除缓存
rec = []
t = 0
timeFlag = 0
except KeyboardInterrupt:
break
# 释放资源
stream.stop_stream()
stream.close()
pa.terminate()
#Python 2.x program for Speech Recognition
import speech_recognition as sr
from pyaudio import PyAudio
import sys
#enter the name of usb microphone that you found
#using lsusb
#the following name is only used as an example
mic_name = PyAudio().get_default_input_device_info()["name"]
text = ""
#Sample rate is how often values are recorded
sample_rate = 48000
#Chunk is like a buffer. It stores 2048 samples (bytes of data)
#here.
#it is advisable to use powers of 2 such as 1024 or 2048
chunk_size = 2048
#Initialize the recognizer
r = sr.Recognizer()
#generate a list of all audio cards/microphones
mic_list = sr.Microphone.list_microphone_names()
#the following loop aims to set the device ID of the mic that
#we specifically want to use to avoid ambiguity.
for i, microphone_name in enumerate(mic_list):
if microphone_name == mic_name:
device_id = i
#use the microphone as source for input. Here, we also specify
#which device ID to specifically look for incase the microphone
#is not working, an error will pop up saying "device_id undefined"
class window(QDialog):
def __init__(self):
super().__init__()
# 视频参数
self.video_capture = cv2.VideoCapture(0)
self.video_thread = True
self.audio_thread = True
self.width = int(self.video_capture.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.video_count = 0
self.audio_count = 0
self.audio_file = "media/audio.mp3"
self.video_file = "media/input.mp4"
# 音频参数
self.framerate = 44100 # 采样率
self.CHUNK = 4096 # 采样点
self.channels = 1 # 一个声道
self.sampwidth = 2 # 两个字节十六位
self.TIME = 2 # 条件变量，可以设置定义录音的时间
self.filename = datetime.now().strftime("%Y-%m-%d_%H_%M_%S") + ".wav"
self.intUI()
self.path = os.getcwd()
print("当前路径：" + self.path)
def intUI(self):
self.btnStart = QPushButton('Start', self)
self.btnStop = QPushButton('Stop', self)
self.btnPlay = QPushButton('Play', self)
self.btnStopVideo = QPushButton('sockStart', self)
self.label = QLabel()
self.label.resize(self.width, self.height)
# 布局设定
layout = QGridLayout(self)
layout.addWidget(self.label, 0, 1, 4, 4)
layout.addWidget(self.btnStart, 4, 1, 1, 1)
layout.addWidget(self.btnStop, 4, 2, 1, 1)
layout.addWidget(self.btnPlay, 4, 3, 1, 1)
layout.addWidget(self.btnStopVideo, 4, 4, 1, 1)
# 信号与槽进行连接，信号可绑定普通成员函数
self.btnStart.clicked.connect(self.Start)
self.btnStop.clicked.connect(self.Stop)
self.btnPlay.clicked.connect(self.Play)
self.btnStopVideo.clicked.connect(self.stopVideo)
def openSlot(self):
# 调用存储文件
fileName, tmp = QFileDialog.getOpenFileName(self, 'Open Image',
'Image',
'*.png *.jpg *.bmp')
if fileName is '':
return
# 采用OpenCV函数读取数据
self.img = cv2.imread(fileName, -1)
if self.img.size == 1:
return
self.refreshShow()
def saveSlot(self):
# 调用存储文件dialog
fileName, tmp = QFileDialog.getSaveFileName(self, 'Save Image',
'Image',
'*.png *.jpg *.bmp')
if fileName is '':
return
if self.img.size == 1:
return
# 调用OpenCV写入函数
cv2.imwrite(fileName, self.img)
def videoTask(self, *args, **kwargs):
print("开始录像")
success, frame = self.video_capture.read()
while success and self.video_thread:
self.video_count += 1
print("vvvvvvvv:" + str(self.video_count))
current_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
self.video_writer.write(frame)
self.img = QImage(current_image.data, current_image.shape[1],
current_image.shape[0], QImage.Format_RGB888)
self.label.setPixmap(QPixmap.fromImage(self.img))
success, frame = self.video_capture.read()
def startVideo(self):
# 打开摄像头
self.video_capture = cv2.VideoCapture(0)
self.video_thread = True
self.size = (self.width, self.height)
self.fps = int(self.video_capture.get(cv2.CAP_PROP_FPS))
self.fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', '2')
# self.fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')
# 创建视频写入对象
self.video_writer = cv2.VideoWriter()
self.video_writer.open(self.video_file, self.fourcc, self.fps,
self.size, True)
self.video_count = 0
self.tVideo = threading.Thread(target=self.videoTask)
self.tVideo.start()
pass
# self.label.show()
# sys.sleep(100)
# if self.img.size == 1:
# return
# # 对图像做模糊处理，窗口设定为5*5
# self.img = cv2.blur(self.img, (5, 5))
# self.refreshShow()
def stopVideo(self):
threading.Thread(target=scokt_start).start()
#scokt_start()
# self.video_thread = False
# time.sleep(0.2)
# self.tVideo._stop()
# self.video_writer.release()
# self.video_capture.release()
# def save_wave_file(self, filename, data):
# wf = wave.open(filename, 'wb') # 二进制写入模式
# wf.setnchannels(self.channels)
# wf.setsampwidth(self.sampwidth) # 两个字节16位
# wf.setframerate(self.framerate) # 帧速率
# # 把数据加进去，就会存到硬盘上去wf.writeframes(b"".join(data))
# wf.writeframes(b"".join(data))
# wf.close()
def video_play(self):
cap = cv2.VideoCapture(self.video_file)
ret, frame = cap.read()
while (ret):
current_image = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
#current_image =frame
# get a frame
# show a frame
self.img = QImage(current_image.data, current_image.shape[1],
current_image.shape[0], QImage.Format_RGB888)
self.label.setPixmap(QPixmap.fromImage(self.img))
#sed_udp_data(frame)
ret, frame = cap.read()
if cv2.waitKey(100) & 0xFF == ord('q'):
break
def audioStart(self):
print("开始录音")
self.pa = PyAudio()
self.audioStream = self.pa.open(format=paInt16,
channels=self.channels,
rate=self.framerate,
input=True,
frames_per_buffer=self.CHUNK,
output=True)
self.wf = wave.open(self.audio_file, 'wb') # 二进制写入模式
self.wf.setnchannels(self.channels)
self.wf.setsampwidth(self.sampwidth) # 两个字节16位
self.wf.setframerate(self.framerate) # 帧速率
self.audio_thread = True
self.audio_count = 0
self.tAudio = threading.Thread(target=self.audioTask)
self.tAudio.start()
def audioTask(self):
while self.audioStream.is_active() and self.audio_thread:
self.audio_count += 1
print("aaaaaaaaa:" + str(self.audio_count))
# 采集数据
string_audio_data = self.audioStream.read(self.CHUNK)
# 播放数据
self.audioStream.write(string_audio_data)
# 写入文件
#my_buf.append(string_audio_data)
self.wf.writeframes(b"".join([string_audio_data]))
# sed_udp_data(string_audio_data)
#self.wf.writeframes(b"".join(my_buf))
def audioStop(self):
self.audio_thread = False
time.sleep(0.2)
self.audioStream.close()
self.wf.close()
#self.pa.terminate()
self.tAudio._stop()
print("录音完成")
def audio_play(self):
pa = PyAudio()
wf = wave.open(self.audio_file, 'rb')
stream = pa.open(format=paInt16,
channels=self.channels,
rate=self.framerate,
input=True,
output=True)
while True:
# string_audio_data = stream.read(self.NUM_SAMPLES)
# audio_data = np.fromstring(string_audio_data, dtype=np.short)
data = wf.readframes(self.NUM_SAMPLES)
if data == b'':
break
stream.write(data)
wf.close()
stream.close()
pa.terminate()
def mediaPlay(self):
self.video_capture = cv2.VideoCapture(0)
#cv2.namedWindow("src")
cuccess, frame = self.video_capture.read()
while cuccess:
cv2.imshow("src", frame)
#cv2.imshow("sec",frame)
# print(frame.shape)
# print(type(frame))
send_data(frame)
cuccess, frame = self.video_capture.read()
cv2.waitKey(1)
def mediaMuxer(self):
ff = ffmpegEx()
ff.video_add_mp3(self.video_file, self.audio_file)
def refreshShow(self):
# 提取图像的通道和尺寸，用于将OpenCV下的image转换成Qimage
# height, width, channel = self.img.shape
# bytesPerline = 3 * width
# self.qImg = QImage(self.img.data, width, height, bytesPerline, QImage.Format_RGB888).rgbSwapped()
# 将QImage显示出来
self.label.setPixmap(QPixmap.fromImage(self.img))
def Start(self):
self.startVideo()
self.audioStart()
def Stop(self):
self.stopVideo()
self.audioStop()
self.mediaMuxer()
def Play(self):
#threading.Thread(target=self.video_play).start()
#threading.Thread(target=self.audio_play).start()
#self.video_play()
#self.audio_play()
threading.Thread(target=self.mediaPlay).start()
class CollectScript(BaseScript):
RECORD_KEY = ' '
EXIT_KEY_CODE = 27
usage = Usage('''
Record audio samples for use with precise
:-w --width int 2
Sample width of audio
:-r --rate int 16000
Sample rate of audio
:-c --channels int 1
Number of audio channels
''')
usage.add_argument('file_label',
nargs='?',
help='File label (Ex. recording-##)')
def __init__(self, args):
super().__init__(args)
self.orig_settings = tcgetattr(stdin)
self.p = PyAudio()
def key_pressed(self):
return select([stdin], [], [], 0) == ([stdin], [], [])
def show_input(self):
tcsetattr(stdin, TCSADRAIN, self.orig_settings)
def hide_input(self):
tty.setcbreak(stdin.fileno())
def next_name(self, name):
name += '.wav'
pos, num_digits = None, None
try:
pos = name.index('#')
num_digits = name.count('#')
except ValueError:
print(
"Name must contain at least one # to indicate where to put the number."
)
raise
def get_name(i):
nonlocal name, pos
return name[:pos] + str(i).zfill(num_digits) + name[pos +
num_digits:]
i = 0
while True:
if not isfile(get_name(i)):
break
i += 1
return get_name(i)
def wait_to_continue(self):
while True:
c = stdin.read(1)
if c == self.RECORD_KEY:
return True
elif ord(c) == self.EXIT_KEY_CODE:
return False
def record_until_key(self):
def should_return():
return self.key_pressed() and stdin.read(1) == self.RECORD_KEY
return record_until(self.p, should_return, self.args)
def _run(self):
args = self.args
self.show_input()
args.file_label = args.file_label or input(
"File label (Ex. recording-##): ")
args.file_label = args.file_label + ('' if '#' in args.file_label else
'-##')
self.hide_input()
while True:
print('Press space to record (esc to exit)...')
if not self.wait_to_continue():
break
print('Recording...')
d = self.record_until_key()
name = self.next_name(args.file_label)
save_audio(name, d, args)
print('Saved as ' + name)
def run(self):
try:
self.hide_input()
self._run()
finally:
tcsetattr(stdin, TCSADRAIN, self.orig_settings)
self.p.terminate()
from MkIOT.imp import iot_device, messaging
from MkIOT.discovery import broadcast
from MkIOT import Get_Device_IPS
import json, time
from pyaudio import PyAudio, paInt16
DEVICE_NAME = "MK_IOT_MIC" # Change this to anything you want
DEVICE_PASSWORD = "******" # Password for this speaker
DEVICE_IP = Get_Device_IPS()['ext'][0] # Get This Devices IP
DEVICE_PORT = 7000 # The Port for audio data to be sent back and forth
DISCOVER_PORT = 7001 # The Port where Speaker will be expecting a connect request
HOTPHRASE = "mkiot_network_device" # What the speaker will respond to when a connect request is sent out
AUDIO_API = PyAudio() # Init PyAudio
# Mic config
CHUNK = 1024
FORMAT = paInt16
CHANNELS = 2
RATE = 44100
DEVICE_MIC = AUDIO_API.open( # Setup our mic
format=FORMAT,
channels=CHANNELS,
rate=RATE,
frames_per_buffer=CHUNK,
input=True)
AUDIO_CONFIG = {
from pyaudio import PyAudio, paFloat32, paContinue
import numpy as np
import time
CHANNLES = 1
RATE = 44100
pa = PyAudio()
full_data = np.array([])
def callback(in_data, frame_count, time_info, flag):
if flag:
print("Playback Error: %i" % flag)
global full_data
audio_data = np.fromstring(in_data, dtype=np.float32)
#full_data = np.append(full_data, audio_data)
return (audio_data, paContinue)
def main():
stream = pa.open(format=paFloat32,
channels=2,
rate=44100,
input=True,
output=True,
frames_per_buffer=1024,
stream_callback=callback)
stream.start_stream()
def _pyaudio() -> Generator[PyAudio, None, None]:
p = PyAudio()
try:
yield p
finally:
p.terminate()
hdr = ftc.getHeader()
except IOError:
pass
if hdr is None:
print 'Invalid Header... waiting'
sleep(1)
else:
print hdr
print hdr.labels
fSample = hdr.fSample
# set up pygame and PyAudio
pygame.init()
p = PyAudio()
# set up the window
if fullscreen:
windowSurface = pygame.display.set_mode(pygame.display.list_modes()[0],
pygame.FULLSCREEN, 32)
else:
windowSurface = pygame.display.set_mode((640, 480), 1, 32)
pygame.display.set_caption('BCI Music Experiment')
## LOADING GLOBAL VARIABLES
# Loading Music data
nrStimuli = 7
def voice_capture():
flag = False
num_samples = 2000 # pyaudio内置缓冲大小
sampling_rate = 16000 # 取样频率
level = 2000 # 声音保存的阈值
count_num_amp1 = 10
count_num_amp2 = 15
silence_length = 4
min_length = 7
dev_to_capture = PyAudio()
stream = dev_to_capture.open(format=paInt16,
channels=1,
rate=sampling_rate,
input=True,
frames_per_buffer=num_samples)
save_count = 0
save_buffer = []
length = 0
silence = 0
while True:
string_audio_data = stream.read(num_samples)
audio_data = np.fromstring(string_audio_data, dtype=np.short)
large_sample_count = np.sum(audio_data > level)
if not flag:
if large_sample_count < count_num_amp1:
save_buffer = []
length = 0
elif count_num_amp1 < large_sample_count < count_num_amp2:
save_buffer.append(string_audio_data)
length += 1
else:
save_buffer.append(string_audio_data)
length += 1
flag = True
silence = 0
else:
if large_sample_count > count_num_amp1:
save_buffer.append(string_audio_data)
length += 1
else:
silence += 1
if silence < silence_length:
save_buffer.append(string_audio_data)
length += 1
elif length < min_length:
flag = False
length = 0
save_buffer = []
silence = 0
else:
voice_string = save_buffer
wf = wave.open(captured_voice, 'wb')
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(sampling_rate)
wf.writeframes(np.array(voice_string).tostring())
wf.close()
stream.stop_stream()
stream.close()
dev_to_capture.terminate()
print("Recorded a piece of voice successfully!")
rospy.set_param(param_is_ready_to_capture, False)
rospy.set_param(param_is_ready_to_translate, True)
flag = False
length = 0
save_buffer = []
silence = 0
return True
