Im Anschluss an die Antwort von Nick Fortescue finden Sie hier ein vollständigeres Beispiel für die Aufnahme vom Mikrofon und die Verarbeitung der resultierenden Daten:
from sys import byteorder
from array import array
from struct import pack
import pyaudio
import wave
THRESHOLD = 500
CHUNK_SIZE = 1024
FORMAT = pyaudio.paInt16
RATE = 44100
def is_silent(snd_data):
"Returns 'True' if below the 'silent' threshold"
return max(snd_data) < THRESHOLD
def normalize(snd_data):
"Average the volume out"
MAXIMUM = 16384
times = float(MAXIMUM)/max(abs(i) for i in snd_data)
r = array('h')
for i in snd_data:
r.append(int(i*times))
return r
def trim(snd_data):
"Trim the blank spots at the start and end"
def _trim(snd_data):
snd_started = False
r = array('h')
for i in snd_data:
if not snd_started and abs(i)>THRESHOLD:
snd_started = True
r.append(i)
elif snd_started:
r.append(i)
return r
# Trim to the left
snd_data = _trim(snd_data)
# Trim to the right
snd_data.reverse()
snd_data = _trim(snd_data)
snd_data.reverse()
return snd_data
def add_silence(snd_data, seconds):
"Add silence to the start and end of 'snd_data' of length 'seconds' (float)"
silence = [0] * int(seconds * RATE)
r = array('h', silence)
r.extend(snd_data)
r.extend(silence)
return r
def record():
"""
Record a word or words from the microphone and
return the data as an array of signed shorts.
Normalizes the audio, trims silence from the
start and end, and pads with 0.5 seconds of
blank sound to make sure VLC et al can play
it without getting chopped off.
"""
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT, channels=1, rate=RATE,
input=True, output=True,
frames_per_buffer=CHUNK_SIZE)
num_silent = 0
snd_started = False
r = array('h')
while 1:
# little endian, signed short
snd_data = array('h', stream.read(CHUNK_SIZE))
if byteorder == 'big':
snd_data.byteswap()
r.extend(snd_data)
silent = is_silent(snd_data)
if silent and snd_started:
num_silent += 1
elif not silent and not snd_started:
snd_started = True
if snd_started and num_silent > 30:
break
sample_width = p.get_sample_size(FORMAT)
stream.stop_stream()
stream.close()
p.terminate()
r = normalize(r)
r = trim(r)
r = add_silence(r, 0.5)
return sample_width, r
def record_to_file(path):
"Records from the microphone and outputs the resulting data to 'path'"
sample_width, data = record()
data = pack('<' + ('h'*len(data)), *data)
wf = wave.open(path, 'wb')
wf.setnchannels(1)
wf.setsampwidth(sample_width)
wf.setframerate(RATE)
wf.writeframes(data)
wf.close()
if __name__ == '__main__':
print("please speak a word into the microphone")
record_to_file('demo.wav')
print("done - result written to demo.wav")
xrange
nochrange
war wirklich notwendig inadd_silence
(so ist es jetzt weg). Ich denke, Arek könnte hier auf etwas stehen - der Übergang von der Stille zum 'Wort' klingt zu ruckelig. Ich denke, es gibt andere Antworten, die sich auch damit befassen.Ich glaube, das WAVE-Modul unterstützt keine Aufzeichnung, sondern nur die Verarbeitung vorhandener Dateien. Vielleicht möchten Sie sich PyAudio ansehen, um tatsächlich aufzunehmen. Bei WAV geht es um das einfachste Dateiformat der Welt. In paInt16 erhalten Sie nur eine vorzeichenbehaftete Ganzzahl, die eine Ebene darstellt, und näher an 0 ist leiser. Ich kann mich nicht erinnern, ob WAV-Dateien zuerst High-Byte oder Low-Byte sind, aber so etwas sollte funktionieren (sorry, ich bin nicht wirklich ein Python-Programmierer:
PyAudio-Code für die Aufzeichnung wird als Referenz aufbewahrt:
quelle
Vielen Dank an cryo für die verbesserte Version, auf der ich meinen getesteten Code basiert habe:
quelle
return copy.deepcopy(data_all[_from:(_to + 1)])
biscopy.deepcopy(data_all[int(_from):(int(_to) + 1)])
Ich denke, dies wird helfen. Es ist ein einfaches Skript, das prüft, ob es eine Stille gibt oder nicht. Wenn Stille erkannt wird, wird es nicht aufgezeichnet, sonst wird es aufgezeichnet.
quelle
Die pyaudio-Website enthält viele Beispiele, die ziemlich kurz und klar sind: http://people.csail.mit.edu/hubert/pyaudio/
Update 14. Dezember 2019 - Hauptbeispiel von der oben verlinkten Website ab 2017:
quelle
Vielleicht möchten Sie sich auch csounds ansehen . Es hat mehrere APIs, einschließlich Python. Möglicherweise kann es mit einer AD-Schnittstelle interagieren und Klangbeispiele sammeln.
quelle