Akustisches Signalverarbeitungsmodul, das mit Python-Sounddevice ASIO [Anwendung] verwendet werden kann

Einführung

Dieser Artikel ist eine Fortsetzung von Verarbeitungsmodul für Audiogeräte, das mit dem Python-Sound-Gerät ASIO [Basic] verwendet werden kann. Hier finden Sie die anfängliche Einstellungsmethode für die Verwendung von Soundgeräten aus der Vorbereitung vor der Verwendung sowie die grundlegende Wiedergabemethode, Aufnahmemethode, simultane Aufnahme- / Wiedergabemethode und Streaming-Methode für Soundgeräte.

In diesem Artikel behandelte Elemente

In diesem Artikel möchte ich über die Kanalzuordnungsmethode mit Soundgeräten schreiben (Eingabe von Ihrem Lieblingsmikrofon und Ausgabe von Ihrem Lieblingslautsprecher in einer Mehrkanalumgebung).

Siehe hier für Details Offizieller Python-Soundgerät

Nachtrag

Mit dem Update scheint die Bedienung einfacher geworden zu sein. In den folgenden Artikeln werden ältere Versionen beschrieben. Überprüfen Sie daher die offizielle Dokumentation.

Grundlegende Methode der Kanalzuordnung

Angenommen, Sie haben ein solches Lautsprecherarray Wenn Sie die Tonquelle von 5 Kanälen in der Reihenfolge über die Lautsprecher von 5 Kanälen ausgeben möchten, ist dies kein Problem, da die Seite des Audiogeräts die Kanäle automatisch zuweist.

Wenn Sie die Tonquelle eines Kanals von einem Lautsprecher (diesmal 3. Lautsprecher) eines Kanals ausgeben möchten, gehen Sie wie folgt vor.

MonoChannelPlayback.py

out = [-1,-1,0,-1,-1]
sd.play(..., mapping = out ,...)

Wenn Sie die Tonquelle von 3 Kanälen über einen beliebigen Lautsprecher (diesmal 2., 3., 5. Lautsprecher) mit 3 Kanälen ausgeben möchten, gehen Sie wie folgt vor.

MultiChannelsPlayback.py

out = [-1,0,1,-1,2]
sd.play(..., mapping = out ,...)

Mit anderen Worten, wenn Sie eine Liste mit [-1] für die Lautsprecher erstellen, die Sie nicht ausgeben möchten, und [0] [1] [2] .. für die Lautsprecher, die Sie ausgeben möchten, und diese in die Zuordnung einfügen, werden sie zugewiesen. Ebenfalls,

MultiChannelsPlayback.py

out = [-1,1,0,-1,2]
sd.play(..., mapping = out ,...)

Sie können die Reihenfolge der Lautsprecher ändern, die Ton erzeugen.

Einstellungen für jede API

