wav Dateien: Programieren von Wiedergabe und Aufnahme

[HaWe]

meinst du
snd_pcm_t *soundKarte
?

das ist wschl Teil des Problems, eventuell wäre es das beste, ein Objekt daraus zu machen mit den Methoden
init()
open()
close()
play()
record()


ich würde sie ansonsten in einer Funktion

snd_pcm_t * init_soundKarte(soundKarte){   
   snd_pcm_t * retstruc = soundKarte;
   //...
   //...
   return retstruc;
}

eingangs lokal mit Werten initialisieren, dann kannst du sie als Struktur an andere Funktionen über den Pointer weiterreichen.

Der allererste Aufruf müsste dann in main() erfolgen.
In main() müsste dazu nur stellvertretend eine lokale Variable

snd_pcm_t * soundKarte;

angelegt werden.

Dann wird hier per

init_soundKarte(soundKarte);

die Struktur "gefüllt",
und dann kann sie im Rest des Programms entsprechend weiter gereicht und benutzt werden, und so hat man sie per Parameter dort zur Verfügung.

z.B. auch in

bool UnInit(soundKarte)
{
  snd_pcm_close(soundKarte);
  return true;
}

und entsprechend an allen anderen Funktionen, wie z.B. auch als weiterer Parameter in Init().

Meintest du es so in etwa?


ps,
Ich sehe allerdings in deinem Code auch gar nicht die Stelle, wo soundKarte überhaupt erstmalig mit Werten "gefüllt" wird... :-/

[hirnfrei]

	if(name == NULL)
	{
		err = snd_pcm_open(&soundKarte, "plughw:1,0", SND_PCM_STREAM_PLAYBACK, 0);
	}

Hier wird die Soundkarte geöffnet und der Handler soundKarte initialisiert. Von da an geht es ja nur noch darum den Funktionen zu sagen mit welchem Handler sie zu arbeiten hat.

Ich hab auch glaub ich eine gute Lösung. Funktioniert zwar noch nicht, aber ich denke morgen knack ich das. Dann schau ich nach deiner Funktion ^^

PS:

Wenn ich mir meine Threads so ansehe, wie zwei scheinen uns gut zu verstehen ^^

[HaWe]

jap, denke ich auch ^^

übrigens:
ich hätte kein Problem mit einer globalen Variablen "soundCard", denn wenn man später alles in eine gesonderte Wrapper-lib verpackt (was mir ja eh am liebsten wäre)
<alsabrain.h> // brain ... hirn...du verstehst...
dann könnte man ja super drauf zugreifen, und sehen muss man sie auch nicht im eigentlichen Programm.
Der ganze alsa-overhead wäre dann raus aus dem eigentlichen Anwendungs-Programm.

[hirnfrei]

Sooooooo.

Das mit der globalen Variable habe ich nicht weg bekommen. Bleibt also erst einmal so. Aber jetzt schön in einer Header-Datei verwurstet. Hier ist der Code:

#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(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: Ü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 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;
}

Jetzt kannst du mit

playwave(Dateiname, Soundkarte);

zB:

playwave("/home/pi/Music/cantalow.wav", "plughw:1,0");

Ganz locker eine Wave abspielen.