PyAudio Ansprechende Aufnahme

Ich habe gesehen, das Aufnahme-tutorial auf der PyAudio website für die Aufnahme einer festen Länge der Aufnahme, aber ich Frage mich, wie ich das gleiche tun könnte mit einem nicht-festen Aufnahme? Bascially, ich will buttons erstellen, um zu starten und beenden Sie die Aufnahme, aber ich habe nicht gefunden was auf die Materie. Irgendwelche Ideen, und ich bin nicht auf der Suche für eine alternative Bibliothek?

InformationsquelleAutor Malik Brahimi | 2015-02-09

6

Besten ist die Verwendung der nicht-blockierende Art und Weise der Aufzeichnung, d.h. Sie bieten eine callback-Funktion aufgerufen wird, von dem moment starten Sie den stream und wird immer wieder genannt wird für jeden block/- buffer, der wird solange bearbeitet, bis Sie stoppen den stream.

In dieser callback-Funktion, die Sie überprüfen, ob ein boolean zum Beispiel, und wenn es wahr ist, schreiben Sie die eingehenden Puffer zu einem datastructure, wenn es falsch ist, Sie ignorieren die eingehenden Puffers. Diese Boolesche kann eingestellt werden durch klicken eine Taste, zum Beispiel.

EDIT: schau dir das Beispiel von Draht-audio: http://people.csail.mit.edu/hubert/pyaudio/#wire-callback-example
Der stream wird geöffnet, mit dem argument,
```
stream_callback=my_callback
```
Wo my_callback ist eine normale Funktion deklariert als
```
def my_callback(in_data, frame_count, time_info, status)
```
Diese Funktion wird jedesmal aufgerufen, wenn ein neuer Puffer verfügbar ist. in_data enthält die Eingabe, die Sie aufnehmen wollen. In diesem Beispiel in_data wird nur zurückgegeben, in einem Tupel zusammen mit pyaudio.paContinue. Was bedeutet, dass der eingehende Puffer aus dem Eingabe-Gerät setzen/kopieren zurück in den Ausgabepuffer geschickt, die den Ausgang Gerät (es ist das gleiche Gerät, so dass Sie die eigentlich routing-Eingabe, Ausgabe aka-Draht). Finden Sie in der api-Dokumentation für ein bisschen mehr Erklärung: http://people.csail.mit.edu/hubert/pyaudio/docs/#pyaudio.PyAudio.open

So, in dieser Funktion können Sie etwas tun möchten (dies ist ein Auszug aus dem code, den ich geschrieben habe, ist nicht komplett: ich verwende einige Funktionen nicht dargestellt. Auch Spiele ich einen Sinus auf einem Kanal und Rauschen auf der anderen Seite in 24-bit-format.):
```
record_on = False
playback_on = False

recorded_frames = queue.Queue()

def callback_play_sine(in_data, frame_count, time_info, status):
    if record_on:
        global recorded_frames
        recorded_frames.put(in_data)

    if playback_on:
        left_channel_data = mysine.next_block(frame_count) * MAX_INT24 * gain
        right_channel_data = ((np.random.rand(frame_count) * 2) - 1) * MAX_INT24 * gain
        data = interleave_channels(max_nr_of_channels, (left_output_channel, left_channel_data), (right_output_channel, right_channel_data))
        data = convert_int32_to_24bit_bytestream(data)
    else:
        data = np.zeros(frame_count*max_nr_of_channels).tostring()

    if stop_callback:
        callback_flag = pyaudio.paComplete
    else:
        callback_flag = pyaudio.paContinue

    return data, callback_flag
```
Können Sie dann festlegen record_on und playback_on zu True oder False aus einem anderen Teil Ihres Codes während der stream öffnen/ausführen, wodurch die Aufnahme und die Wiedergabe zu starten oder zu stoppen, unabhängig voneinander, ohne Sie zu unterbrechen stream.
Ich kopiere die in_data in einem (threadsicher) queue, die von einem anderen thread verwendet, um zu schreiben auf die Festplatte gibt, sonst wird die Warteschlange get big nach einer Weile.