In diesem Abschnitt wird die Einstellungsmethode bei der Steuerung der Ein- / Ausgabe über eindeutige APIs wie ASIO, Core Audio und WAS API beschrieben. So überprüfen Sie die API, die derzeit von Ihrem Computer unterstützt wird [Anfangseinstellungen der verwendeten Geräte](https://qiita.com/MikuMaekawa/items/aaac6df5d6cee2f8cf71#%E4%BD%BF%E7%94%A8% E6% A9% 9F% E6% 9D% 90% E3% 81% AE% E8% A8% AD% E5% AE% 9A) oder versuchen Sie den folgenden Befehl.

checkAPI.py

sd.query_hostapis(index=None)

Rückgabewert

({'name': 'Core Audio',
  'devices': [0, 1, 2],
  'default_input_device': 0,
  'default_output_device': 1},)

ASIO Klicken Sie hier, um die Einstellungen für die Kanalzuordnung in ASIO anzuzeigen. Dies wird unter der Annahme gesteuert, dass in einer Umgebung der Lautsprecherausgang 5 Kanäle und der Mikrofoneingang 2 Kanäle beträgt.

ASIOMultiChannnelsControl.py

out = [0,1,2,3,4]
in = [0,1]

asio_out = sd.AsioSettings(channel_map = out)
asio_in = sd.AsioSettings(channel_map = in)

#Wiedergabe
sd.play(..., extra_settings=asio_out)

#Aufzeichnung
recdata = sd.rec(..., channels=2, extra_settings=asio_in,...)

#Gleichzeitige Aufnahme und Wiedergabe
recdata = sd.playrec(...,channels=2, extra_settings=(asio_in,asio_out),... )

Sie können extra_setting auch als Standard festlegen, wenn Sie wissen, dass Sie immer dieselben Einstellungen verwenden.

default_map.py

out = [0,1,2,3,4]
in = [0,1]

asio_out = sd.AsioSettings(channel_map = out)
asio_in = sd.AsioSettings(channel_map = in)

sd.default.extra_settings = (asio_in,asio_out)

Core Audio Die Methode ist fast die gleiche wie bei ASIO

CoreAudioMultiChannnelsControl.py

out = [0,1,2,3,4]
in = [0,1]

ca_out = sd.CoreAudioSettings(channel_map = out)
ca_in = sd.CoreAudioSettings(channel_map = in)

#Wiedergabe
sd.play(..., extra_settings=ca_out)

#Aufzeichnung
recdata = sd.rec(..., channels=2, extra_settings=ca_in,...)

#Gleichzeitige Aufnahme und Wiedergabe
recdata = sd.playrec(...,channels=2, extra_settings=(ca_in,ca_out),... )

WASAPI Gleiches gilt für WASAPI

WasapiMultiChannnelsControl.py

out = [0,1,2,3,4]
in = [0,1]

wasapi_out = sd.WasapiSettings(channel_map = out)
wasapi_in = sd.WasapiSettings(channel_map = in)

#Wiedergabe
sd.play(..., extra_settings=wasapi_out)

#Aufzeichnung
recdata = sd.rec(..., channels=2, extra_settings=wasapi_in,...)

#Gleichzeitige Aufnahme und Wiedergabe
recdata = sd.playrec(...,channels=2, extra_settings=(wasapi_in,wasapi_out),... )

Schließlich

Damit ist die Erklärung des Audiogeräts abgeschlossen. Hoffentlich wird die Anzahl der Benutzer von Soundgeräten weltweit zunehmen, und ich hoffe, dass die Welt mit verschiedenen äußerst praktischen und stärksten Programmen überflutet wird, die Soundgeräte verwenden.

Abschließend werde ich mich von dem Programm verabschieden, das automatisch die Impulsantwort des Mehrkanal-Lautsprecher-Arrays findet, das ich für den Dummy-Kopf verwendet habe, ohne die DAW-Software zu durchlaufen. Danke für deine harte Arbeit.

Beispielprogramm zur Messung der Impulsantwort

Ich werde einen Kommentarartikel schreiben, wenn ich Lust dazu habe, aber vielleicht brauchen Leute, die ihn benutzen, keinen Kommentar ...

InpulseResponse.py

import numpy as np
import scipy as sp
import sounddevice as sd
import wave
import struct

#Setting
Fs=44100
small=1000000 #Stellen Sie die Lautstärke auf 1 / klein ein, da der Ton der vorbereiteten WAV-Datei zu laut war

#sounddevise Setting
sd.default.samplerate=Fs
print(sd.query_devices())
#Eine Liste der angeschlossenen Geräte wird angezeigt. Geben Sie daher die Geräte-ID ein.
deviceNo = input("Please enter the ID of the device to use  :" )
sd.default.device = int(deviceNo)

area = 1

#mapping
out1 = sd.CoreAudioSettings(channel_map=[0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])
out2 = sd.CoreAudioSettings(channel_map=[-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])
out3 = sd.CoreAudioSettings(channel_map=[-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1])
out4 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1])
out5 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,0,-1,-1,-1,-1,-1,-1,-1])
out6 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,0,-1,-1,-1,-1,-1,-1])
out7 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,0,-1,-1,-1,-1,-1])
out8 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,-1])
out9 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1])
out10 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1])
out11 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1])
out12 = sd.CoreAudioSettings(channel_map=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0])

ca_in = sd.CoreAudioSettings(channel_map=[0,1])

