Tinnitus_Musik_Therapie_Projektarbeit_Repo/TinnitusAnalyse/SoundGenerator.py

import wave  # bearbeiten von .wav-Dateien
import struct
import sounddevice as sd
import numpy as np
import sys  # für Fehlermeldungen
from scipy import signal
import csv
#import matplotlib.pyplot as plt
"""---------------------------------------------------------------------------------------------------------------------
In .wav-Dateien wird der Ton in absoluten Werte eingetragen. Die Standart-framerate ist 44100
das heißt für jede Sekunde an Ton gibt es 44100 Werte, die die Tonwelle über die Zeit beschreiben
---------------------------------------------------------------------------------------------------------------------"""


class Tinnitus:  # beinhaltet alle Werte, die vom Nutzer eingestellt werden
    def __init__(self, l_freq=0, r_freq=0, l_amp=0, r_amp=0, l_rausch=0, r_rausch=0, ohr=0, l_rausch_ug=10, r_rausch_ug=10, l_rausch_og=20000, r_rausch_og=20000):
        self.vorname = ""
        self.nachname = ""
        self.kommentar = ""
        # [Alle Frequenzangaben in Hz, alle Amplitudenangaben von 0-1 (float)]
        self.linksFrequenz = l_freq
        self.rechtsFrequenz = r_freq
        self.linksLautstaerke = l_amp
        self.rechtsLautstaerke = r_amp
        self.linksRauschenLautstaerke = l_rausch
        self.rechtsRauschenLautstaerke = r_rausch
        self.linksRauschenUntereGrenzfrequenz = l_rausch_ug
        self.rechtsRauschenUntereGrenzfrequenz = r_rausch_ug
        self.linksRauschenObereGrenzfrequenz = l_rausch_og
        self.rechtsRauschenObereGrenzfrequenz = r_rausch_og

    def speichern(self):  # speichert die Nutzerdaten in eine .csv-Datei
        datei = open("TinnitusDaten.csv", "w")

        daten = "Vorname;" + self.vorname + "\n"
        daten += "Nachname;" + self.nachname + "\n"
        daten += "linke Frequenz;" + str(self.linksFrequenz) + "\n"
        daten += "linke Lautstärke;" + str(self.linksLautstaerke) + "\n"
        daten += "linkes Rauschen Lautstärke;" + str(self.linksRauschenLautstaerke) + "\n"
        daten += "linkes Rauschen untere Grenzfrequenz;" + str(self.linksRauschenUntereGrenzfrequenz) + "\n"
        daten += "linkes Rauschen obere Grenzfrequenz;" + str(self.linksRauschenObereGrenzfrequenz) + "\n"

        daten += "rechte Frequenz;" + str(self.rechtsFrequenz) + "\n"
        daten += "rechte Lautstärke;" + str(self.rechtsLautstaerke) + "\n"
        daten += "rechtes Rauschen Lautstärke;" + str(self.rechtsRauschenLautstaerke) + "\n"
        daten += "rechtes Rauschen untere Grenzfrequenz;" + str(self.rechtsRauschenUntereGrenzfrequenz) + "\n"
        daten += "rechtes Rauschen obere Grenzfrequenz;" + str(self.rechtsRauschenObereGrenzfrequenz) + "\n"

        daten += "Kommentar;" + str(self.kommentar) + "\n"

        datei.write(daten)
        datei.close()


"""---------------------------------KLASSE: SOUND-----------------------------------------------------------------------
Sound beinhaltet alle Variablen, die zum erstellen einer .wav-Datei benötigt werden (siehe soun.wav_speichern())
   Das 'sound_obj' ist für das dynamische abspielen zuständig (siehe sound.play())
   Beim Initialisieren muss ein Tinnitus-Objekt übergeben werden
---------------------------------------------------------------------------------------------------------------------"""