BTW: pyaudio basiert auf portaudio, die viel mehr Dokumentation und hilfreiche Tipps. Zum Beispiel (http://portaudio.com/docs/v19-doxydocs/writing_a_callback.html): die callback-Funktion zu beenden, bevor ein neuer Puffer vorgestellt, andere Puffer verloren. So schreiben in eine Datei innerhalb der callback-Funktion in der Regel nicht eine gute Idee. (obwohl das schreiben in eine Datei wird gepuffert und ich weiß nicht, ob es blockiert wird, wenn Ihre Festplatte geschrieben, irgendwann)
- Ich bin dir nicht folgt. Können Sie erklären, diese Methode weiter?
- Ich bin nicht vertraut mit C oder C++. Können Sie eigentlich erklären einige Python?
- Kann das vielleicht einfacher sein?
- Soweit ich weiß, nicht wirklich. Könnte man die nicht-Rückruf (Blockade) version, aber Sie haben, um es in einem separaten thread, wenn Sie nicht möchten, dass Sie den rest des Codes zu frieren, das ist wohl komplizierter. Auch der callback-version ist die standard-Weg, um die Interaktion mit einem realtime-IO-device. Die IO-Gerät verursacht einen interrupt in das Betriebssystem/Treiber, die Trigger eine Funktion, die aufgerufen (callback), die Sperrung ist nur eine Bequemlichkeit gebaut, auf der Spitze dieses für die einfachsten Fälle.
- Ich fand einen besseren Weg, mit Pygame, fügen Sie einfach die Programm-updates über den normalen Aufnahme-Programm.
- Das ist, was ich verwenden, um zu simulieren-Taste drückt. Siehe unten.
- warum ist data zurückgegeben wird?
- ist eine Funktion, die zugewiesen wird, um die "audio-thread'. Dieser thread führt die Funktion, wenn die Wiedergabe gestartet wird, und es braucht mehr Daten, um zu spielen zurück. Wenn der audio-thread führt die Funktion, übergibt er einige Argumente an die Funktion (in_data und so), während der Aufruf der Funktion, berechnen wir, was abgespielt werden soll, setzen, dass in der Daten-und, wenn die Funktion zurückgibt, die data Puffer aufgenommen mit der audio-thread und (schließlich) weitergegeben, die die eigentliche audio-interface.
- es ist wahr, wenn wir die Wiedergabe von audio-Datei. Aber sind wir nicht aufnehmen? Ich nehme an, wir werden Sie nicht verwenden, Lautsprecher, während wir aufnehmen. Ansonsten gibt es einen loopback
- Das hängt von Ihrer Einrichtung und/oder über die Anwendung. Sie könnte die Aufnahme von einer externen Quelle (z.B. ein Synthesizer, sampler..), vielleicht machen die Echtzeit-Verarbeitung (selbst wenn es nur das mischen mehrerer Kanäle oder so), und spielen es wieder zurück. Oder in meinem Fall, ich war gerade wieder testen Signale, die ging über einen externen Prozessor, die wurden dann wieder aufgenommen. So, wie ich verwendet python zum erstellen von automatisierten tests für die hardware-integration von einigen dsp-algorithmen.
InformationsquelleAutor Emile Vrijdags

import pyaudio
import wave

import pygame, sys
from pygame.locals import *

pygame.init()
scr = pygame.display.set_mode((640, 480))
recording = True

CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 2
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")

frames = []

while True:
    if recording:
        data = stream.read(CHUNK)
        frames.append(data)

    for event in pygame.event.get():
        if event.type == KEYDOWN and recording:
            print("* done recording")

            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()
            recording = False

        if event.type == QUIT:
            pygame.quit(); sys.exit()

InformationsquelleAutor Malik Brahimi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.