def wavread(filename):#Reading 16bit WAVE files
    wf = wave.open(filename,'rb')
    buf = wf.readframes(wf.getnframes())
    data = np.frombuffer(buf, dtype = "int16")
    return data

TSP=wavread("tsp.wav")/small 
#Setzen Sie weißes Rauschen oder TSP-Signal (Swept Sine Signal) ein

#Berechnen Sie die Faltungsimpulsantwort
def IR(rTSPdata,outputfilename):
    rTSPdata=rTSPdata.T
    ipls=np.real(sp.ifft(sp.fft(rTSPdata)*sp.fft(np.flipud(TSP),rTSPdata.size)))
    c=np.fft.fftshift(ipls/max(ipls))
    int16amp=32768 / int(c.max())
    y2 = np.array([c * int16amp],dtype = "int16")[0]
    y4 = struct.pack("h" * len(y2), *y2)
    w = wave.Wave_write(outputfilename)
    w.setparams((
            1,                        # channel
            2,                        # byte width
            44100,                    # sampling rate
            len(y4),                 # number of frames
            "NONE", "NONE"  # no compression
        ))
    w.writeframesraw(y4)
    w.close()

#Playrec
def PlayRec(outmap,IDnumber):
    #sd.play(TSP,Fs,extra_settings=outmap,blocking=True)
    TSP1=sd.playrec(TSP,Fs,channels=2,extra_settings=(ca_in,outmap),blocking=True)
    TSP2=sd.playrec(TSP,Fs,channels=2,extra_settings=(ca_in,outmap),blocking=True)
    TSP3=sd.playrec(TSP,Fs,channels=2,extra_settings=(ca_in,outmap),blocking=True)

    #Wir führen eine additive Polymerisation durch, haben jedoch kürzlich ein langes weißes Rauschen oder ein Swept-Sine-Signal (TSP-Signal) vorbereitet.
    #Es scheint, dass der Mainstream darin besteht, es auf einmal ohne additive Polymerisation zu finden.
    
    rTSP = TSP1 + TSP2 + TSP3

    #Invertieren Sie die aufgezeichnete Antwort, um die IR zu finden
    rTSP1 = rTSP[:,0]
    rTSP2 = rTSP[:,1]
    rTSP3 = rTSP[:,2]
    rTSP4 = rTSP[:,3]
    rTSP5 = rTSP[:,4]
    rTSP6 = rTSP[:,5]
    rTSP7 = rTSP[:,6]
    rTSP8 = rTSP[:,7]
    rTSP9 = rTSP[:,8]
    rTSP10 = rTSP[:,9]
    
    #Benennen Sie die resultierende Impulsantwort und schreiben Sie sie als WAV-Datei in einen Ordner
    IR(rTSP1,"IR"+str(IDnumber)+"1.wav")
    IR(rTSP2,"IR"+str(IDnumber)+"2.wav")
    IR(rTSP3,"IR"+str(IDnumber)+"3.wav")
    IR(rTSP4,"IR"+str(IDnumber)+"4.wav")
    IR(rTSP5,"IR"+str(IDnumber)+"5.wav")
    IR(rTSP6,"IR"+str(IDnumber)+"6.wav")
    IR(rTSP7,"IR"+str(IDnumber)+"7.wav")
    IR(rTSP8,"IR"+str(IDnumber)+"8.wav")
    IR(rTSP9,"IR"+str(IDnumber)+"9.wav")
    IR(rTSP10,"IR"+str(IDnumber)+"10.wav")

print("Starten Sie den Test")
PlayRec(out1,1)
PlayRec(out2,2)
PlayRec(out3,3)
PlayRec(out4,4)
PlayRec(out5,5)
PlayRec(out6,6)
PlayRec(out7,7)
PlayRec(out8,8)
PlayRec(out9,9)
PlayRec(out10,10)
PlayRec(out11,11)
PlayRec(out12,12)
print("Ende der Messung")

Referenz

Offizieller Python-Soundgerät Soundgeräte-Verarbeitungsmodul, das mit dem Python-Sound-Gerät ASIO [Basic] verwendet werden kann