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()
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()
def play(frequency, length):
print("Playing impulse at %sHz" % frequency);
frequency = float(frequency);
BITRATE = 16000
FREQUENCY = frequency
LENGTH = length
NUMBEROFFRAMES = int(BITRATE * LENGTH)
RESTFRAMES = NUMBEROFFRAMES % BITRATE
WAVEDATA = ''
for x in range(NUMBEROFFRAMES):
WAVEDATA += chr(int(math.sin(x / ((BITRATE / FREQUENCY) / math.pi)) * 127 + 128))
for x in range(RESTFRAMES):
WAVEDATA += chr(128)
p = PyAudio()
stream = p.open(
format=p.get_format_from_width(1),
channels=1,
rate=BITRATE,
output=True,
)
stream.write(WAVEDATA)
stream.stop_stream()
stream.close()
p.terminate()
def Audio_play(filepath):
'''
play audio
'''
CHUNK = 1024
wf = wave.open(filepath, 'rb')
pa = PyAudio()
default_output = pa.get_default_host_api_info().get('defaultOutputDevice')
stream =pa.open(format = pa.get_format_from_width(wf.getsampwidth()),
channels = wf.getnchannels(),
rate = wf.getframerate(),
output = True,
output_device_index = default_output)
NUM = int(wf.getframerate()/CHUNK * 15)
logging.info(">> START TO PLAY AUDIO")
while NUM:
data = wf.readframes(CHUNK)
if data == " ": break
stream.write(data)
NUM -= 1
stream.stop_stream()
stream.close()
del data
pa.terminate()
class BD_API():
def __init__(self):
# super(BD_API, self).__init__(parent)
# self.initUi()
self.initariateV()
def initariateV(self):
self.pa = None
self.stream = None
def save_wave_file(self, filename, data):
'''save the date to the wavfile'''
self.wf = wave.open(filename, 'wb')
self.wf.setnchannels(channels) # 声道
self.wf.setsampwidth(sampwidth) # 采样字节 1 or 2
self.wf.setframerate(framerate) # 采样频率 8000 or 16000
self.wf.writeframes(
b"".join(data)
) # https://stackoverflow.com/questions/32071536/typeerror-sequence-item-0-expected-str-instance-bytes-found
self.wf.close()
def my_record(self):
self.pa = PyAudio()
self.stream = self.pa.open(format=paInt16,
channels=1,
rate=framerate,
input=True,
frames_per_buffer=NUM_SAMPLES)
print("开始录音。。。")
frames = []
temp1 = []
temp2 = 0
# t1=time.time()
while (True):
print('begin ')
temp2 = temp2 + 1
for i in range(0, int(framerate / NUM_SAMPLES)):
data = self.stream.read(NUM_SAMPLES)
frames.append(data)
audio_data = np.fromstring(data, dtype=np.short)
large_sample_count = np.sum(audio_data > 800)
temp = np.max(audio_data)
if temp2 >= 60:
print("超过百度调用最大时长")
break
if temp < 800:
# print("未检测到信号")
temp1.append(temp)
if len(temp1) == 2:
print('未说话超过2s')
break
print("录音结束")
self.stream.stop_stream()
self.stream.close()
self.pa.terminate()
self.save_wave_file('01.pcm', frames)
def get_file_content(self, filePath):
with open(filePath, 'rb') as fp:
return fp.read()
def LuYin(b): #录音功能
# 采样率16k
#RECORD_SECONDS = Time #采样时间
WAVE_OUTPUT_FILENAME = 'recode.wav' #输出文件名
a = 'b'
if eval(a) == 0:
a = '5'
if eval(a) != 0:
p = PyAudio()
# 可以在此写一个判断，当如某个值开始录音。最好可以该进程按下录音
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
print("*录音开始*")
frames = []
for i in range(0, int(RATE / CHUNK * (eval(a) + 1))):
data = stream.read(CHUNK)
frames.append(data)
print(data)
print("* 录音结束")
stream.stop_stream()
stream.close()
p.terminate() #关闭数据流，并关闭pyaudio
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb') #以二进制模式写入
wf.setnchannels(CHANNELS)
wf.setsampwidth(sampwidth)
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()
def _pyaudio() -> Iterator[PyAudio]:
p = PyAudio()
try:
yield p
finally:
logging.info('Terminating PyAudio object')
p.terminate()
def _pyaudio() -> Generator[PyAudio, None, None]:
p = PyAudio()
try:
yield p
finally:
print('Terminating PyAudio object')
p.terminate()
class PyAudioSense:
def __init__(self):
self.rate = MIN_RECOMMANDED_SAMPLING_RATE
chunk = int(self.rate / 2)
self.buff = queue.Queue()
self.audio_interface = PyAudio()
self.audio_stream = self.audio_interface.open(
format=paFloat32,
channels=1,
rate=self.rate,
input=True,
frames_per_buffer=chunk,
stream_callback=self._fill_buffer)
def stop(self):
self.audio_stream.stop_stream()
self.audio_stream.close()
self.buff.put(None)
self.audio_interface.terminate()
def _fill_buffer(self, in_data, frame_count, time_info, status_flags):
self.buff.put(in_data)
return None, paContinue
def generator(self):
while True:
chunk = self.buff.get()
if chunk is None:
return
yield chunk
def Microphone(File, Seconds):
CHUNK = 1024
FORMAT = paInt16
CHANNELS = 2
RATE = 44100
RECORD_SECONDS = float(Seconds)
WAVE_OUTPUT_FILENAME = File
p = PyAudio()
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
frames = []
for i in range(0, int(RATE/CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
frames.append(data)
stream.stop_stream()
stream.close()
p.terminate()
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()
def playvoice():
# chunk = 1024 # 2014kb
# wf是打开的音频文件
p = PyAudio()
# chunk = 1024, channels = 1, rate = 8000
stream = p.open(format=pyaudio.paInt16, channels=1,
rate=8000, output=True)
# 定义一个数据流对象，帧会直接通过它进行播放
# 客户端作为请求接受端
client = socket.socket()
client.connect(('localhost', 6969))
# 客户端完成连接
# 等待服务端传来的文件
while not signal_time.is_set():
# 对了如果是对的才是True
# 这里得设一个挂断信号，这个挂断信号只是自己的，还得有对面的。
data = client.recv(1024)
stream.write(data)
print(data)
if data == b'':
break
# 还得确定一个结束的信号
# 接收信号，之后进行播放
client.close()
# 结束关闭
stream.stop_stream() # 停止数据流
stream.close()
p.terminate()
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 run_predictor():
# range(1) means ensamble learning is not used to get faster inference
# model_0.h5 is the best one chosen among models
# range(5) means we have 5 models and want to apply ensamble learning into these 5 models
model = get_2d_conv_model(config)
model.load_weights(MODEL_FOLDER + '/model_0.h5')
#model.load_weights(MODEL_FOLDER + '/model_%d.h5'%i)
# realtime recording
audio = PyAudio()
stream = audio.open(
format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
#input_device_index=0,
frames_per_buffer=SAMPLES_PER_CHUNK,
start=False,
stream_callback=callback)
# print(audio.get_sample_size(FORMAT))
# sample_width = audio.get_sample_size(FORMAT)
# main loop
stream.start_stream()
while stream.is_active():
main_process(model, on_predicted)
sleep(0.001)
stream.stop_stream()
stream.close()
# finish
audio.terminate()
exit(0)
def audioTask(_running, _queue, _queue_1):
print("audioTaskStart")
pa = PyAudio()
audioStream = pa.open(format=paInt16,
channels=channels,
rate=framerate,
input=True,
frames_per_buffer=CHUNK,
output=True)
while audioStream.is_active() and _running.value:
# 采集数据
string_audio_data = audioStream.read(CHUNK)
# 播放数据
audioStream.write(string_audio_data)
try:
_queue.put(string_audio_data, False)
_queue_1.put(string_audio_data, False)
except Exception as e:
pass
audioStream.close()
pa.terminate()
return "audio finish"
def pyrec(file_name,
CHUNK=1024,
FORMAT=paInt16,
CHANNELS=2,
RATE=16000,
RECORD_SECONDS=2):
p = PyAudio()
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
print("开始录音,请说话......")
frames = []
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
frames.append(data)
print("录音结束,请闭嘴!")
stream.stop_stream()
stream.close()
p.terminate()
wf = wave.open(file_name, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()
return
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
def play_voice(audio_file):
chunk = 1024 # 2014kb
wf = wave.open(audio_file, 'rb')
p = PyAudio()
stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),
channels=wf.getnchannels(),
rate=wf.getframerate(),
output=True)
data = wf.readframes(chunk) # 读取数据
while True:
data = wf.readframes(chunk)
if signal1.is_set():
# 点击结束后这个变为true
break
if data == "":
break
stream.write(data)
stream.stop_stream() # 停止数据流
stream.close()
p.terminate() # 关闭 PyAudio
print('play函数结束！')
class AudioRecorder():
# Audio class based on pyAudio and Wave
def __init__(self, filename):
self.open = True
self.rate = 44100
self.frames_per_buffer = 1024
self.channels = 2
self.startTime = 0
self.endTime = 0
self.duration = 0
self.format = 8
self.audio_filename = filename+".wav"
self.audio = PyAudio()
self.stream = self.audio.open(format=self.format,
channels=self.channels,
rate=self.rate,
input=True,
frames_per_buffer=self.frames_per_buffer)
self.audio_frames = []
# Audio starts being recorded in separate thread
def record(self):
self.stream.start_stream()
while(self.open == True):
data = self.stream.read(self.frames_per_buffer)
self.audio_frames.append(data)
if self.open == False:
break
# Finishes the audio recording therefore the thread too
def stop(self):
if self.open == True:
self.open = False
time.sleep(0.5)
self.stream.stop_stream()
self.stream.close()
self.audio.terminate()
self.endTime = time.time()
self.duration = self.endTime - self.startTime
time.sleep(0.5)
waveFile = wave.open(self.audio_filename, 'wb')
waveFile.setnchannels(self.channels)
waveFile.setsampwidth(self.audio.get_sample_size(self.format))
waveFile.setframerate(self.rate)
waveFile.writeframes(b''.join(self.audio_frames)) # Audio write out at this point
waveFile.close()
time.sleep(0.5)
return self.duration
# Launches the audio recording function using a thread
def start(self):
self.startTime = time.time()
self.open = True
self.audio_thread = threading.Thread(target=self.record)
self.audio_thread.start()
def sine_tone(freq, duration, bitrate):
#See http://en.wikipedia.org/wiki/Bit_rate#Audio
BITRATE = bitrate #number of frames per second/frameset.
#See http://www.phy.mtu.edu/~suits/notefreqs.html
FREQUENCY = freq #Hz, waves per second, 261.63=C4-note.
LENGTH = duration #seconds to play sound
NUMBEROFFRAMES = int(BITRATE * LENGTH)
RESTFRAMES = NUMBEROFFRAMES % BITRATE
WAVEDATA = ''
# print (type(FREQUENCY))
for x in xrange(NUMBEROFFRAMES):
WAVEDATA += chr(int(math.sin(x / ((BITRATE / FREQUENCY) / math.pi)) * 127 + 128))
#fill remainder of frameset with silence
for x in xrange(RESTFRAMES):
WAVEDATA += chr(128)
p = PyAudio()
stream = p.open(
format=p.get_format_from_width(1),
channels=1,
rate=BITRATE,
output=True,
)
stream.write(WAVEDATA)
stream.stop_stream()
stream.close()
p.terminate()
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 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 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 record_voice(self):
#open the input of wave
pa = PyAudio()
stream = pa.open(format=paInt16,
channels=self._channels,
rate=self._sample_rate,
input=True,
input_device_index=2,
frames_per_buffer=self._chuck)
save_buffer = []
print('recording...')
for i in range(
0, int(self._sample_rate / self._chuck * self._sample_time)):
data = stream.read(self._chuck, exception_on_overflow=False)
save_buffer.append(data)
stream.stop_stream()
stream.close()
pa.terminate()
self.save_wave_file(self._record_speech_name, save_buffer)
save_buffer = []
print(self._record_speech_name, "saved")
print('speech record OK!')
os.system(
"ffmpeg -y -f s16le -ac 1 -ar 44100 -i recorded_speech.wav -acodec pcm_s16le -f s16le -ac 1 -ar 16000 recorded_speech.pcm -loglevel -8"
)
def _playback(self):
"""
Playback function for thread. Plays a segment until running is set to
false or end is reached
"""
# open stream
p = PyAudio()
stream = p.open(
format=p.get_format_from_width(self._segment.sample_width),
channels=self._segment.channels,
rate=self._segment.frame_rate,
output=True,
output_device_index=self._audio_device,
)
# output the file in millisecond steps
while self._pos < len(self._segment) and self._running:
stream.write(self._segment[self._pos]._data)
self._pos += 1
# close stream
time.sleep(stream.get_output_latency())
stream.stop_stream()
stream.close()
p.terminate()
def run(self):
pa = PyAudio()
self.stream = pa.open(format=paFloat32,
channels=CHANNELS,
rate=SAMPLE_RATE,
output=False,
input=True,
stream_callback=self.callback,
input_device_index=INPUT_DEVICE_INDEX,
frames_per_buffer=CHUNK)
self.stream.start_stream()
pyquit = False
while self.stream.is_active() and not pyquit:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pyquit = True
sleep(0.76) # 24 fps
self.stream.stop_stream()
self.stream.close()
pa.terminate()
pygame.quit()
class BD_API():
def __init__(self):
self.initariateV()
def initariateV(self):
self.APP_ID = '16143259'
self.API_KEY = 'Xy3G5WD6E8kEFwSy3FuCgSlm'
self.SECRET_KEY = '94QyVX3gFvNjTq3fwKGSNmPgApdBFR6u'
self.client = AipSpeech(self.APP_ID, self.API_KEY, self.SECRET_KEY)
self.pa = None
self.stream = None
def save_wave_file(self,filename,data):
'''save the date to the wavfile'''
self.wf = wave.open(filename, 'wb')
self.wf.setnchannels(channels) # 声道
self.wf.setsampwidth(sampwidth) # 采样字节 1 or 2
self.wf.setframerate(framerate) # 采样频率 8000 or 16000
self.wf.writeframes(b"".join(data)) # https://stackoverflow.com/questions/32071536/typeerror-sequence-item-0-expected-str-instance-bytes-found
self.wf.close()
def my_record(self):
self.pa = PyAudio()
self.stream = self.pa.open(format=paInt16, channels=1,
rate=framerate, input=True,
frames_per_buffer=NUM_SAMPLES)
print("开始录音")
frames = []
for i in range(0, int(framerate / NUM_SAMPLES * RECORD_SECONDS)):
data = self.stream.read(NUM_SAMPLES)
frames.append(data)
print("录音结束!")
self.stream.stop_stream()
self.stream.close()
self.pa.terminate()
self.save_wave_file('01.wav', frames)
def get_file_content(self,filePath):
with open(filePath, 'rb') as fp:
return fp.read()
def send_request(self, words):
result = self.client.synthesis(words, 'zh', 1, {'vol': 5, 'per': 4})
if not isinstance(result, dict):
with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as f:
f.write(result)
tmpfile = f.name
return tmpfile,result,f
def say(self, words):
tmpfile, result,f = self.send_request(words)
# time.sleep(0.5)
print("file name is"+ tmpfile)
subprocess.call("play -q %s" % tmpfile, shell=True)
def InitDevice():
audioDev = pyaudio.PyAudio()
stream = audioDev.open(format=pyaudio.paInt8,
channels=1,
rate=16000,
output=True)
return stream
def play(stream, Result):
stream.write(Result)
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 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 AudioServer(Thread):
"""Server class for receiving audio data from client.
Keep running as a thread until self.sock is deleted.
"""
def __init__(self, port):
super(AudioServer, self).__init__()
self.setDaemon(True)
self.address = ('', port)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.recoder = PyAudio()
self.audio_stream = None
# parameters for recording
self.chunk = config.VOICE_CHUNK
self.format = config.VOICE_FORMAT
self.channels = config.VOICE_CHANNELS
self.rate = config.VOICE_RATE
self.max_record_seconds = config.MAX_RECORD_SECONDS * 50
self.is_alive = True
def __del__(self):
self.sock.close()
if self.audio_stream is not None:
self.audio_stream.stop_stream()
self.audio_stream.close()
self.recoder.terminate()
def run(self):
self.sock.bind(self.address)
self.sock.listen(1)
client_sock, _ = self.sock.accept()
payload_size = struct.calcsize('L')
self.audio_stream = self.recoder.open(format=self.format,
channels=self.channels,
rate=self.rate,
output=True,
frames_per_buffer=self.chunk)
audio_data = ''.encode('utf-8')
while self.is_alive: # get one piece and output per iteration
packed_data = client_sock.recv(payload_size)
msg_size = struct.unpack('L', packed_data)[0]
while len(audio_data) < msg_size:
next_size = config.MAX_PACKAGE_SIZE if \
len(audio_data) + config.MAX_PACKAGE_SIZE <= msg_size else \
msg_size - len(audio_data)
next_data = client_sock.recv(next_size)
audio_data += next_data
audio_frames = loads(audio_data)
for frame in audio_frames:
self.audio_stream.write(frame, self.chunk)
audio_data = ''.encode('utf-8')
def kill(self):
"""Kill the thread."""
self.is_alive = False
class MicrophoneStream(object):
"""Opens a recording stream as a generator yielding the audio chunks."""
def __init__(self, rate, chunk):
self._rate = rate
self._chunk = chunk
# Create a thread-safe buffer of audio data
self._buff = queue.Queue()
self.closed = True
def __enter__(self):
self._audio_interface = PyAudio()
self._audio_stream = self._audio_interface.open(
format = paInt16,
channels = 1,
rate = self._rate,
input = True,
frames_per_buffer = self._chunk,
# Run the audio stream asynchronously to fill the buffer object.
# This is necessary so that the input device's buffer doesn't
# overflow while the calling thread makes network requests, etc.
stream_callback=self._fill_buffer,
)
self.closed = False
return self
def __exit__(self, type, value, traceback):
self._audio_stream.stop_stream()
self._audio_stream.close()
self.closed = True
# Signal the generator to terminate so that the client's
# streaming_recognize method will not block the process termination.
self._buff.put(None)
self._audio_interface.terminate()
def _fill_buffer(self, in_data, frame_count, time_info, status_flags):
"""Continuously collect data from the audio stream, into the buffer."""
self._buff.put(in_data)
return None, paContinue
def generator(self):
while not self.closed:
# Use a blocking get() to ensure there's at least one chunk of
# data, and stop iteration if the chunk is None
chunk = self._buff.get()
if chunk is None:
return
data = [chunk]
# Now consume whatever other data's still buffered.
while True:
try:
chunk = self._buff.get(block=False)
if chunk is None:
return
data.append(chunk)
except queue.Empty:
break
yield b''.join(data)
def play(filepath):
fp = open(filepath, 'rb')
data = fp.read()
fp.close()
aud = BytesIO(data)
sound = AudioSegment.from_file(aud, format='mp3') # LONG
global isPlaying
p = PyAudio()
stream = p.open(format=p.get_format_from_width(sound.sample_width),
channels=sound.channels,
rate=sound.frame_rate,
output=True)
print("[PLAYAUDIO INTERVAL]%f" % (time.time()))
datas = sound.raw_data
isPlaying = True
stream.write(datas) # ------------这里，接住！
'''
来来来兄弟们，来看看网上大神的代码↓（稍加修改，但是思想融会贯通）
# framewidth = sound.frame_width
# i = 0
# while True:
# data = datas[i*framewidth:(i+1)*framewidth]
# if data == b"":
# break
# i += 1
# stream.write(data)
这个人教我一帧一帧的去写，我一想好像没什么毛病。
当然后果就是CPU必须时刻保持有一定空闲，让出来给这一线程。
总之就是说CPU必须不能跑高了，稍微高一点就爆音。
然而我TM发现这东西可以一次全写进去！(如上一句话↑)
让我们看看官方的注释：
def write(self, frames, num_frames=None,
exception_on_underflow=False):
"""
Write samples to the stream. Do not call when using
*non-blocking* mode.
:param frames:#音频的数据帧
The frames of data.
:param num_frames:#帧的数量
The number of frames to write.
Defaults to None, in which this value will be
automatically computed.#你如果不输就是None，系统自动给你判断
结果网上的代码让我一帧一帧些，他每次都会判断一次帧的数量为1。
求CPU心理阴影面积。
不过感谢这位老哥指导我用了pydub这个库。
改完之后妈妈再也不用担心我音频卡顿了，哪怕我主线程写个while True：pass也不怕了！
'''
stream.stop_stream() # 停止数据流
stream.close()
p.terminate() # 关闭 PyAudio
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 play_audio(self):
audio = PyAudio()
stream = audio.open(format=audio.get_format_from_width(self.sampwidth),
channels=self.nchannels,
rate=self.rate,
output=True)
stream.write(self.response)
stream.stop_stream()
stream.close()
audio.terminate()
def play(self,filename):
#os.popen(self.locpla+filename )
wf=wave.open(self.locpla+filename,'rb')
p=PyAudio()
stream=p.open(format=p.get_format_from_width(wf.getsampwidth()),channels=wf.getnchannels(),rate=wf.getframerate(),output=True)
data = wf.readframes(self.chunk)
while data != b'':
stream.write(data)
data = wf.readframes(self.chunk)
stream.close()
p.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 play():
wf=wave.open(r"C:\Users\pengfy\PycharmProjects\smart-audio\record_files\2019-07-30-11-52-51.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()
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 play():
wf=wave.open(file,'r')
p=PyAudio()
stream=p.open(format=p.get_format_from_width(wf.getsampwidth()),channels=
wf.getnchannels(),rate=wf.getframerate(),output=True)
data=wf.readframes(8000)
while len(data)>0:
stream.write(data)
data=wf.readframes(8000)
stream.close()
p.terminate()
def play():
wf=wave.open(r"01.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()
def play(self,event):
wf=wave.open(self.name,'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(1024)
if not 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 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()
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()
def throw_process(self, q):
""" Plays a sound. """
import sounddevice
p = PyAudio()
stream = p.open(
format=self.formatting,
channels=self.channels,
rate=self.rate,
output=True
)
while True:
if not q.get():
break
stream.write(self.data)
p.terminate()
stream.close()
def run(self):
pya = PyAudio()
self._stream = pya.open(
format=paInt16,
channels=1,
rate=SAMPLE_RATE,
input=True,
frames_per_buffer=WINDOW_SIZE,
stream_callback=self._process_frame,
)
self._stream.start_stream()
while self._stream.is_active() and not raw_input():
time.sleep(0.1)
self._stream.stop_stream()
self._stream.close()
pya.terminate()
def getWavFeature(wavName): print "processing %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) while data != '': stream.write(data) data = wf.readframes(CHUNK) stream.stop_stream() stream.close() pa.terminate()
def play(wavName): 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) # td = threading.Thread(target=startGame) # td.start() data = wf.readframes(CHUNK) while data != '': stream.write(data) data = wf.readframes(CHUNK) stream.stop_stream() stream.close() pa.terminate()
def load(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[10000:10000+4608*4] self.stringAudioData = self.audioData.tostring() self.cutAudio = self.audioData # self.cut2() self.getFeature()
def record(self, time=5):
audio = PyAudio()
stream = audio.open(format=self.format, channels=self.channel,
rate=self.rate, input=True,
frames_per_buffer=self.chunk)
print "RECORDING START"
frames = []
for i in range(0, self.rate / self.chunk * time):
data = stream.read(self.chunk)
frames.append(data)
stream.stop_stream()
stream.close()
audio.terminate()
print "RECORDING STOP"
write_frames = open_audio(self.audio_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()
def Play_WAV(self, filename):
chunk = 1024
f = wave.open(filename,"rb")
pa = PyAudio()
# open stream
stream = pa.open(format = pa.get_format_from_width(f.getsampwidth()),
channels = f.getnchannels(),
rate = f.getframerate(),
output = True)
# read data
data = f.readframes(chunk)
# play stream
while data != '':
stream.write(data)
data = f.readframes(chunk)
# stop stream
stream.stop_stream()
stream.close()
# close PyAudio
pa.terminate()
def record(self, time, device_i=None):
audio = PyAudio()
print audio.get_device_info_by_index(1)
stream = audio.open(input_device_index=device_i,output_device_index=device_i,format=self.format, channels=self.channel,
rate=self.rate, input=True,
frames_per_buffer=self.chunk)
playDing()
print "REC: "
frames = []
for i in range(0, self.rate / self.chunk * time):
data = stream.read(self.chunk)
frames.append(data)
stream.stop_stream()
print "END"
stream.close()
playDing()
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()
m=c elif tk=="sc": m=0.6 for n in X(1,9): h=2*n-1 sS+=m*math.sin((tp*(float(x)/R)*F)*h)/h A(sS) if ss>du: for x in X(int(du),int(ss)): A(0.0) nP+=1 pP+=1 tP+=1 lD=0 for x in z: lD=len(x) if len(x)>lD else lD for x in X(lD): sum=0.0 for y in X(len(z)): try: sum+=z[y][x] except IndexError: pass sample=min(int(((max(min(sum/len(z),1.0),-1.0)) + 1.0)*128.0),255) sgRaw+=chr(sample) for D in X(1): st.write(sgRaw) st.stop_stream() st.close() p.terminate()
# play
def InputFromMIC():
while True:
string_audio_data = streamin.read(FRAME_SIZE)
encdata = e.encode(string_audio_data)
q.put(encdata)
t1 = Thread(target=InputFromMIC)
t1.start()
def OutputToSpeaker():
while True:
if q.empty() == False:
decdata = d.decode(q.get())
streamout.write(decdata)
t2 = Thread(target=OutputToSpeaker)
t2.start()
# control
while True:
quality=input('Please enter a quality [0-10]:')
e.control(SPEEX_SET_QUALITY, int(quality))
streamin.close()
streamout.close()
pa.terminate()
p.terminate()
