wav Dateien: Programieren von Wiedergabe und Aufnahme

HaWe · 04.06.2016, 21:14

ja, das mit Stereo weiß ich, die Frage ist: alle in derselben int32 Zelle oder in 2 aufeinanderfolgenden?

aber das ist jetzt nicht mehr wichtig.

Wir wissen jetzt:
die Sound-Daten im Input-Array entsprechen ganz exakt den Micro-sound(wav)-Schwingungsdaten, die wir weiterverarbeiten können.

also speichern wir jetzt am besten input in einem wavbuffer (um input zu schonen):

int32_t wavbuffer[SHRT_MAX];
memcpy(wavbuffer, input, sizeof(input) );
for(int i=0; i<SHRT_MAX, ++i) wavbuffer[i] &= 0x00ff;

wav buffer müssen wir jetzt analysieren:

Bandbreite der Werte/Dynamik:
min-Wert=?
max-Wert=?

Code:

bis wo geht der Vorspann,
d.h. wo fängt das eigentliche Wort an,
und wo beginnt der Nachspann, d.h. wo hört das Wort auf.

dann:
wie groß ist die Schwingungsbreite (Dynamik) im Vor/Nachspann?
126-130? oder größer?

**hirnfrei** · 04.06.2016, 21:21

Warum ein neues Array anlegen? Können wir nicht das nutzen was wir schon haben?

min-Wert ist 0
max-Wert ist 255

Ja die Schwinungsbreite von vor und nach müsste so zwischen 120 und 132 liegen.

Wo nun vor und nachspann anfangen, wie ich das kläre weiss ich nicht.

HaWe · 04.06.2016, 21:43

Mist, der blöde Editor hat mich rausgeschmissen...

nein, ich will das Original behalten, zur Sicherheit, deshalb zusätzlicher wavbuffer.

max-Wert und Minwert htte ich grade gepostet, wurde aber von dem blöden editor gelöscht weil mich das Forum ausgeloggt hat. Abrer das kannst du selber....

- - - Aktualisiert - - -

hierfür eine Funktion mit Rückgabewert anlegen:

Code:

  maximum = wavbuffer[0];
  int32_t maxpos;
  for (i = 1; i < size; i++)
  {
    if (wavbuffer[i] > maximum)
    {
       maximum  = wavbuffer[i];
       maxpos= i+1;
    }
  }

Minimum analog

- - - Aktualisiert - - -

wir müssten für Vorspann und Nachspann wissen, ob wirklich immer einer existiert, oder ob alles der komplette aufgenommene Sound ist.
Nur wenn künftig überall Vor-oder Nachspann vorkommen, kann man das also analysieren und verwenden

- - - Aktualisiert - - -

wenn wir aufpassen, dass unsere Kommandos immer kürzer sind als die etwa 3 sec., kann man die Dynamik der letzten 100 Zellen verwenden (~10 ms):

minr = minimum der letzten 100 zellen (optimiert: ebenfalls zu heftige Spikes nach unten rausschneiden)
maxr = maximum der letzten 100 zellen (optimiert: ebenfalls zu heftige Spikes nach oben rausschneiden)

baseline = arithmet. Mittel der letzten 100 zellen (baseline)

bias = min(baseline-minr, maxr-baseline); // <=== Bandbreite um Mittelwert

- - - Aktualisiert - - -

wenn wir dann die Ober- und Untergrenzen des Grundrauschens kennen, können wir das bias abschneiden:

Code:

