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 time
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, 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 und Funktionen zum bearbeiten der wav-Dateien und zum abspielen des Sounds in Echtzeit
   Beim Initialisieren muss ein Tinnitus-Objekt übergeben werden
---------------------------------------------------------------------------------------------------------------------"""


class Sound:
    def __init__(self, tinnitus):

        self.tinnitus = tinnitus

    # Variablen für das Abspeichern und Abspielen des Tinnitus-Geräuschs:
        self.wav_name = "MeinTinnitus.wav" #Der Dateiname
        self.audio = []  # ein Array, in das die Sound-Werte geschrieben werden (von -1, bis +1)
        self.nchannels = 2  # Zahl der audio channels (1:mono 2:stereo)
        self.sampwidth = 2  # Größe eines einzelnen Sound-Werts (in bytes)
        self.framerate = 44100  # Abtastrate
        self.nframes = len(self.audio)  # Anzahl der Sound-Werte -> Muss bei jeder audio-Änderung aktuallisiert werden
        self.comptype = "NONE"
        self.compname = "not compressed"
        self.mute = True  # 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

    #Variablen für das Filtern der Musikdatei:
        self.music_samplerate = 0     # die samplerate der ausgewählten Musikdatei
        self.music_data = 0           # das Numpy Array der ausgewählten Musikdatei
        self.filterfortschritt = 0, 0.  # für feedback-fkt, 1.Position: Abschnitt-Nmr, 2.Positon: Speicherfortschritt


    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
        nframes = self.framerate * 10  # entspricht 10 Sekunden
        status = ""  # für den Funktionsaufruf benötigt, sonst keine Funktion
        audio = np.ones((nframes, 2))  # Audio-Array initialisieren
        audio = self.callback(audio, nframes, self.sound_obj.time, status)

        #Audio-Samples auf 1 normieren. Samples müssen zum speichern zwischen -1 und 1 liegen
        #Maximum finden (Funktion max(...) ist minimal schneller, macht aber Probleme beim Feedback)
        max_ges = 1
        for i in range(nframes):
            if max_ges < abs(audio[i][0]):
                max_ges = abs(audio[i][0])
            if max_ges < abs(audio[i][1]):
                max_ges = abs(audio[i][1])

        #auf 4 Nachkommastellen aufrunden
        max_ges = int(max_ges * 10000)
        max_ges += 1
        max_ges /= 10000

        print("X_GES: ", max_ges)

        #Alle samples normieren
        audio[:, 0] /= max_ges
        audio[:, 1] /= max_ges


        # 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))

        packedMusic = []  # Liste an die wir die einzelnen frames bereits in binär umgewandelt aneinanderreihen

        #Die Audiosamples schreiben
        for x in range(self.nframes):  # geht jeden Sample-Wert der Musikdatei einzeln durch
            # Die Audiodaten müssen von float in einen passenden int-Wert umgerechnet werden
            packedMusic.append(struct.pack('h', int(audio[x][0] * 32767.0)))
            packedMusic.append(struct.pack('h', int(audio[x][1] * 32767.0)))

        value_str = b"".join(packedMusic)
        wav_obj.writeframes(value_str)

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


    def play(self):
        """sound.play()' 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. """
        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


    def callback(self, outdata, frames, time, status):
        """erzeugt bei jedem Aufruf die Audiodaten, abhängig von den aktuellen Tinnitus-Variablen.
           Die errechneten  Werte werden in das NumPy-Array 'outdata' geschrieben """
        if status:  # Warnungen, wenn das Soundobj. auf Fehler stößt (hauptsächlich over/underflow wg. Timingproblemen)
            print(status, file=sys.stderr)


        # Whitenoise erzeugen
        # Wird auch durchlaufen, wenn es kein Rauschen gibt, damit die alten Daten mit 0 überschrieben werden
        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 = 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 = 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):
        """
        Diese Funktion filtert die Tinnitus Frequenz aus einer gewählten Musikdatei. Dabei geht sie in 4 großen
        Schritten vor:
        1. Die nötigen Informationen über den Tinnitus aus der .csv Datei herausholen
        2. Die digitalen Filter erstellen und die Tinnitus Frequenz aus der Audiodatei "herausschneiden"
        3. Überschwinger finden und alle Audiosamples wieder auf 1 normieren
        4. Die fertigen Audiodatei als .wav Datei speichern
        """
        nframes = len(self.music_data)  # Gesamtanzahl der Frames in der Musikdatei

        # ------------1. Die nötigen Informationen über den Tinnitus aus der .csv Datei herausholen---------------------
        self.filterfortschritt = 1, 0  # der erste schritt
        csvstring = open("TinnitusDaten.csv").read()
        tinnitus_data = csvstring.split("\n")

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


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


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

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

        # -------- 2. Die digitalen Filter erstellen und die Tinnitus Frequenz aus der Audiodatei "herausschneiden------
        self.filterfortschritt = 2, 0  # der zweite schritt im Feedback
        start_time = time.time()    # einen Timer laufen lassen um zu sehen wie lange Filterung dauert

        #Parameter festlegen
        order = 501   # Filterordnung
        bandwidth = 1000     # Bandbreite des Sperrbereichs in Hz
        self.music_data = self.music_data/32767  # convert array from int16 to float

        # ------------------------------------------LEFT EAR FILTERING-------------------------------------------------
        if ll != 0.0:   # nur wenn die Lautstärke des linken Tinnitus ungleich 0 ist, wird auf diesem Ohr auch gefiltert
            cutoff_frequencies = [(lf - (bandwidth / 2)),
                                  (lf + (bandwidth / 2))]  # the cutoff frequencies (lower and upper)
            h = signal.firwin(order, [cutoff_frequencies[0], cutoff_frequencies[1]], fs=self.music_samplerate)
            music_links = signal.lfilter(h, 1.0, self.music_data[:, 0])
        else:
            music_links = self.music_data[:, 0]  # ungefiltert, wenn kein Tinnitus angegeben wurde

        # ------------------------------------- RIGHT EAR FILTERING ------------------------------------------------
        if rl != 0.0:  # nur wenn die Lautstärke des rechten Tinnitus ungleich 0 ist, wird auf diesem Ohr auch gefiltert
            cutoff_frequencies = [(lf - (bandwidth / 2)),
                                  (lf + (bandwidth / 2))]  # the cutoff frequencies (lower and upper)
            h = signal.firwin(order, [cutoff_frequencies[0], cutoff_frequencies[1]], fs=self.music_samplerate)
            music_rechts = signal.lfilter(h, 1.0, self.music_data[:, 1])
        else:
            music_rechts = self.music_data[:, 1]  # ungefiltert, wenn kein Tinnitus angegeben wurde

        endTimeFiltering = time.time()
        print("benötigte Zeit zum Filtern rechts Ohr =", endTimeFiltering - start_time, "s")

        #----------------------- 3. Maxima finden und Samples auf 1 normieren ----------------------------
        self.filterfortschritt = 3, 0  # der dritte schritt

        #Maximum finden (Funktion max(...) ist minimal schneller, macht aber Probleme beim Feedback)
        start_time = time.time()
        max_ges = 1
        fortschritt = 0
        for i in range(nframes):
            if max_ges < abs(music_links[i]):
                max_ges = abs(music_links[i])
            if max_ges < abs(music_rechts[i]):
                max_ges = abs(music_rechts[i])
            if i % int(nframes/10) == 0:    # gibt Fortschritt in 10%-Schritten an
                fortschritt += 10
                self.filterfortschritt = 3, round(fortschritt, 1)
                print("  max: ", self.filterfortschritt[1], "%")
        end_time = time.time()
        print("Zeitaufwand Maxima-Suche: ", end_time - start_time)

        #auf 4 Nachkommastellen aufrunden
        start_time = time.time()
        max_ges = int(max_ges * 10000)
        max_ges += 1
        max_ges /= 10000
        end_time = time.time()
        print("Zeitaufwand Maximum runden: ", end_time - start_time)

        #Alle samples normieren
        start_time = time.time()
        music_links /= max_ges
        music_rechts /= max_ges
        end_time = time.time()
        print("Zeitaufwand samples normieren: ", end_time - start_time)

        # ------------------------- 4. Die fertigen Audiodatei als .wav Datei speichern --------------------------------
        self.filterfortschritt = [4, 0]  # der vierte Schritt

        start_time = time.time()
        wav_obj = wave.open("gefilterteMusik.wav", "w")

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

        """The values are stored in a temporary list, and when the process is finished, they are joined together into 
        an string which is then sent to the output with the traditional writeframes method."""

        packedMusic = []    # Liste an die wir die einzelnen frames bereits in binär umgewandelt aneinanderreihen

        # Die Audiosamples schreiben
        print("Musikdatei wird erstellt...")
        fortschritt = 0
        for tinnitus_data in range(nframes):  #geht jeden Sample-Wert der Musikdatei einzeln durch
            # Die Audiodaten müssen von float in einen passenden int-Wert umgerechnet werden
            packedMusic.append(struct.pack('h', int(music_links[tinnitus_data] * 32767.0)))
            packedMusic.append(struct.pack('h', int(music_rechts[tinnitus_data] * 32767.0)))
            if tinnitus_data % int(nframes/10) == 0:  # gibt Fortschritt in 10%-Schritten an
                fortschritt += 10
                self.filterfortschritt = 4, round(fortschritt, 1)
                print("  samples: ", self.filterfortschritt[1], "%")

        end_time = time.time()
        print("Zeitaufwand für das packen der einzelnen Samples =", end_time - start_time, "s")

        value_str = b"".join(packedMusic)

        start = time.time()
        wav_obj.writeframes(value_str)
        end = time.time()
        print("Zeitaufwand für das schreiben aller Frames in die wav Datei =", end - start, "s")
        wav_obj.close()

        print("Speichern beendet.")
        self.filterfortschritt = 5, 0  #Nach erfolgreichem Filtern Fortschritt zur Bestätigung auf 5 setzen