class Sound:
    def __init__(self, tinnitus, wav_name="MeinTinnitus.wav", audio=None, nchannels=2, sampwidth=2, framerate=44100,
                 comptype="NONE", compname="not compressed", mute=True):
        if audio is None:
            audio = []
        self.tinnitus = tinnitus
        self.wav_name = wav_name #Der Dateiname
        self.audio = audio  # ein Array, in das die Sound-Werte geschrieben werden (von -1, bis +1)
        self.nchannels = nchannels  # Zahl der audio channels (1:mono 2:stereo)
        self.sampwidth = sampwidth  # Größe eines einzelnen Sound-Werts (in bytes)
        self.framerate = framerate  # Abtastrate
        self.nframes = len(audio)  # Anzahl der Sound-Werte -> Muss bei jeder audio-Änderung aktuallisiert werden
        self.comptype = comptype
        self.compname = compname
        self.mute = mute  # wenn der mute boolean auf true gesetzt ist, sollte kein Ton ausgegeben werden
        self.sound_obj = sd.OutputStream(channels=2, callback=self.callback,
                                         samplerate=self.framerate)  # Objekt fürs Abspielen (siehe sound.play())
        self.start_idx = 0  # wird für sound_obj benötigt
        self.music_samplerate = 0     # die samplerate der ausgewählten Musikdatei
        self.music_data = 0           # das Numpy Array der ausgewählten Musikdatei


    def wav_speichern(self):  # ezeugt/aktuallisiert die .wav-Datei
        print("Sound wird als .wav-Datei gespeichert. Bitte warten...\nDer Vorgang kann ca. 10 Sekunden dauern")

        wav_obj = wave.open(self.wav_name, "w")

        # Die Callback-Funktion aufrufen, um die Audiodaten zu bekommen
        frames = self.framerate * 3  # entspricht 3 Sekunden
        status = ""  # für den Funktionsaufruf benötigt, sonst keine Funktion
        audio = np.ones((frames, 2))
        audio = self.callback(audio, frames, self.sound_obj.time, status)

        # Rahmenparameter für die .wav-Datei setzen
        self.nframes = len(audio)
        wav_obj.setparams((self.nchannels, self.sampwidth, self.framerate, self.nframes, self.comptype, self.compname))

        #Die Audiosamples schreiben
        for x in range(frames):
            #Die Audiodaten müssen von float in einen passenden int-Wert umgerechnet werden
            wav_obj.writeframes(struct.pack('h', int(audio[x][0] * 32767.0)))  # Werte für links und rechts werden bei
            wav_obj.writeframes(struct.pack('h', int(audio[x][1] * 32767.0)))  # wav abwechselnd eingetragen

        wav_obj.close()
        print("Speichern beendet.")

    """Die Objekt-Funktion 'start()' startet die asynchrone Soundwiedergabe. Sie ruft dabei immer wieder die Funktion
       sound.callback() auf. Daher können die dort genutzten Variablen dynamisch geändert werden. """

    def play(self):
        if not self.mute:  # Nie abspielen, wenn die GUI auf stumm geschaltet ist
            self.sound_obj.start()  # öffnet thread der immer wieder callback funktion aufruft und diese daten abspielt


    def stop(self):
        self.sound_obj.stop()  # beendet die asynchrone Soundwiedergabe

    """Die Funktion callback() erzeugt bei jedem Aufruf die Audiodaten, abhängig von den aktuellen Tinnitus-Variablen.
       Die errechneten  Werte werden in das NumPy-Array 'outdata' geschrieben """

    def callback(self, outdata, frames, time, status):
        if status:  # Warnungen, wenn das Soundobj. auf Fehler stößt (hauptsächlich over/underflow wg. Timingproblemen)
            print(status, file=sys.stderr)


        # Whitenoise erzeugen
        for x in range(len(outdata)):
            rand = (np.random.rand() - 0.5)  # Zufallszahl zwischen -0.5 und 0.5
            # links:
            outdata[x][0] = rand * self.tinnitus.linksRauschenLautstaerke
            # rechts:
            outdata[x][1] = rand * self.tinnitus.rechtsRauschenLautstaerke

        # Whitenoise durch Bandpass laufen lassen
        if self.tinnitus.linksRauschenLautstaerke:
            # (-3dB Grenzen) bzw was der Bandpass durchlässt
            fGrenz = [self.tinnitus.linksRauschenUntereGrenzfrequenz,
                         self.tinnitus.linksRauschenObereGrenzfrequenz]
            # sos (=second order sections = Filter 2. Ordnung) ist ein Array der Länge (filterOrder) und beinhaltet
            # die Koeffizienten der IIR Filter 2. Ordnung (b0, b1, b2 & a0, a1, a2)
            sos = signal.butter(5, fGrenz, 'bandpass', fs=self.framerate, output='sos')
            # sosfilt filtert das Signal mittels mehrerer 'second order sections' (= Filter 2. Ordnung) die über sos definiert sind
            outdata[:, 0] = signal.sosfilt(sos, outdata[:, 0])

        if self.tinnitus.rechtsRauschenLautstaerke:
            # (-3dB Grenzen) bzw was der Bandpass durchlässt
            fGrenz = [self.tinnitus.rechtsRauschenUntereGrenzfrequenz,
                      self.tinnitus.rechtsRauschenObereGrenzfrequenz]
            # sos (=second order sections = Filter 2. Ordnung) ist ein Array der Länge (filterOrder) und beinhaltet
            # die Koeffizienten der IIR Filter 2. Ordnung (b0, b1, b2 & a0, a1, a2)
            sos = signal.butter(5, fGrenz, 'bandpass', fs=self.framerate, output='sos')
            # sosfilt filtert das Signal mittels mehrerer 'second order sections' (= Filter 2. Ordnung) die über sos definiert sind
            outdata[:, 1] = signal.sosfilt(sos, outdata[:, 1])


        # Sinus addieren: f(t) = A * sin(2 * pi * f * t)
        for x in range(len(outdata)):
            # links: rauschen und sinus wieder zusammen addieren
            outdata[x][0] += self.tinnitus.linksLautstaerke * np.sin(2 * np.pi * self.tinnitus.linksFrequenz *
                                                                    ((x + self.start_idx) / self.framerate))
            # rechts: rauschen und sinus wieder zusammen addieren
            outdata[x][1] += self.tinnitus.rechtsLautstaerke * np.sin(2 * np.pi * self.tinnitus.rechtsFrequenz *
                                                                     ((x + self.start_idx) / self.framerate))

        self.start_idx += frames

        return outdata

    def musik_filtern(self):
        """ Die Tinnitus Frequenz aus der Musik Filtern... easy"""

        # Die Parameter des Tinnitus aus .csv Datei getten
        csvstring = open("TinnitusDaten.csv").read()
        #print(csvstring)
        x = csvstring.split("\n")
        #print("\nx= ", x)

        # linke Frequenz aus csv Datei holen
        lf = x[2]
        lf = lf.split(";")
        lf = float(lf[1])


        # rechte Frequenz aus csv Datei holen
        rf = x[7]
        rf = rf.split(";")
        rf = float(rf[1])


        # linke Lautstärke aus cvs Datei holen
        ll = x[3]
        ll = ll.split(";")
        ll = float(ll[1])

        # rechte Lautstärke aus cvs Datei holen
        rl = x[8]
        rl = rl.split(";")
        rl = float(rl[1])


        # Die Musik filtern
        w0 = float(lf/(self.music_samplerate/2))    # Frequency to remove from a signal. If fs is specified, this is in the same units as fs. By default, it is a normalized scalar that must satisfy 0 < w0 < 1, with w0 = 1 corresponding to half of the sampling frequency.
        Q = 30.0    # Quality factor. Dimensionless parameter that characterizes notch filter -3 dB bandwidth bw relative to its center frequency, Q = w0/bw.

        self.music_data = self.music_data/32767 * 0.8 # convert array from int16 to float

        b, a = signal.iirnotch(lf, Q, fs=self.music_samplerate)
        if ll != 0.0:
            print("Links wird gefiltert...")
            musicLinks = signal.lfilter(b, a , self.music_data[:, 0])    # links
            print("Filtern beendet")
        else:
            musicLinks = self.music_data[:, 0]  # ungefiltert, wenn kein Tinnitus angegeben wurde

        #Plot
            # freq, h = signal.freqz(b, a, fs=self.music_samplerate)
            # fig, ax = plt.subplots(2, 1, figsize=(8, 6))
            # ax[0].plot(freq, 20 * np.log10(abs(h)), color='blue')
            # ax[0].set_title("Frequency Response")
            # ax[0].set_ylabel("Amplitude (dB)", color='blue')
            # ax[0].set_xlim([0, 10000])
            # ax[0].set_ylim([-25, 10])
            # ax[0].grid()
            # ax[1].plot(freq, np.unwrap(np.angle(h)) * 180 / np.pi, color='green')
            # ax[1].set_ylabel("Angle (degrees)", color='green')
            # ax[1].set_xlabel("Frequency (Hz)")
            # ax[1].set_xlim([0, 10000])
            # ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
            # ax[1].set_ylim([-90, 90])
            # ax[1].grid()
            # plt.show()

        b, a = signal.iirnotch(rf, Q, fs=self.music_samplerate)
        if rl != 0.0:
            print("Rechts wird gefiltert...")
            musicRechts = signal.lfilter(b, a, self.music_data[:, 1])    # rechts
            print("Filtern beendet")
        else:
            musicRechts = self.music_data[:, 1]  # ungefiltert, wenn kein Tinnitus angegeben wurde


        wav_obj = wave.open("musikTest.wav", "w")

        # Rahmenparameter für die .wav-Datei setzen
        nframes = len(self.music_data) #Gesamtanzahl der Frames in der Musikdatei
        wav_obj.setparams((self.nchannels, self.sampwidth, self.music_samplerate, nframes, self.comptype, self.compname))

        print("Maximum musicLinks: ", max(musicLinks))
        print("Minimum musikLinks: ", min(musicLinks))


        # Die Audiosamples schreiben
        print("Musikdatei wird erstellt...")
        for x in range(self.music_samplerate * 20): #Kann mit nframes ersetzt werden, für den ganzen Song
            # Die Audiodaten müssen von float in einen passenden int-Wert umgerechnet werden
            wav_obj.writeframes(struct.pack('h', int(musicLinks[x] * 32767.0)))  # Werte für links und rechts werden bei
            wav_obj.writeframes(struct.pack('h', int(musicRechts[x] * 32767.0)))  # wav abwechselnd eingetragen
            if x % 10000 == 0:
                fortschritt = x/(self.music_samplerate*20)*100
                print("  ", round(fortschritt, 1), "%")

        wav_obj.close()
        print("Speichern beendet.")