Soundverarbeitung mit dem Raspi

[HaWe]

Die Spracherkennung (vergleich von Audio-Signalen) läuft meist über eine FFT (Fast Fourier Transformation), Stichwort: audio cross correlation
http://dsp.stackexchange.com/questio...es-are-similar

Grundsätzlich kann man versuchen
a) den Micro-Sound in Real time zu verarbeiten (wschl.schwierig)
b) der einfachste Weg (und der einzige, den ich mir für tinyalsa vorstellen kann), wäre aber:

0. überprüfen, ob du beliebige wav files überhaupt mit tinyalsa abspielen kannst , 
   ansonsten anderes Programm 
1. Code zum Aufnehmen eines .wav Files schreiben (entweder auch tinyalsa oder anderes Programm),  
   und die Qualität vom Ergebnis testen (abspielen), ggf Aufnahmeparameter anpassen   
2. a) erzeugte wav-File Daten in einen FFT-kompatiblen array passender Größe konvertieren,
      dann einer FFT unterwerfen (Array aus komplexen Zahlen, also 2D Array), 
   b) dann die Transformierte weiter verarbeiten (s. mein Post oben) um Rauschen / Störfrequenzen etc. zu elimieren
   c) debug: zur Kontrolle die FFT auf das veränderte Ergebnis anwenden,
      und dann das Ergebnis wieder als wav abspeichern und abhören
   d) goto 2.b)...
3. Anlage einer wav-Datenbank mit verschiedenen definierten Sound/Sprach-Records als Vergleichsbasis

die Parts mit dem Play- und dem Record-Programm wären also das erste, was du schreiben und testen musst.

[hirnfrei]

Tue ich doch. Als ich davon Sprach die Wav Dateien entsprechend zu verarbeiten war eigentlich gemeint, die Heder auslesen, Daraus die entsprechenden Werte für Alsa übernehemen, die Soundkarte entsprachend initialisieren, dann die Daten abspielen und Alles wieder schliessen.

Gestern Abend bin ich noch so weit gekommen, dass beim Abspielen ein kurzes Knacken zu hören ist. Kein Grund einen Luftsprung zu machen, aber immerhin ein weiterer Schritt. Hab mir gestern erst einmal angeschaut wie so ein Wav aufgebaut ist. Wie gesagt, hatte damit bislang noch nie etwas zu tun. Ich denke mal, ich übergebe da noch ein paar Parameter nicht richtig. Aber das sollte ich hin bekommen.

Erst danach kommt das mit dem Aufnehmen usw. Immer schön Schritt für Schritt!

[HaWe]

deine Aussage

Also wo stehe ich. Ich kann mittels ALSA die Soundkarte öffnen, die Parameter abrufen, sie beliebig setzen und vorbereiten.

An dieser Stelle käme dann das mit dem Sound. Da hatte ich den Fehler das ich nur einmal Daten gelesen habe und diese dann laufend zur Karte geschickt hatte. Lese ich das File komplett, oder auch stückweise gibt es gar keinen Ton von sich.

Letzten Endes wird die Soundkarte dann auch wieder deaktiviert.

Bliebe die Frage, wie bringe ich dem das mit den Audiodaten näher? Ich nehme an ich muss das Wav-File erst entsprechend verarbeiten.

klang nicht so, als ob du schon einwandfrei abspielen und aufnehmen könntest, und erst dann kommt ja die Weiterverarbeitung.

Wenn du aber schon play- und record-Code hast, dann poste ihn mal bitte!

[hirnfrei]

Entweder du verstehst mich, oder ich verstehe dich falsch ^^.

Was ich sagen wollte, die Soundkarte aktivieren konnte ich schon mittels C/C++ (und Geany ^^). Nur bekam ich die Soundkarte bisher nur dazu einen schmerzhaften Ton zu produzieren. Da ich bislang von Sound-Formaten komplett 0 Ahnung hatte musste ich erst einmal lernen wie ich die wav Datei so zerpflücke, dass ich die Soundkarte mit den entsprechenden Werten (Kanäle, Bit...) initialisieren und aus der Datei dann den abspielbaren Bereich heraus nehmen muss.

Und siehe da, Mission erfüllt .

Den Code bereite ich noch ein wenig auf. So gefällt mir das nicht und schön ist das auch nicht. Dann poste ich den. Der ist dann aber minimal, geht also auf keine Fehler oder so ein.

- - - Aktualisiert - - -

Hilfe!

Ich hab gerade voll die Blockade!

Aktuell setze ich die globale Variable

snd_pcm_t *soundKarte;

Ich mag globale Variablen aber eher weniger und wollte die nun in einer Funktion verwursten. Die Funktion sollte aufgerufen werden:

soundkarteIni("plugdev:1,0", soundKarte);

Nur wie zur Hölle muss ich die Funktion nochmal schreiben, dass *soundKarte von der Funktion gefüllt wird?

Ich kriege grade voll die Krise!

[HaWe]

ja, ich hatte dich falsch verstanden.
Jetzt aber doch wohl richtig.

und jetzt bin ich gespannt was wie bereits geht ...

Kannst du mit vllt auch mal deine Soundkarte genau verlinken? Wenn alles funktioniert mit play/record, hol ich mir die gleiche!

(oh, hat sich gerade überschnitten...)

[hirnfrei]

Das mit der globalen Variable gefällt mir zwar immer noch nicht aber ich bin aktuell zu doof um es anders zu regeln.

So funktioniert es auf jeden Fall!

#include <alsa/asoundlib.h>

#include <iostream>

#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(const char *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 == NULL)
	{
		err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_PLAYBACK, 0);
	}
	else
	{
		err = snd_pcm_open (&soundKarte, name, 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: Üarameters können nicht gesetzt werden(" << snd_strerror (err) << ")" << endl;

		return false;
	}
//	snd_pcm_hw_params_get_buffer_size(hw_params, &bufferSize);

	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 main()
{
	FORMAT format;
	FILE_head head;
	CHUNK_head chead;
	
	char *wave;

	register snd_pcm_uframes_t count, frames;	
	
	int datei;
	
	unsigned int WaveSize;
	
	datei = open("/home/pi/Music/cantalow.wav", 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("plughw:1,0", 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;
}

[HaWe]

in welchem Ober-Verzeichnis liegt deine alsa/asoundlib.h ?
und wie lautet deine Compile/Build Parameter Liste?

und wo steht, was "soundKarte" ist ? Bzw. wie man das auf die eingebaute oder andere externe "Karten" umstellt?

[hirnfrei]

Dazu notwendig ist (falls noch nicht vorhanden)

sudo apt-get install libasound2-dev

sowie braucht es beim Linken noch

-lasoundlib

für g++.

- - - Aktualisiert - - -

Das übergibst du bei

Init("plughw:1,0", format.wChannels, format.dwSamplesPerSec, format.wBitsPerSample);

Wie Peter schon sagte, 1 ist die zweite verfügbare Soundkarte. Da Raspi eine drin hat ist diese 0. Welche Nummer die entsprechende Karte hat kannst du zum Beispiel mit

aplay -l

heraus finden.