Der PyAudio-Eingang ist übergelaufen

pyaudio.Stream.read() hat eine keyword-parameter exception_on_overflowsetzen Sie diese auf False.

Ihres Beispiel-code würde wie folgt Aussehen:

import pyaudio
import wave
import sys

chunk = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "output.wav"

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                frames_per_buffer = chunk)

print "* recording"
all = []
for i in range(0, RATE / chunk * RECORD_SECONDS):
    data = stream.read(chunk, exception_on_overflow = False)
    all.append(data)
print "* done recording"

stream.close()
p.terminate()

Sehen die PyAudio Dokumentation für mehr details.

InformationsquelleAutor der Antwort Jesquik

Es scheint wie eine Menge Menschen sind der Begegnung mit diesem Thema. Ich grub ein bisschen in ihn und ich denke, es bedeutet, dass zwischen dem vorherigen Aufruf stream.read() und das aktuelle Gespräch, werden die Daten aus dem stream verloren (d.h. der Puffer füllte sich schneller, als Sie es geklärt).

Vom doc für Pa_ReadStream() (die PortAudio-Funktion, die stream.read() schließlich endet Aufruf):

@return On success PaNoError will be returned, or PaInputOverflowed if
input data was discarded by PortAudio after the previous call and
before this call.

(PaInputOverflowed dann zu einem IOError im pyaudio-wrapper).

Wenn es OK ist für Sie nicht erfassen jedes einzelne Bild, dann können Sie diese Fehlermeldung ignorieren. Wenn es absolut wichtig, dass Sie jeden frame, dann müssen Sie einen Weg finden, um die Priorität zu erhöhen Ihrer Anwendung. Ich bin nicht vertraut genug mit Python zu kennen pythonic Weg, dies zu tun, aber es ist einen Versuch Wert, einen einfachen nice Befehl, oder die änderung der scheduling-Strategie zu SCHED_DEADLINE.

Edit:

Einzige Problem jetzt ist, dass wenn IOError geworfen wird, verlieren Sie alle Bilder gesammelt in, call. Stattdessen ignorieren Sie die überlauf-und nur zurückkehren, was wir haben, können Sie den patch anwenden unten, das wird verursachen stream.read() zu ignorieren, Ausgabe Unterfahrschutz und input-overflow-Fehler von PortAudio (aber immer noch werfen etwas, wenn ein anderer Fehler aufgetreten ist). Ein besserer Weg wäre, um dieses Verhalten (werfen/nicht werfen) anpassbar je nach Ihren Bedürfnissen.

diff --git a/src/_portaudiomodule.c b/src/_portaudiomodule.c
index a8f053d..0878e74 100644
--- a/src/_portaudiomodule.c
+++ b/src/_portaudiomodule.c
@@ -2484,15 +2484,15 @@ pa_read_stream(PyObject *self, PyObject *args)
     } else {
       /* clean up */
       _cleanup_Stream_object(streamObject);
+
+      /* free the string buffer */
+      Py_XDECREF(rv);
+
+      PyErr_SetObject(PyExc_IOError,
+                       Py_BuildValue("(s,i)",
+                                     Pa_GetErrorText(err), err));
+      return NULL;
     }
-
-    /* free the string buffer */
-    Py_XDECREF(rv);
-
-    PyErr_SetObject(PyExc_IOError,
-                   Py_BuildValue("(s,i)",
-                                 Pa_GetErrorText(err), err));
-    return NULL;
   }

   return rv;

InformationsquelleAutor der Antwort Meta

Arbeitete ich das auf OS X 10.10, Habe den gleichen Fehler, während Sie versuchen, um audio vom Mikrofon in ein SYBA USB-Karte (C-Media-Chipsatz), und verarbeiten Sie in Echtzeit mit fft ' s und mehr:

IOError: [Errno Input overflowed] -9981

Dem überlauf wurde vollständig gelöst, wenn mit Hilfe einer Callback-Modus, anstelle des Blockierenden Modus, wie geschrieben von libbkmz.(https://www.python.org/dev/peps/pep-0263/)

Basiert auf, der etwas von den funktionierenden code sah so aus:

"""
Creating the audio stream from our mic
"""
rate=48000
self.chunk=2**12
width = 2

p = pyaudio.PyAudio()

# callback function to stream audio, another thread.
def callback(in_data,frame_count, time_info, status):
    self.audio = numpy.fromstring(in_data,dtype=numpy.int16)
    return (self.audio, pyaudio.paContinue)

#create a pyaudio object
self.inStream = p.open(format = p.get_format_from_width(width, unsigned=False),
                       channels=1,
                       rate=rate,
                       input=True,
                       frames_per_buffer=self.chunk,
                       stream_callback = callback)

"""
Setting up the array that will handle the timeseries of audio data from our input
"""
self.audio = numpy.empty((self.buffersize),dtype="int16")

    self.inStream.start_stream()

while True:
  try:
    self.ANY_FUNCTION() #any function to run parallel to the audio thread, running forever, until ctrl+C is pressed. 

  except KeyboardInterrupt:

    self.inStream.stop_stream()
    self.inStream.close()
    p.terminate()
    print("* Killed Process")
    quit()

Diesem code erstellen Sie eine callback-Funktion, erstellen Sie dann ein stream-Objekt, starten Sie es und dann in einer Schleife in jeder Funktion. Einen separaten thread zum Streaming von audio und stream ist geschlossen, wenn die main-Schleife wird gestoppt. selbst.audio ist in jeder Funktion. Ich hatte auch Probleme mit dem Faden, der immer, wenn nicht gekündigt wird.

Seit Pyaudio läuft dieser stream in einem separaten thread, und das machte den audio-stream stabil, die Blocking-Modus hätte die Sättigung in Abhängigkeit von der Geschwindigkeit oder das timing der rest der Prozesse, die in das Skript.

Beachten Sie, dass die chunk-Größe ist 2^12, aber kleinere Stücke, die genauso gut funktionieren. Es gibt andere Parameter, die ich angesehen und rumgespielt, um sicherzustellen, dass Sie alles machte Sinn:

• Chunk-Größe größer oder kleiner(kein Effekt)
• Anzahl und format der bits, die für die Worte in den Puffer, signed 16-bit in diesem Fall.
• Fehler von Variablen(versucht mit unsigned und bekam Sättigung Muster)
• Natur-mic-Eingang, und die Auswahl wird als Standardeinstellung im system, gain etc.

Hoffe, das funktioniert für jemanden!

InformationsquelleAutor der Antwort Roberto Becerra

Ich hatte das gleiche Problem auf dem wirklich langsamen raspberry pi, aber ich war in der Lage, es zu lösen (für die meisten Fälle) durch die Verwendung der schneller array Modul für die Speicherung der Daten.

import array
import pyaudio 

FORMAT = pyaudio.paInt16
CHANNELS = 1
INPUT_CHANNEL=2
RATE = 48000
CHUNK = 512

p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=INPUT_CHANNEL,
                frames_per_buffer =CHUNK)

print("* recording")


try:
    data = array.array('h')
    for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
        data.fromstring(stream.read(CHUNK))
finally:
    stream.stop_stream()
    stream.close()
    p.terminate()

print("* done recording")

Den Inhalt data ist eher binäre danach.
Aber Sie können numpy.array(data, dtype='i') um ein numpy-array von intergers.

InformationsquelleAutor der Antwort Harald Thomson