wav Dateien: Programieren von Wiedergabe und Aufnahme

das ist das input, das ich u.a. hier gefunden habe:

vector<int> audioCapture(int sek, string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
int err, zielzeit;
char *puffer;
vector<int> input;


was du intern nur in den Funktionen verwendest, ist für mich natürlich nicht wichtig, aber alles was weiterverarbeitet wird (gefiltert, extrahiert, geglättet, geschnitten, transformiert) muss feste array-Größen haben.

Das Ziel ist ja (ich hatte es schon erwähnt):

du hast aufgenommenene Rohdaten (die können länger oder kürzer sein als 2^15 Werte oder "packages") als bytes (strings) oder ints, keine Ahnung,
die müssen in einen int32_t array überführt werden, wo sie nur max. 32767==SHRT_MAX Zellen belegen dürfen
(sample rate 11-12kHz, also ca. 3 sec.),
dann kommt der double-Array von doppelter Länge (65535==USHRT_MAX) ins Spiel, dessen (mindestens) 2. Hälfte mit Nullen aufgefüllt wird.

Länger als 3 sec dürfen also die gesprochenen Kommandos nicht werden (egal ob 1 oder mehrere Wörter)


wav enthält dann im "Roh-array" 2 Kanäle, und wir verarbeiten aber nur 1 Kanal, also muss jedes 2. Datenpaket raus geschmissen werden.
Es sind dann wohl 16-bit ints, oder wie ist das, das ist schließlich wichtig, denn das muss ja exakt in floats (double) überführt werden.
Also immer 2 bytes als int16 lesen und in den Bearbeitungs-Array als int32 kopieren (li Kanal), dann 2 bytes verwerfen (re Kanal), dann wieder 2 lesen+kopieren (li Kanal) usw. ?
Oder andersrum? Oder andere Datenblöcke? Da kommts jetzt drauf an.

So ich habe dann etwas rum gebastelt. Jetzt nimmt er genau SHRT_MAX auf. Hast recht, bei 12Khz sind es um die 3 Sekunden, rauscht dafür aber auch mehr.

Code:

---

#include <alsa/asoundlib.h>

#include <iostream>
#include <vector>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

using namespace std;

typedef struct _FILE_head
{
        unsigned char        ID[4];
        unsigned int        Length;
        unsigned char        Type[4];
} FILE_head;

typedef struct _FORMAT
{
        short wFormatTag;
        unsigned short        wChannels;
        unsigned int        dwSamplesPerSec;
        unsigned int        dwAvgBytesPerSec;
        unsigned short        wBlockAlign;
        unsigned short        wBitsPerSample;
} FORMAT;

typedef struct _CHUNK_head
{
        unsigned char ID[4];
        unsigned int        Length;
} CHUNK_head;

snd_pcm_t *soundKarte;

bool Init(string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err;
       
        snd_pcm_format_t bits;

        unsigned int resample = 1;

        switch(WaveBits)
        {
                case 8:
                        bits = SND_PCM_FORMAT_U8;
                        break;
       
                case 16:
                        bits = SND_PCM_FORMAT_S16;
                        break;
       
                case 24:
                        bits = SND_PCM_FORMAT_S24;
                        break;
       
                case 32:
                        bits = SND_PCM_FORMAT_S32;
                        break;
        }       
       
        snd_pcm_hw_params_t *hw_params;

        if(name.length() == 0)
        {
                err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_PLAYBACK, 0);
        }
        else
        {
                err = snd_pcm_open(&soundKarte, name.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
        }

        if(err < 0)
        {
                cout << "Init: Kann die Soundkarte nicht öffnen! " << name << " (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht initialisiert werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_any(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht ermittelt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        err = snd_pcm_hw_params_set_rate_resample(soundKarte, hw_params, resample);

        if(err < 0)
        {
                cout << "Init: Resampling kann nicht eingeschaltet werden " << snd_strerror(err) << endl;

                return err;
        }

        if((err = snd_pcm_hw_params_set_access(soundKarte, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
        {
                cout << "Init: Zugriffstyp kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_format(soundKarte, hw_params, bits)) < 0)
        {
                cout << "Init: Sample-Format kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_channels(soundKarte, hw_params, channels)) < 0)
        {
                cout << "Init: Anzahl der Kanäle kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_rate_near(soundKarte, hw_params, &actualRate, 0)) < 0)
        {
                cout << "Init: Sample-Rate kann nicht auf " << actualRate << " gesetzt werden (" << snd_strerror (err) << ")"  << endl;

                return false;
        }

        if((err = snd_pcm_hw_params(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameters können nicht gesetzt werden(" << snd_strerror (err) << ")" << endl;

                return false;
        }
        snd_pcm_hw_params_free(hw_params);

        if((err = snd_pcm_prepare(soundKarte)) < 0)
        {
                cout << "Init: Audio kann nicht zur Nutzung vorbereitet werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        return true;
}

bool InitCapture(string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err;
       
        snd_pcm_format_t bits;

        switch(WaveBits)
        {
                case 8:
                        bits = SND_PCM_FORMAT_U8;
                        break;
       
                case 16:
                        bits = SND_PCM_FORMAT_S16;
                        break;
       
                case 24:
                        bits = SND_PCM_FORMAT_S24;
                        break;
       
                case 32:
                        bits = SND_PCM_FORMAT_S32;
                        break;
        }       
       
        snd_pcm_hw_params_t *hw_params;

        if(name.length() == 0)
        {
                err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_CAPTURE, 0);
        }
        else
        {
                err = snd_pcm_open(&soundKarte, name.c_str(), SND_PCM_STREAM_CAPTURE, 0);
        }

        if(err < 0)
        {
                cout << "Init: Kann die Soundkarte nicht öffnen! " << name << " (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht initialisiert werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_any(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht ermittelt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_access(soundKarte, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
        {
                cout << "Init: Zugriffstyp kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_format(soundKarte, hw_params, bits)) < 0)
        {
                cout << "Init: Sample-Format kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_channels(soundKarte, hw_params, channels)) < 0)
        {
                cout << "Init: Anzahl der Kanäle kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_rate_near(soundKarte, hw_params, &actualRate, 0)) < 0)
        {
                cout << "Init: Sample-Rate kann nicht auf " << actualRate << " gesetzt werden (" << snd_strerror (err) << ")"  << endl;

                return false;
        }

        if((err = snd_pcm_hw_params(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameters können nicht gesetzt werden(" << snd_strerror (err) << ")" << endl;

                return false;
        }

        snd_pcm_hw_params_free(hw_params);

        if((err = snd_pcm_prepare(soundKarte)) < 0)
        {
                cout << "Init: Audio kann nicht zur Nutzung vorbereitet werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        return true;
}

bool UnInit()
{
  snd_pcm_close(soundKarte);

  return true;
}

int playwave(string waveDatei, string name)
{
        FORMAT format;
        FILE_head head;
        CHUNK_head chead;

        char *wave;

        register snd_pcm_uframes_t count, frames;       
       
        int datei;
       
        unsigned int WaveSize;
       
        datei = open(waveDatei.c_str(), 00);
               
        read(datei, &head, sizeof(FILE_head));

        read(datei, &chead, sizeof(CHUNK_head));

        read(datei, &format, sizeof(FORMAT));

        wave = (char *) malloc(head.Length);
       
        read(datei, wave, head.Length);

        WaveSize = head.Length * 8 / ((unsigned int)format.wBitsPerSample * (unsigned int)format.wChannels);

        close(datei);

        Init(name, format.wChannels, format.dwSamplesPerSec, format.wBitsPerSample);
       
        count = 0;
       
        do
        {
                frames = snd_pcm_writei(soundKarte, wave + count, WaveSize - count);

                if (frames < 0) frames = snd_pcm_recover(soundKarte, frames, 0);
                if (frames < 0)
                {
                        printf("Kann wav nicht abspielen: %s\n", snd_strerror(frames));
                        break;
                }

                count += frames;

        } while (count < WaveSize);

        if (count == WaveSize) snd_pcm_drain(soundKarte);

        free(wave);

        UnInit();

        return 0;
}

vector<int> audioCapture(int SHRT_MAX, string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err, i=0;
       
        char *puffer;
       
        vector<int> input;
       
        puffer = (char *) malloc(1);
       
        cout << "Beginne Aufnahme" << endl;
       
        if(InitCapture(name, channels, actualRate, WaveBits))
        {
                while(i < SHRT_MAX)
                {
                        err = snd_pcm_readi(soundKarte, puffer, 1);
                       
                        if(err < 0) cout << "Fehler bei der Aufnahme!" << endl;
                       
                        input.push_back(puffer[0]);

                        i++;
                }

                free(puffer);
               
                UnInit();
        }
        else cout << "Bei der Initialisierung ist ein Fehler aufgetreten!" << endl;
       
        cout << "Aufnahme beendet!" << endl;
       
        return input;
}

void playCaptured(char *wave, unsigned int WaveSize, string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        register snd_pcm_uframes_t count, frames;       
       
        Init(name, channels, actualRate, WaveBits);

        WaveSize = WaveSize * 8 / WaveBits * channels;

        count = 0;
       
//        for(int i=0;i<WaveSize-2;i++) printf("%d/%d -> %d\n", i, WaveSize, wave[i]);
       
        do
        {
                frames = snd_pcm_writei(soundKarte, wave + count, WaveSize - count);

                if(frames < 0) frames = snd_pcm_recover(soundKarte, frames, 0);
                if(frames < 0)
                {
                        printf("Kann wav nicht abspielen: %s\n", snd_strerror(frames));
                        break;
                }

                count += frames;

        } while (count < WaveSize);

        if (count == WaveSize) snd_pcm_drain(soundKarte);

        UnInit();
}

---

Das ist der neue Header und hier kommt das neue main:

Code:

---

#include <iostream>
#include <vector>
#include <fstream>

#include <stdio.h>

#include "diaSound.hpp"

bool debug = false;

int main()
{
        fstream datei;
       
        vector<int> input;

        unsigned int i, SHRT_MAX = 32767;

        char *wave;
       
        input = audioCapture(SHRT_MAX, "plughw:1,0", 1, 12000, 8);
       
        wave = (char *) malloc(input.size());
       
        if(debug) datei.open("test.csv", ios::out);
       
        for(i=0;i<input.size();i++)
        {
                wave[i] = input[i];
                if(debug) datei << input[i] << endl;
        }
       
        if(debug) datei.close();
       
        playCaptured(wave, input.size(), "plughw:1,0", 1, 12000, 8);
       
        free(wave);
       
        return 1;
}

---

Zufrieden soweit?

stelle gerade fest:

die float (double) arrays müssen USHRT_MAX+1 groß sein ( == exakt 2^16 ),
für SHRT_MAX soll es so bleiben.

SHRT_MAX und USHRT_MAX sind C-Konstanten, die brauchst du nicht mehr definieren
(oder wir verwenden explizit 32767, 65536)

http://www.cplusplus.com/reference/climits/


und bitte auch möglichst nirgends int oder unsigned int verwenden, immer nur int32_t und uint32_t

das gleiche gilt für char und unsigned char (stattdessen möglichst int8_t, uint8_t)



in main steht immer noch

vector<int> input;

das müsste dann auch zu
int32_t input[SHRT_MAX]
werden

Und nochmal bisschen umgestrickt.

Code:

---

#include <iostream>
#include <vector>
#include <fstream>

#include <stdio.h>

#include "diaSound.hpp"

bool debug = false;

int main()
{
        fstream datei;
       
        vector<int> input;

        unsigned int i, SHRT_MAX = 32767;

        char *wave;
       
        int32_t inputWave[SHRT_MAX];
       
        input = audioCapture(SHRT_MAX, "plughw:1,0", 1, 12000, 8);
       
        wave = (char *) malloc(input.size());
       
        if(debug) datei.open("test.csv", ios::out);
       
        for(i=0;i<input.size();i++)
        {
                wave[i] = input[i];

                inputWave[i] = input[i];
                if(debug) datei << input[i] << endl;
        }
       
        if(debug) datei.close();
       
        playCaptured(wave, input.size(), "plughw:1,0", 1, 12000, 8);
       
        free(wave);
       
        return 1;
}

---

Nun liegt also ein Array als int32_t vor mit exakt der Länge SHRT_MAX (wenn ich SHRT_MAX nicht deklariere bekomme ich eine Fehlermeldung! Fehlt mir da eine Headerdatei?).

Zitat:

---

und bitte auch möglichst nirgends int oder unsigned int verwenden, immer nur int32_t und uint32_t

das gleiche gilt für char und unsigned char (stattdessen möglichst int8_t, uint8_t)

---

Was hat das für einen Vorteil?

int ist von der Größe her nicht festgelegt (compiler- und Zielplattform-abhängig, manchmal 16bit, manchmal 32bit (z.Zt Raspi 2) und manchmal 64bit), und char ist auf manchen Plattformen signed und auf anderen unsigned.
int32_t ist aber auf allen Plattformen identisch groß und int8_t überall signed.
(Ntl kannst du überall vor jedes char auch ein signed davorschreiben, aber das ist wieder unnötige Schreiberei - die int Länge allerdings ist damit immer noch nicht von identischer Länge -
wir dürfen nicht vergessen:
ich habe einen 32bit Pi 2, aber du hast einen 64bit Pi 3...!
(und wer weiß, ob wir den Code mal auf nem Raspi4 mit Win10-2020 verwenden werden...? ;) )

die limits stehen in <limits.h>
aber auch da bin ich fast schon wieder bei den echten Zahlen 32767 und 65536, auch wegen künftiger Portierbarkeit.

es stellt sich auch die Frage, ob wir lieber Geschwindigkeit wollen oder Speicher sparen:
32767 int16 sind etwas langsamer, aber ein schnellerer 32767er array von int32_t ist schon ein Wort.
Noch interessanter wirds dann bei 65536er arrays von float vs. double ...

naja, wir haben ja 1 GB RAM (hatte mich grade schon verrechnet... ;) )

Du stellst einen schon vor Herausforderungen! Denn Seit ich von char * auf int32_t * umgestellt habe schmiert das Programm sofort bei Aufruf von playCaptured ab. Da werde ich also bei char * bleiben. Das dürfte aber letzten Endes egal sein, denn solltest du das irgendwann mal auf Windows zum Laufen bringen wollen wirst du eh für Aufnahme und Ausgabe andere Funktionen brauchen.

ps:

Die Chance das ich irgendwann mal freiwillig mit Windows arbeite halte ich für sehr fraglich ;).

zu den ints: du wirst (irgendwann) 64-bit ints haben (Pi 3 = 64bit µC), ich aber weiterhin 32bit (Pi 2 = 32bit µC):
dann stimmen die Arraygrößen auf unseren System nicht mehr überein.

zu den char[] arrays:
ich weiß nicht, was dein char[] array macht bzw was drin steht.
Wenn die Aufnahmefunktion die Rohdaten in char[] speichern muss, muss man es dort erst so lassen, dann aber als nächstes in int32 arrays umkopieren, bevor man weitermacht.

Aber dazu muss man wissen, wie die Datenpakete pro Einzelpaket kodiert sind.
sind es immer 4 bytes, erst 2 bytes für li, dann 2 bytes für rechts?

audioCapture() läuft schon auf int32_t. So kommen auch die Daten an, eben als Vector, das ändert aber auch an der Grösse nichts.

was mit playCaptured ist verstehe ich nicht. Das stürzt sofort ab wenn ich es aufrufe! In die Funktion kommt es gar nicht. Das stürzt beim Aufrufen schon ab.

gings denn vorher mit playCaptured?

zum Daten-Record und Aufbereiten -
vielleicht hast du mich falsch verstanden, und ich bin ja nicht auf denem Programmier-Level:

Ich hatte mir vorgestellt, dass anstelle von
string oder char* wasauchimmer
jetzt
uint8_t (!!) wasauchimmer (nicht int32_t !!)
verwendet werden soll, aber mit festen array Grenzen;

das gleiche gilt für vector<int> input etc,
stattdesen
int32_t input[FESTE_GROESSE]


Das hätte den Sinn, dass man es immer mit identisch großen records zu run hat, was das Aufbereiten der Daten vereinfacht.
Wenn du lieber erst mit Vektoren variabler Größe arbeitest, auch ok, dann muss es im nächsten Schritt eben in arrays von konstanter Größe verfrachtet werden, und zwar nur MONO (1 Kanal).

Weil es nur MONO sein darf, muss man wissen, welche der ganzen Bytes genau die richtigen Töne darstellen, ohne die andere Spur mitzukopieren.

Die konstante Größe ist wichtig, denn wie du sicher weißt, arbeitet ja die FFT nur mit arrays, die eine Länge haben, die sich als 2^n (hier: 2^16 == 65536) darstellen lässt.

Für die Cross Correlation darf dafür nur höchstens die erste Hälfte mit Daten gefüllt sein, mindestens die 2. Hälfte ausschließlich mit Nullen.

Daher bleibt für Daten dann maximal ((2^n)/2) -1 (== 2^15 -1 == 32767 ) übrig, und das muss die exakte Länge der int32-MONO-Records sein, die man erst cutted und filtert und dann (zu floats konvertiert) der FFT übergibt.


Wann du also anfängst mit fixen arrays, ist prinzipiell egal, aber Vektoren taugen dazu nicht, und daher muss man vektoren auch erst wieder in fixe arrays umwandeln, bevor man mit der eigentlichen Arbeit anfangen kann, und daher: je früher, je besser.

Ist dir klar, wie ich das meine?

Ich nehm es doch mal an ^^.

Ich bastel das nachher um. Allerdings kann es ein wenig dauern. Ich musste vorhin zum Essen meinen Bot (Also die Holzplatte auf dem die Platinen drauf geschraubt sind ^^) vom Tisch runter holen, bin hängen geblieben und hab mir da Kabel abgerissen. Demnach hat der arme Raspi zur Zeit keinen Strom :(. Sobald das geregelt ist baue ich das Programm nochmal etwas um.

Mir kam da aber auch ein Gedanke. Du sprachst davon, die Aufnahme soll immer nur dann beginnen wenn eine gewisse Lautstärke überschritten ist. Da kam mir der Gedanke, ich habe noch ein Soundmodul für den Arduino. Das ist ja dafür da bei einer gewissen Lautstärke ein Signal zu geben. Das könnte man da ja für nutzen um das Ganze zu Automatisieren. Derzeit ist es ja so, das Programm startet, nimmt sofort auf und fertig. Mit dem Teil könnte mein Aruduino ja ein Signal an den Raspi schicken, die Lautstärke ist überschritten und der nimmt dann automatisch die feste Grösse lang auf.

- - - Aktualisiert - - -

So, der gute Raspi hat wieder Saft und wie versprochen hier eine char und vector bereinigte Main

Code:

---

#include <iostream>
#include <vector>
#include <fstream>

#include <stdio.h>
#include <limits.h>

#include "diaSound.hpp"

bool debug = false;

int main()
{
        fstream datei;
       
        int32_t input[SHRT_MAX];

        int i;

        uint8_t *wave;
       
        audioCapture(input, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
       
        wave = (uint8_t *) malloc(SHRT_MAX+1);
       
        if(debug) datei.open("test.csv", ios::out);
       
        for(i=0;i<SHRT_MAX;i++)
        {
                wave[i] = input[i];

                cout << i << " -> " << input[i] << endl;

                if(debug) datei << input[i] << endl;
        }
       
        if(debug) datei.close();

        playCaptured(wave, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
       
        free(wave);
       
        return 1;
}

---

und die Header dazu

Code:

---

#include <alsa/asoundlib.h>

#include <iostream>
#include <vector>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

using namespace std;

typedef struct _FILE_head
{
        unsigned char        ID[4];
        unsigned int        Length;
        unsigned char        Type[4];
} FILE_head;

typedef struct _FORMAT
{
        short wFormatTag;
        unsigned short        wChannels;
        unsigned int        dwSamplesPerSec;
        unsigned int        dwAvgBytesPerSec;
        unsigned short        wBlockAlign;
        unsigned short        wBitsPerSample;
} FORMAT;

typedef struct _CHUNK_head
{
        unsigned char ID[4];
        unsigned int        Length;
} CHUNK_head;

snd_pcm_t *soundKarte;

bool Init(string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err;
       
        snd_pcm_format_t bits;

        unsigned int resample = 1;

        switch(WaveBits)
        {
                case 8:
                        bits = SND_PCM_FORMAT_U8;
                        break;
       
                case 16:
                        bits = SND_PCM_FORMAT_S16;
                        break;
       
                case 24:
                        bits = SND_PCM_FORMAT_S24;
                        break;
       
                case 32:
                        bits = SND_PCM_FORMAT_S32;
                        break;
        }       
       
        snd_pcm_hw_params_t *hw_params;

        if(name.length() == 0)
        {
                err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_PLAYBACK, 0);
        }
        else
        {
                err = snd_pcm_open(&soundKarte, name.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
        }

        if(err < 0)
        {
                cout << "Init: Kann die Soundkarte nicht öffnen! " << name << " (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht initialisiert werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_any(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht ermittelt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        err = snd_pcm_hw_params_set_rate_resample(soundKarte, hw_params, resample);

        if(err < 0)
        {
                cout << "Init: Resampling kann nicht eingeschaltet werden " << snd_strerror(err) << endl;

                return err;
        }

        if((err = snd_pcm_hw_params_set_access(soundKarte, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
        {
                cout << "Init: Zugriffstyp kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_format(soundKarte, hw_params, bits)) < 0)
        {
                cout << "Init: Sample-Format kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_channels(soundKarte, hw_params, channels)) < 0)
        {
                cout << "Init: Anzahl der Kanäle kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_rate_near(soundKarte, hw_params, &actualRate, 0)) < 0)
        {
                cout << "Init: Sample-Rate kann nicht auf " << actualRate << " gesetzt werden (" << snd_strerror (err) << ")"  << endl;

                return false;
        }

        if((err = snd_pcm_hw_params(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameters können nicht gesetzt werden(" << snd_strerror (err) << ")" << endl;

                return false;
        }
        snd_pcm_hw_params_free(hw_params);

        if((err = snd_pcm_prepare(soundKarte)) < 0)
        {
                cout << "Init: Audio kann nicht zur Nutzung vorbereitet werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        return true;
}

bool InitCapture(string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err;
       
        snd_pcm_format_t bits;

        switch(WaveBits)
        {
                case 8:
                        bits = SND_PCM_FORMAT_U8;
                        break;
       
                case 16:
                        bits = SND_PCM_FORMAT_S16;
                        break;
       
                case 24:
                        bits = SND_PCM_FORMAT_S24;
                        break;
       
                case 32:
                        bits = SND_PCM_FORMAT_S32;
                        break;
        }       
       
        snd_pcm_hw_params_t *hw_params;

        if(name.length() == 0)
        {
                err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_CAPTURE, 0);
        }
        else
        {
                err = snd_pcm_open(&soundKarte, name.c_str(), SND_PCM_STREAM_CAPTURE, 0);
        }

        if(err < 0)
        {
                cout << "Init: Kann die Soundkarte nicht öffnen! " << name << " (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht initialisiert werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_any(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameter können nicht ermittelt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_access(soundKarte, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
        {
                cout << "Init: Zugriffstyp kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_format(soundKarte, hw_params, bits)) < 0)
        {
                cout << "Init: Sample-Format kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_channels(soundKarte, hw_params, channels)) < 0)
        {
                cout << "Init: Anzahl der Kanäle kann nicht gesetzt werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        if((err = snd_pcm_hw_params_set_rate_near(soundKarte, hw_params, &actualRate, 0)) < 0)
        {
                cout << "Init: Sample-Rate kann nicht auf " << actualRate << " gesetzt werden (" << snd_strerror (err) << ")"  << endl;

                return false;
        }

        if((err = snd_pcm_hw_params(soundKarte, hw_params)) < 0)
        {
                cout << "Init: Parameters können nicht gesetzt werden(" << snd_strerror (err) << ")" << endl;

                return false;
        }

        snd_pcm_hw_params_free(hw_params);

        if((err = snd_pcm_prepare(soundKarte)) < 0)
        {
                cout << "Init: Audio kann nicht zur Nutzung vorbereitet werden (" << snd_strerror (err) << ")" << endl;

                return false;
        }

        return true;
}

bool UnInit()
{
  snd_pcm_close(soundKarte);

  return true;
}

int playwave(string waveDatei, string name)
{
        FORMAT format;
        FILE_head head;
        CHUNK_head chead;

        char *wave;

        register snd_pcm_uframes_t count, frames;       
       
        int datei;
       
        unsigned int WaveSize;
       
        datei = open(waveDatei.c_str(), 00);
               
        read(datei, &head, sizeof(FILE_head));

        read(datei, &chead, sizeof(CHUNK_head));

        read(datei, &format, sizeof(FORMAT));

        wave = (char *) malloc(head.Length);
       
        read(datei, wave, head.Length);

        WaveSize = head.Length * 8 / ((unsigned int)format.wBitsPerSample * (unsigned int)format.wChannels);

        close(datei);

        Init(name, format.wChannels, format.dwSamplesPerSec, format.wBitsPerSample);
       
        count = 0;
       
        do
        {
                frames = snd_pcm_writei(soundKarte, wave + count, WaveSize - count);

                if (frames < 0) frames = snd_pcm_recover(soundKarte, frames, 0);
                if (frames < 0)
                {
                        printf("Kann wav nicht abspielen: %s\n", snd_strerror(frames));
                        break;
                }

                count += frames;

        } while (count < WaveSize);

        if (count == WaveSize) snd_pcm_drain(soundKarte);

        free(wave);

        UnInit();

        return 0;
}

void audioCapture(int32_t *input, int max, string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        int err, i=0;
       
        int32_t *puffer;
       
        puffer = (int32_t *) malloc(1);
       
        cout << "Beginne Aufnahme" << endl;
       
        if(InitCapture(name, channels, actualRate, WaveBits))
        {
                while(i < max)
                {
                        err = snd_pcm_readi(soundKarte, puffer, 1);
                       
                        if(err < 0) cout << "Fehler bei der Aufnahme!" << endl;
                       
                        input[i] = puffer[0];

                        i++;
                }

                free(puffer);
               
                UnInit();
        }
        else cout << "Bei der Initialisierung ist ein Fehler aufgetreten!" << endl;
       
        cout << "Aufnahme beendet!" << endl;
}

void playCaptured(uint8_t *wave, unsigned int WaveSize, string name, unsigned int channels, unsigned int actualRate, unsigned short WaveBits)
{
        register snd_pcm_uframes_t count, frames;       

        Init(name, channels, actualRate, WaveBits);

        WaveSize = WaveSize * 8 / WaveBits * channels;

        count = 0;
       
        do
        {
                frames = snd_pcm_writei(soundKarte, wave + count, WaveSize - count);

                if(frames < 0) frames = snd_pcm_recover(soundKarte, frames, 0);
                if(frames < 0)
                {
                        printf("Kann wav nicht abspielen: %s\n", snd_strerror(frames));
                        break;
                }

                count += frames;

        } while (count < WaveSize);

        if (count == WaveSize) snd_pcm_drain(soundKarte);

        UnInit();
}

---

Zudem alles auf entsprechende Grösse SHRT_MAX ausgerichtet.

Und jetzt?