wav Dateien: Programieren von Wiedergabe und Aufnahme

**hirnfrei** · 04.06.2016, 17:47

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?

HaWe · 04.06.2016, 17:57

ok, jetzt muss ich mir ein Bild von den wav-audio-Daten machen.
in welchem array stehen jetzt die wav-Roh-Daten, die du vom Micro aufgenommen hast, und die jetzt weiterverarbeitet werden sollen?

ist es

in32_t input[SHRT_MAX]

und enthält er noch beide Spuren (li+re) ?

**hirnfrei** · 04.06.2016, 18:11

Richtig.

input32_t input[SHRT_MAX];

ist das was vom Mikro kommt. Direkt in diese Variable. Also da wird nicht erst noch was konvertiert oder so.

Und zu besseren Verständnis, wie die audioCapture() funktioniert hier ne kleine Erklärung:

Code:

audioCapture(input, SHRT_MAX, "plughw:1,0", 1, 12000, 8);

audoCapture("Variable zum Speichern der Daten", "Aufzeichnungslänge", "Soundkarte", "Kanäle", "Frequenz", "Bit");

Ich jammere rum weil tinyalsa keine gute Dokumentation hat und biete dann für meine Funktion ebenfalls keine Erklärung. Tztztztz.

Wie du siehst, ich nehme nur mit einem Kanal auf.

Okay, habe versucht eine CSV hoch zu laden, hat natürlich nicht geklappt

. Versuch es mal hier http://www.kipperei.de/test.csv

HaWe · 04.06.2016, 18:19

ok, hab ich mir angeschaut.
Es sind jetzt alles Zahlen in Byte-Größe.

Betrachten wir jetzt mal diesen Array input, N == SHRTR_MAX Zellen mit jeweils 4 Bytes:

Code:

|----,----,----,----,----,----,----,----,----,----,---- .... ----,----,----,----,----,----,----,----,----,----,----|
  0     1    2    3    4    5    6    7    8    9   10  ....                                                   N=SHRT-MAX-1

wie ist jetzt jede 4er-Bytes-Gruppe aufgebaut?

**hirnfrei** · 04.06.2016, 18:27

Wie meinst du das?

Normalerweise 3 Zeichen und ein Terminationszeichen.

HaWe · 04.06.2016, 18:30

was für zeichen an welcher Array-Stelle?
Wir brauchen lowByte und HighByte des Ton-Peaks, oder etwas, was wir dazu umwandeln können

oder hast du in 8 bit gesampelt?

dann brauchen wir die byte-Nr-Stelle, wo dieses 8bit-Tonsignal steht.
Immer im LowByte des int32-Zellenwertes?