for(int i=0; i<SHRT_MAX; ++i) {
  if( (wavbuffer[i]>baseline ) && (wavbuffer[i]< baseline + bias)) wavbuffer[i] = baseline ; // kleine Schwankung => auf Baseline
  else
  if( (wavbuffer[i]<baseline ) && (wavbuffer[i]> baseline - bias)) wavbuffer[i] = baseline ; // kleine Schwankung => auf Baseline

oh mann, wenn wir doch nur IMMER codetags im Editor hätten....!

(ich hoffe, ich habe mich jetzt nicht verkalkuliert mit dem "Entrauschen"...)

**hirnfrei** · 04.06.2016, 21:48

Schneiden wir dann nicht auch diese Teile aus dem Wort raus?

Hier mal ein Update von der main

Code:

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

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

#include "diaSound.hpp"

bool debug = false;

void analyse(int32_t *waveBuffer)
{
	int32_t maximum = waveBuffer[0];
	int32_t minimum = waveBuffer[0];
	
	int32_t maxpos, minpos;
	
	int i;

	for(i=0;i<SHRT_MAX;i++)
	{
		if(waveBuffer[i] > maximum)
		{
			maximum = waveBuffer[i];
			
			maxpos = i + 1;
		}

		if(waveBuffer[i] < minimum)
		{
			minimum = waveBuffer[i];
			
			minpos = i + 1;
		}
	}
}

int main()
{
	fstream datei;
	
	int32_t input[SHRT_MAX], waveBuffer[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] & 0x00ff;;

		waveBuffer[SHRT_MAX] = input[i] & 0x00ff;

		if(debug) cout << i << " -> " << input[i] << endl;

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

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

HaWe · 04.06.2016, 22:23

wenn wir soweit sind, können wir probeweise dieses Veränderte Array einmal abspielen und horchen, wie es klingt...
dann gehts weiter...
(ich habe schon eine Idee)

kleine Optimierung für analyse():

Code:

void analyse(int32_t *waveBuffer)
{
	int32_t maximum = waveBuffer[0];
	int32_t minimum = waveBuffer[0];
	
	int32_t maxpos, minpos;
	
	uint32_t i; // falls man mal aus Versehen 1 zu weit zählt...

	for(i=0; i<SHRT_MAX; ++i)  {
		if(waveBuffer[i] > maximum) {
			maximum = waveBuffer[i];			
			maxpos = i ;  // genaue Zellen-Nummer
		}

		if(waveBuffer[i] < minimum) {
			minimum = waveBuffer[i];			
			minpos = i ;
		}
	}
}

heute abend kann ich selber nicht am Raspi programmieren, du könntest mir aber mal deinen input als zipfile hochladen, dann kann ich morgen mal dran arbeiten.

- - - Aktualisiert - - -

Schneiden wir dann nicht auch diese Teile aus dem Wort raus?

was sind das für Teile, die du meinst ?

und wofür braucht du noch wave und diese Zeilen...?

wave = (uint8_t *) malloc(SHRT_MAX+1);
wave[i] = input[i] & 0x00ff;;

**hirnfrei** · 04.06.2016, 22:54

wave ist für die Ausgabe. Hat eigentlich nur Kontrollfunktion ob im Gerät auch das ankommt was man rein geredet hat. Das kann im letztendlichen Code raus.

Was ist der Unterschied zwischen i++ und ++i?????

Und was genau soll ich hoch laden? Die Daten vom Mikro? Falls ja, dass ist das was in test.cvs drin steht.

- - - Aktualisiert - - -

Und mit Teile raus schneiden, wenn wir alles raus schneiden was die Werte von Vor- und Abspann hat dann schneiden wir das ja auch aus dem Wort heraus. Da kommen doch auch solche Werte drin vor.

- - - Aktualisiert - - -

Ah noch etwas. Was genau macht & 0x00ff?

HaWe · 05.06.2016, 10:45

erstmal: wie setzen nur die Bereiche auf Null, die innerhalb eines bestimmten Ausschlags von der Basislinie liegen.

im Abspann, bei den fiktiven Werten

Code:

128  129   125  130  127  131  126  128

wären:

baseline 128
maxr 131
minr 125
bias 3

(zur Ermittlung arbeite ich grade an eine optimierten Funktion, die auch singuläre Ausreißer-Spikes unberücksichtigt lässt! )(

das (laute) Wort davor soll mal haben

Code:

135  138  120  123  180  150  115  112

kurzer Vorspann (optional):

Code:

127  129  128  128

jetzt gucken wir uns den gesamten Scan an:
(Punkte zur Markierung der Bereiche)

Code:

127  129  128  128 . 135  138  120  123  180  150  115  112. 128  129  125  130  127  131 126  128

nun bereinigen wir den Scan, indem wir alle kleinen Ausschläge ( von der Baseline <= bias inkl.) auf baseline gesetzt werden, d.h. alle zwischen 125 und 131

Code:

128  128  128  128 . 135  138  120  123  180  150  115  112. 128  128  128  128  128  128  128  128

du siehst: jetzt ist das "Wort" in der Mitte scharf markiert.

Den Kram mit dem Bias abziehen vom gesamten Scan, wie gestern "angedacht",können wir uns evtl schenken, denn das macht wschl. die FFT für und automatisch wie ichs momentan sehe.

- - - Aktualisiert - - -

Ah noch etwas. Was genau macht & 0x00ff?

& 0x00ff
"anded" bitweise einen Int-Wert aus mehreren (hier: 4) Bytes und errechnet daraus den Wert des Lowbytes.
0x00ff ist die hex-Schreibweise von 255, wo die 8 kleinen bits auf 1 und alle höheren bits Null sind.

das heisst:
7 & 0x00ff ergibt 7 // nur das lowByte enthält Werte
127 & 0x00ff ergibt 127 // dto...
255 & 0x00ff ergibt 255
256 & 0x00ff ergibt 1 // 2.-unterstes Byte enthält Stör-Wert, der wird herausmaskiert, nur Lowbyte bleibt übrig.
262 & 0x00ff ergibt 7 // dto...
382 & 0x00ff ergibt 127
511 & 0x00ff ergibt 255 .
1024 & 0x00ff ergibt 1
32768 & 0x00ff ergibt 1 // 3.-unterstes Byte enthält Stör-Wert, der wird herausmaskiert, nur Lowbyte bleibt übrig.

Der Sinn war: alle int-Werte, die sonst noch als unnütze Bytes in den 4-Byte-int32_t array-zellen auftauchen sollten, zu nullen (z. B. Steuer-Bytes / Begrenzer oder der Wert einer 2. Spur), damit nur das kleinste Byte übrig bleibt, wenn das wirklich die echte Micro-Mono-Spur enthält.
So wie es momentan aussieht, sind allerdings keine weiteren Stör-Bytes drinnen, aber das werden wir noch austesten.

Was ist der Unterschied zwischen i++ und ++i?????

++i ist das pre-increment, das führt das Increment sofort aus und steht für i=i+1.
i++ ist das post-increment, das führt das Increment erst aus, nachdem weitere Kommandos in der selben Kommando-Zeile bereits ausgeführt worden sind.

++i ist in diesem speziellen Falle zwar identisch mit i++,
aber ++i ist das logisch richtigere, denn i++ kann möglicherweise immer "side effects" haben.

Siehe die Erklärung hier:
http://www.embedded.com/design/progr...rement-in-C-C-

HaWe · 05.06.2016, 14:03

so, ich habe mal auf nem Arduino die Rauschglättung simuliert (geht dort einfacher mit Grafik etc):

Simulations-Code (automatische Erkennung der Rauschbandbreite) :

Code:

// ver 0005

void arrayinit(int16_t * array, int16_t arrlen) {
  char     sbuf[128];
  int16_t  bias, minr, maxr, baseline;


  // simulated noisy word-command or signal
  for (int i=0; i<arrlen; ++i) {    
    array[i] = 128 + random(10)- 5;  // simulated noise  +/- 5;      
  }
  for (int i=33; i<arrlen-101; ++i) {  // simulated word/signal +/- 100
    array[i] = 128 + random(200) - 100;      
  }

  curlf();
  sprintf(sbuf, "arrayinit[0] vorher %d ", array[0] );  
  Serial.println(sbuf);
  lcdprint(sbuf);
  
  

  // calculate baseline from last 100 array cells:

  //init
  baseline=array[arrlen-90];
  minr=array[arrlen-90]-1;
  maxr=array[arrlen-90]+1;
  
  // auto-adjust:  
  for (int i=arrlen-100; i<arrlen; ++i) {    
    // mean baseline
    baseline = round ( ( 0.5*(float)array[i]  + 0.5*(float)baseline )) ;

    // smoothed out max noise
    if (array[i] >= baseline) maxr = round ( ( 0.8*(float)array[i]  + 0.2*(float)maxr )) ;

    // smoothed out min noise
    if (array[i] <= baseline) minr = round ( ( 0.8*(float)array[i]  + 0.2*(float)minr ))  ;       
  }
 
  bias =  max(baseline-minr-2, maxr+2-baseline)  ;  // 
  
  curlf();
  sprintf(sbuf, "baseline %d ", baseline );  
  Serial.println(sbuf);
  lcdprint(sbuf);

  curlf();
  sprintf(sbuf, "bias %d ", bias );  
  Serial.println(sbuf);
  lcdprint(sbuf);


  // mit /ohne Rauschglättung (auskommentieren)
 
  for (int i=0; i<arrlen; ++i) {
     if( (array[i]>baseline ) && (array[i] <= baseline + bias)) array[i] = baseline ; // little higher value => drop to baseline
     else
     if( (array[i]<baseline ) && (array[i] >= baseline - bias)) array[i] = baseline ; // little lower value => rise to baseline
  }
  
  
  
  curlf();
  sprintf(sbuf, "arrayinit[0] nachher %d ", array[0] );  
  lcdprint(sbuf);
  Serial.println(sbuf);
 

}

klappt!

leider ist das Bildhochladen hier im Forum extremst kompliziert und vom Speicherplatz zu eingeschränkt,
ich habe es daher hier zum direkten Vergleich hochgeladen:

http://www.mindstormsforum.de/viewto...p=69409#p69409

- - - Aktualisiert - - -

deine lib habe ich jetzt noch etwas in ifndef eingekapselt, um doppeltes Linken zu vermeiden:

Code:

#ifndef __DIASOUND_HPP__
#define __DIASOUND_HPP__



/// dein diaSound-lib Code



#endif

**hirnfrei** · 05.06.2016, 16:10

Was ist denn das für ein Display wo du da am Arduino hängen hast?

Ich merke immer wieder, dass seit ich C gelernt habe sich doch einiges weiter entwickelt hat. Oder es liegt daran das ich erst seit nem halben Jahr mit C++ arbeite.

Danke für deine Erklärungen. Hab ich bisher so noch nie gebraucht und auch i++ hat bisher noch nie Schwierigkeiten gemacht, aber man lernt ja nie aus!

Was dein Simulationscode angeht, sobald ich mein Gentoo auf systemd umgestellt habe bastel ich da gerne was in den Code rein.

ich nehme an es geht in der Hauptsache um diesen Teil

Code:

  // calculate baselind from last 100 arraay cells:

  //init
  baseline=array[arrlen-50];
  minr=array[arrlen-50]-1;
  maxr=array[arrlen-50]+1;
  
  // auto-adjust:  
  for (int i=arrlen-100; i<arrlen; ++i) {    
    // mean baseline
    baseline = round ( ( 0.7*(float)array[i]  + 0.3*(float)baseline ) ) +1;

    // smoothed out max noise
    if (array[i] >= baseline) maxr = round ( ( 0.7*(float)array[i]  + 0.3*(float)maxr ) ) +1;

    // smoothed out min noise
    if (array[i] <= baseline) minr = round ( ( 0.7*(float)array[i]  + 0.3*(float)minr ) ) -1;   
    
  }
 
  bias = max (baseline-minr, maxr-baseline);  // 

  // mit /ohne Rauschglättung (auskommentieren)
 
  for (int i=0; i<arrlen; ++i) {
     if( (array[i]>baseline ) && (array[i] <= baseline + bias)) array[i] = baseline ; // kleine Schwankung => auf Baseline
     else
     if( (array[i]<baseline ) && (array[i] >= baseline - bias)) array[i] = baseline ; // kleine Schwankung => auf Baseline
  }

HaWe · 05.06.2016, 16:54

hallo,

ja, genau, das ist der Teil mit dem Rauschen wegschneiden. Inzwischen ist der Code schon wieder ein wenig optimiert...

was C angeht: da hat sich bei ANSI C gar nicht so viel verändert, eher schon C++11 und C++14, aber ich selber programmiere nur in ANSI C99 (und nutze die C++ libs ntl, soweit verfügbar).

C/C++ sind aber derart mächtig, dass man sicher immer wieder noch mal was neues entdeckt, egal wie lange man schon dabei ist ...

das Arduino-Display ist dieses hier:
http://www.mindstormsforum.de/viewto...p=68170#p68170

- - - Aktualisiert - - -

wenn du die Wav-Rausch-Entfernung vorher/nachher gemacht hast, dann spiele doch bitte mal diesen veränderten Array als wav-File ab (PlayCaptured).
Das Rauschen im "Wortsignal" ist ja noch nicht verändert, aber vorher/hinterher müsste man einen Unterschied hören!