Author: solocan (page 4 of 8)

Digitales Tiefpass-Kammfilter

27. November 2019 / solocan / Noch kein Kommentar

Das Kammfilter ist ein Frequenzfilter, das das verzögerte Signal zum nichtverzögerten Signal mischt und dadurch bestimmte Frequenzen auslöscht. (Kammeffekt). Im Grunde ist das Kammfilter eine Verzögerungslinie mit Rückkopplung.

Die diskrete Übertragungsfunktion H(z) eines Feedback-Kammfilters M-ter Ordnung kann als

(1) $\begin{equation*} H(z)=\frac{z^{-M}}{1-G_{FB}z^{-M}} \end{equation*}$

beschrieben werden.

Kammfilter mit Tiefpass

Man kann die Rückkopplung nur auf bestimmte Frequenzen begrenzen, in dem man ein Frequenzfilter in die Rückkopplungsbahn einbaut. Das ist für Reverb-Implementierung wichtig, da in der Realität die Schallenergie der höheren Frequenzen schneller abgedämpft wird. Um dies nachzubilden, kann ein Tiefpassfilter erster Ordnung eingebaut werden:

(2) $\begin{equation*} H_{LP}(z)=\frac{1-d}{1-d z^{-1}} \end{equation*}$

oder noch einfacher eine Glättung:

(3) $\begin{equation*} H_{LP}(z)=\frac{1}{1-d z^{-1}} \end{equation*}$

Wird dies in die Rückkopplungsbahn integriert, sieht es folgendermaßen aus:

Hierbei wurden zwei Dämpfungskoeffizienten $d_1$ und $d_2$ hinzugefügt.

Implementierung

Die Implementierung des Kammfilters mit Tiefpass ist im Folgenden gezeigt:

/*
Main process comb filter with low pass
*/
float c_comb::process(float x){

	float y;

	y = buffer[cptr];

	filterstore = (y*damp2) + (filterstore*damp1);

	buffer[cptr] = x + (filterstore*feedback);

	if(++cptr>=bufsize) cptr = 0;

	return y;
}

Main process comb filter with low pass

float c_comb::process(float x){

float y;

y = buffer[cptr];

filterstore = (y*damp2) + (filterstore*damp1);

buffer[cptr] = x + (filterstore*feedback);

if(++cptr>=bufsize) cptr = 0;

return y;

}

Digitales Allpassfilter höherer Ordnung

27. November 2019 / solocan / Noch kein Kommentar

Das Allpassfilter ist ein Frequenzfilter, das alle Frequenzen durchlässt und nur ihre Phasen verschiebt. Diese Phasenverschiebung kann man sich als Verzögerung (Delay) vorstellen.

Die diskrete Übertragungsfunktion H(z) eines Allpassfilters M-ter Ordnung kann als

(1) $\begin{equation*} H(z)=\frac{z^{-M}-G_{FB}}{1-G_{FB}z^{-M}} \end{equation*}$

beschrieben werden, wobei $G_{FB}$ komplex konjugierte Pol-Nullstelle ist. Zieht man das $z^{-M}$ heraus, erhält man

(2) $\begin{equation*} y(n) = z^{-M} [x(n)+y(n) G_{FB} ]-x(n) G_{FB}} \end{equation*}$

Das ist im folgenden Regelkreis veranschaulicht.

Implementierung

Die Implementierung des Allpassfilters ist im Folgenden gezeigt:

/*
Main process alpass
*/
float c_allpass::process(float x){

	float y;
	y=buffer[aptr]-feedback*x;
	buffer[aptr]=y*feedback+x;
/*
//Original implementation of Freeverb is not consistent
	float bufout;
 	y = -x + bufout;
 	buffer[aptr] = x + (bufout*feedback);
*/

	if(++aptr>=bufsize) aptr = 0;

	return y;
}

Main process alpass

float c_allpass::process(float x){

float y;

y=buffer[aptr]-feedback*x;

buffer[aptr]=y*feedback+x;

//Original implementation of Freeverb is not consistent

float bufout;

y = -x + bufout;

buffer[aptr] = x + (bufout*feedback);

if(++aptr>=bufsize) aptr = 0;

return y;

}

Im Freeverb ist eine Kombination aus Feedforward- und feedback-Kammfilter implementiert als eine Allpassfilter-Approximation. Diese wird oben auskommentiert gezeigt.

Digitaler Reverb (Hall)-Effekt

27. November 2019 / solocan / Noch kein Kommentar

Das Reverb (- oder Hall) ist ein Effekt, der die Schallreflektionen und dadurch die Umgebungscharakteristika abbildet. Es gibt grundsätzlich zwei Kategorien der Hall-Implementierungen.

Faltungshall (engl. convolution reverb)
Algorithmischer Hall (engl. algorithmic reverb)

Faltungshall

Die Theorie ist einfach: Hierbei wird die Impulsantwort eines realen Raums aufgenommen. Dann wurde diese Impulsantwort auf jeden(!) Sample angewendet. Wenn man bedenkt, dass so eine Impulsantwort für größere Räume mehrere Sekunden lang ist, bedeutet das, dass man für jeden Sample tausende von Folgesamples berechnen muss, speichern muss und diese dann irgendwie miteinander addieren muss. Wenn man es also ganz simpel auf der Zeitebene betreibt, ist es quasi eine Aufgabe der Unmöglichkeit. Selbst die schnellsten Desktop-Prozesoren kommen da an ihre Grenzen alleine für diese Aufgabe.

Das ganze man aber auf der Frequenzebene berechnen! Dieser Prozess der Impulsapplikation kann mit Hilfe der Faltungsoperation erledigt werden. Man faltet die Impulsantwort quasi auf die Samplereihe. Nichtsdestotrotz: Dafür muss das Signal auf die Frequenzebene (in halbwegs akzeptabler Qualität) transformiert werden, dort daraus der Hall berechnet und zurück auf die Zeitebene transformiert werden. Auch diese Operationen ist bei vielen DSPs nicht drin, (die üblicherweise auch Luft haben müssen, was anderes als Reverb zu berechnen).

Da früher die Rechenleistung der DSPs viel niedriger waren, sind algorithmische Reverbs entstanden.

Algorithmischer Hall

Algorithmische Halls sind Effekte, die einen imaginären Raumeffekt mit verschiedenen Algorithmen abbilden. Diese Algorithmen müssen -im Gegensatz zum Convolution reverb- keinen Bezug zur Realität haben. Sie sollen den Effekt eben nur nachmachen. Es gibt unzählige Algorithmen in der Reverbgeschichte von jedem Hersteller, die aber oft auf Grundelemente zurückgreifen. Diese sind:

Viele algorithmische Reverbs basieren auf empirische Ansätze anstatt analytische. D.h. oft sind die Parameter und Designs als ein Kompromiss zwischen Effektqualität und Recheneffizienz entstanden. Die Ermittlung der Parameter (und Designs) basieren auf Hörerlebnissen und Wahrnehmung des Halleffekts.

Denn der Halleffekt ist strenggenommen auch theoretisch nichts anderes als eine Summe der unendlichen Reflektionen – also Delays. Diese nehmen wir nur hierbei nicht einzeln wahr sondern eben als deren Gesamtheit – als Halleffekt.

Das heißt, es macht unserem Ohr keinen Unterschied, auf welche Mikrosekunde genau eine Reflektion ankommt. Vielmehr ist ein gesamtes Klangbild entscheidend. Deshalb erzielt man diese Reflektionen mit Hilfe der parallel geschaltete Kammfilter (Im Prinzip Delay lines) und reihengeschaltete Allpassfilter. Mit Hilfe dieser Filter werden Reflektionen in Schleife vermehrt und gedämpft. Das schwierigste dabei ist die Bestimmung der Parameter, sodass keine unerwünschte Effekte auftreten bzw. das Klangbild soweit wie möglich unseren Vorstellungen passt.

Parameter

Folgende Kontrollparameter sind für Halleffekte üblich:

Raumgröße

Einstellung der Raumgröße beeinflußt die Rückkopplung der Kamm- und Allpassfilter. Je größer die Rückkopplung, desto langsamer klingt eine Reflektion ab und das erweckt den Eindruck eines größeren Raums

Dry/Wet

Wieviel Effektanteil ins Ausgangssignal gemischt werden soll.

Dämpfung

Mit dem Dämpfungsparameter wird die Dämpfung der Kammfilter kontrolliert. Je größer die Dämpfung, desto steiler klingen die Reflektionen ab.

Frequenzfilter

Mit Frequenzfiltern , üblicherweise mit Hochpass und Tiefpass, wird die Klangcharakteristik des Halls beeinflusst.

Pre-Delay

Der Mensch kann die ersten Reflektionen eines Raums wahrnehmen, weil die noch sauber und einzeln hörbar sind. Deshalb kann man ein paar Delay-Linien mit kleineren Verzögerungen einbauen, um den Effekt realistischer zu machen.

Freeverb Reverb-Algorithmus

Soweit die Einführung zur Reverb-Algorithmik. Ein freier und beliebter Algorithmus ist der Freeverb-Algorithmus. Dieser basiert auf alter Schröder-Algorithmus. Dieser verwendet acht Kammfilter parallel und anschließend vier Allpassfilter in Reihe.

Die empirisch ermittelten Delay-Zeiten Kammfiltern und Allpassfiltern sind folgende (angegeben in Sampleanzahl für 44.1kHz ):

Kammfilter 1: 1116
Kammfilter 2: 1188
Kammfilter 3: 1277
Kammfilter 4: 1356
Kammfilter 5: 1422
Kammfilter 6: 1491
Kammfilter 7: 1557
Kammfilter 8: 1617
Allpassfilter 1: 556
Allpassfilter 2: 441
Allpassfilter 3: 341
Allpassfilter 4: 225

Implementierung

Die Implementierung des Reverbs an sich ist unkompliziert, da die eigentliche Signalverarbeitung in Kammfiltern und Allpassfiltern passiert. Hier passiert die Summierung und Routing der einzelnen Signale. Das Beispiel bezieht sich auf ein Mono-Kanal. Man kann es auf Stereo erweitern, wie im originalen Freeverb Effekt. Dafür werden beide Kanäle vorsummiert und auf beide Effektkanäle geschickt.

/*
Main process reverb
*/
float c_reverb::process(float x){

	float y;
	y=0;

	//Feed the parallel comb filters
	unsigned i;
	for(i=0;i<n_comb;i++){
		y+=comb[i].process(x);
	}

	//Pass through the serial allpass filters
	for(i=0;i<n_allpass;i++){
		y=allpass[i].process(y);
	}

	//Attenuate output and mix wet& dry
	y=y*fixedgain*wetmix+x*drymix;

	return y;
}

Main process reverb

float c_reverb::process(float x){

float y;

y=0;

//Feed the parallel comb filters

unsigned i;

for(i=0;i<n_comb;i++){

y+=comb[i].process(x);

}

//Pass through the serial allpass filters

for(i=0;i<n_allpass;i++){

y=allpass[i].process(y);

}

//Attenuate output and mix wet& dry

y=y*fixedgain*wetmix+x*drymix;

return y;

}

Die Steuerung der Parameter Raumgröße, Dämpfung und Dry/Wet ist folgendermaßen implementiert.

void c_reverb::set_wet(float* w){

	//Update the dry&wet mix
	wetmix=*w*0.01;
	drymix=1-wetmix;

}

void c_reverb::set_size(float* s){

	//Scale and set feedback parameter
	float feedback;

	feedback=(*s*0.01*scaleroom) + offsetroom;

	//Update the parameter of comb filters (Pointer on 2nd element: Roomsize)
	unsigned i;
	for(i=0;i<n_comb;i++){
		comb[i].set_feedback(&feedback);
	}

	//Update the parameter of allpass filters (Pointer on 2nd element: Roomsize)
	for(i=0;i<n_allpass;i++){
		allpass[i].set_feedback(&feedback);
	}

}

void c_reverb::set_damp(float* d){

	//Scale and set damp
	float damp=*d*0.01*scaledamp;

	//Update the parameter of comb filters (Pointer on 2nd element: Roomsize)
	unsigned i;
	for(i=0;i<n_comb;i++){
		comb[i].set_damp(&damp);
	}

}

void c_reverb::set_wet(float* w){

//Update the dry&wet mix

wetmix=*w*0.01;

drymix=1-wetmix;

}

void c_reverb::set_size(float* s){

//Scale and set feedback parameter

float feedback;

feedback=(*s*0.01*scaleroom) + offsetroom;

//Update the parameter of comb filters (Pointer on 2nd element: Roomsize)

unsigned i;

for(i=0;i<n_comb;i++){

comb[i].set_feedback(&feedback);

}

//Update the parameter of allpass filters (Pointer on 2nd element: Roomsize)

for(i=0;i<n_allpass;i++){

allpass[i].set_feedback(&feedback);

}

void c_reverb::set_damp(float* d){

//Scale and set damp

float damp=*d*0.01*scaledamp;

//Update the parameter of comb filters (Pointer on 2nd element: Roomsize)

unsigned i;

for(i=0;i<n_comb;i++){

comb[i].set_damp(&damp);

}

Die empirisch ermittelten Parameter sind im Quellcode verfügbar.

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre Rythmus - Reverb - Wet: 60 - Size: 80 -Damping: 40

Gitarre Rythmus - Reverb - Wet: 60 - Size: 80 -Damping: 100

Gitarre Rythmus - Reverb - Wet: 60 - Size: 20 -Damping: 40

Gitarre Rythmus - Reverb - Wet: 60 - Size: 100 -Damping: 0

Gitarre Rythmus - Reverb - Wet: 60 - Size: 80 -Damping: 10

Digitaler Wah-Wah-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Der Wah-Wah-Effekt ist ein Filtereffekt, der die hohen Frequenzen im Signal herausfiltert (Tiefpass) oder abschwächt (Shelving Filter). Die Filterung wird

mit einem Wahwah-Pedal (Standard-Wahwah Effekt) oder
mit einem LFO (AutoWah)

kontrolliert. Im Fall vom WahWah-Pedal wird die Pedalposition genutzt, um die Frequenz des Tiefpassfilters zu ermitteln. Im Fall vom Auto Wah wird die Frequenz aus dem LFO abgeleitet.

Im folgenden ist das Grundprinzip des Wah-Wah-Effekts aufgezeigt.

Parameter

Folgende Kontrollparameter sind für einen Wah-Wah-Effekt üblich:

Source

Hier wird gewählt, ob die Steuerung mit LFO (Auto Wah) oder mit einem Expression-Pedal erfolgen soll.

Tiefe (Depth)

Mit diesem Parameter kontrolliert man die negative Verstärkung des Filters, im Falle eines Kuhschwanzfilters. (Shelving Filter) Hiermit wählt man, ob man einen milden oder starken Effekt haben möchte.

Breite (Width)

Mit diesem Parameter wählt man die Frequenzschranken der Filterung. Üblicherweise sind diese zwischen 500Hz und 4000Hz. Je breiter der Effekt, desto größer das Intervall.

Implementierung

LFO

LFO steuert das Tiefpassfilter. Nach jeder Änderung werden die Parameter des Tiefpassfilters aktualisiert.

float c_autowah::lfo(void){

	float y_lfo;

	//Calculate LFO value
	y_lfo=sin(a_lfo);

	//Update angle
	a_lfo+=a_step;
	if(a_lfo>=2*PI){
		a_lfo=a_lfo-2*PI;
	}

	return y_lfo;
}

void c_autowah::update_wah_frequency(void){

	float sin_x;

	sin_x=lfo();

	if(i_update>=n_update_reset){
		//Update filter frequency
		frequency=freq_low+(sin_x+1)*freq_scaler;
		wahfilter.set_freq(frequency);
		i_update=0;
	}else{
		i_update++;
	}
}

float c_autowah::lfo(void){

float y_lfo;

//Calculate LFO value

y_lfo=sin(a_lfo);

//Update angle

a_lfo+=a_step;

if(a_lfo>=2*PI){

a_lfo=a_lfo-2*PI;

}

return y_lfo;

}

void c_autowah::update_wah_frequency(void){

float sin_x;

sin_x=lfo();

if(i_update>=n_update_reset){

//Update filter frequency

frequency=freq_low+(sin_x+1)*freq_scaler;

wahfilter.set_freq(frequency);

i_update=0;

}else{

i_update++;

}

Hauptroutine

Der Wah-Wah-Hauptalgorithmus ist dann einfach ein LP-Filter. (In dem Fall als Biquad-Filter implementiert)

/*
Wah wah main routine
*/
float c_autowah::process(float x){

	update_wah_frequency();
	return wahfilter.process(input_gain*x);
}

Wah wah main routine

float c_autowah::process(float x){

update_wah_frequency();

return wahfilter.process(input_gain*x);

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre Rythmus - Autowah Depth 50 - Rate 1.25Hz

Gitarre Rythmus - Autowah Depth 90 - Rate 2.5Hz

Gitarre Rythmus - Autowah Depth 90 - Rate 1.25Hz

Gitarre Rythmus - Autowah Depth 90 - Rate 2.5Hz

Digitaler Tremolo-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Ein Tremolo-Effekt ändert zyklisch die Lautstärke eines Signals. Es wird je nach Parametrierung zum Erzeugen von „Country“-Sounds oder aber auch in starker Ausführung für spezielle Effekte wie „Boulevard of broken dreams“-Intro von Green day.

Im folgenden ist das Grundprinzip des Tremolo-Effekts aufgezeigt.

Parameter

Folgende Kontrollparameter für den Tremolo-Effekt sind üblich:

Frequenz

Mit der Frequenz kontrolliert man die Geschwindigkeit der Verstärkungsmodulation. Üblicherweise in Hertz. Typische Werte zwischen 1Hz und 25Hz.

Tiefe (Depth)

Mit diesem Parameter kontrolliert man die Wirksamkeit der Modulation. Üblicherweise in [%] angegeben. Bei 30% wird die Lautstärke zwischen 70% und 100% gesteuert. Bei 100% wird die Lautstärke zwischen 0 und 100% gesteuert (Also dabei teilweise ganz stummgeschaltet.)

LFO Typ

Damit wird der Typ des LFO-Signals gewählt. Übliche Signale sind:

Sinussignal
Dreiecksignal
Sägezahnsignal
Rechtecksignal

Modulation mit LFO

Während sonstige Tonhöhenmodulationseffekte wie Chorus, Flanger, Rotary mit einem Sinus-Signal kontrolliert wird, sind für den Tremolo-Effekt auch andere Signalquellen üblich. Die effiziente Implementierung dieser Signalgeneratoren sind unten gezeigt.

Implementierung

LFO

/*
LFO
*/
float c_tremolo::lfo(void){

	float y_lfo;

	//Calculate LFO value

	switch(type){
	//Sinus
	case 0:
		y_lfo=0.5*(1+sin(i_lfo));
		//Update angle
		i_lfo+=a_step;
		if(i_lfo>=2*PI){
			i_lfo-=2*PI;
		}
		break;

	//Triangle
	case 1:

		y_lfo = fabs(fmod(i_lfo, 2) -1 );
		i_lfo+=t_step;

		break;
	case 2:		//Square
		y_lfo=fmod(i_lfo,2) < 1 ? 1 : 0;
		i_lfo+=t_step;
		break;

	}

//	printf("%.3f\n",y_lfo);

	return y_lfo;
}

/*
Calculate the gain
*/
float c_tremolo::get_current_attenuation(void){

	return 1-depth*lfo();

}

LFO

float c_tremolo::lfo(void){

float y_lfo;

//Calculate LFO value

switch(type){

//Sinus

case 0:

y_lfo=0.5*(1+sin(i_lfo));

//Update angle

i_lfo+=a_step;

if(i_lfo>=2*PI){

i_lfo-=2*PI;

}

break;

//Triangle

case 1:

y_lfo = fabs(fmod(i_lfo, 2) -1 );

i_lfo+=t_step;

break;

case 2: //Square

y_lfo=fmod(i_lfo,2) < 1 ? 1 : 0;

i_lfo+=t_step;

break;

}

// printf("%.3f\n",y_lfo);

return y_lfo;

}

Calculate the gain

float c_tremolo::get_current_attenuation(void){

return 1-depth*lfo();

}

Hauptroutine

Der Algorithmus vom Rotary-Effekt ist vergleichbar mit einem Chorus-Algorithmus ohne Signalkopie und Trockensignal / Effektsignal-Mischung.

float c_tremolo::process(float x){

	return x*get_current_attenuation();
}

float c_tremolo::process(float x){

return x*get_current_attenuation();

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Tremolo Sinus: Depth: 50 - Frequency: 6Hz

Gitarre - Tremolo Dreieck: Depth: 75 - Frequency: 20Hz

Gitarre - Tremolo Rechteck: Depth: 50 - Frequency: 10Hz

Digitaler Rotary-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Ein Rotary-Effekt ist ein Modulationseffekt, der die Frequenz bzw. die Tonhöhe (Pitch) des Eingangssignals mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Somit entsteht eine Rotary bzw. je nach Parametrierung ein Vibrato-artiger Effekt.

Er ist sehr ähnlich zum Chorus-Effekt mit dem Unterschied, dass hierbei das Signal nicht kopiert wird sondern das trockene Signal verarbeitet wird: Ohne Kopieren und zurückmischen. Daher resultiert hierbei kein Phasenauslöschungseffekt.

Im folgenden ist das Grundprinzip des Rotary-Effekts aufgezeigt.

Parameter

Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:

Frequenz

Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.

Tiefe (Depth)

Mit diesem Parameter kontrolliert man die Wirksamkeit der Modulation. Sie wird in Prozent oder in Millisekunden (Delay-Zeit) angegeben. Wenn z.B. die Basis-Delayzeit 25ms ist und die Tiefe 50%, dann bedeutet das, dass das Delay zwischen 12,5ms und 37,5ms moduliert wird.

Modulation mit LFO

Ein LFO ist nichts anderes als ein Signalgenerator, der in der Regel ein niederfrequentes Sinus-Signal generiert. Diese Signalquelle nutzt man u. a. zur Modulation eines Signals.

Im Fall eines Rotary-Effekts moduliert man „die Abtastfrequenz“. Konkret tut man das, in dem man die Delay-Zeit kontinuierlich erhöht und reduziert. Diese Delay-Zeit ist in der Regel sehr kurz und liegt im Fall von Chorus in der Regel 5-50ms. Man nimmt eine Referenzdelayzeit. Z.b. 20ms und moduliert diese mit LFO zwischen 10ms und 30ms. Dadurch verlangsamt und beschleunigt das Signal und es entsteht eine Frequenzverschiebung.

Implementierung

LFO

Für das Rotary-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird.

/*
LFO
*/
float c_rotary::lfo(void){

	float y_lfo;

	//Calculate LFO value
	y_lfo=sin(a_lfo);

	//Update angle
	a_lfo+=a_step;
	if(a_lfo>=2*PI){
		a_lfo=a_lfo-2*PI;
	}

	return y_lfo;
}

/*
Calculate rotating delay
*/
float c_rotary::get_current_delay(void){

	//Calculate time
	float t;
	t=d_base+depth*lfo();

	//Return the delay time
	return t;

}

LFO

float c_rotary::lfo(void){

float y_lfo;

//Calculate LFO value

y_lfo=sin(a_lfo);

//Update angle

a_lfo+=a_step;

if(a_lfo>=2*PI){

a_lfo=a_lfo-2*PI;

}

return y_lfo;

}

Calculate rotating delay

float c_rotary::get_current_delay(void){

//Calculate time

float t;

t=d_base+depth*lfo();

//Return the delay time

return t;

}

Hauptroutine

Der Algorithmus vom Rotary-Effekt ist vergleichbar mit einem Chorus-Algorithmus ohne Signalkopie und Trockensignal / Effektsignal-Mischung.

/*
Rotary main routine
*/
float c_rotary::process(float x){

	float y;
	float t_c;	//Current delay

	//Get current delay
	t_c=get_current_delay(); //Delay time

	//Calculate the position of the pointer
	int wptr;

	wptr=rptr-rint(t_c*FSms);

	if(wptr<0){
		wptr+=rotary_len;
	}

	//Calculate output
	y=rbuf[wptr];

	//Update the buffer
	rbuf[rptr]=x;

	//Increment
	rptr++;
	if(rptr>=rotary_len){
		rptr-=rotary_len;
	}

	return y;
}

Rotary main routine

float c_rotary::process(float x){

float y;

float t_c; //Current delay

//Get current delay

t_c=get_current_delay(); //Delay time

//Calculate the position of the pointer

int wptr;

wptr=rptr-rint(t_c*FSms);

if(wptr<0){

wptr+=rotary_len;

}

//Calculate output

y=rbuf[wptr];

//Update the buffer

rbuf[rptr]=x;

//Increment

rptr++;

if(rptr>=rotary_len){

rptr-=rotary_len;

}

return y;

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre Rythmus - Rotary Depth:100 - Freq:2Hz

Gitarre Rythmus - Rotary Depth:100 - Freq:5Hz

Gitarre Rythmus - Rotary Depth:50 - Freq:10Hz

Digitaler Flanger-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Ein Flangereffekt ist ein Modulationseffekt, der das Eingangssignal kopiert und dessen Tonhöhe (Pitch) mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Der Unterschied zum Chorus-Effekt besteht darin, dass auf der Effektlinie eine Rückkopplung gibt. Da die Verzögerung im Bereich von paar Millisekunden liegt, resultieren daraus Phasenlöschungseffekte. Das gibt dem Flanger seinen charakteristischen Space-Sound.

Eine andere Eigenheit vom Flanger ist, dass hierbei üblicherweise auch das trockene Signal verzögert werden muss, um eine starke Phasenauslöschung und einen drehend empfundenen Sound zu erzielen.

Im folgenden ist das Grundprinzip eines Flangers aufgezeigt.

Parameter

Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:

Frequenz

Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.

Tiefe (Depth)

Pre-Delay

Die Verzögerung des trockenen Signals. Dies kann parametriert werden, um die Stärke und Charakteristik des Phasenauslöschungseffektes einzustellen.

Wet/Dry

Hiermit wird kontrolliert, wie stark das modulierte Signal ins Ausgangssignal beigemischt werden soll.

Modulation mit LFO

Ein LFO ist nichts anderes als ein Signalgenerator, der in der Regel ein niederfrequentes Sinus-Signal generiert. Diese Signalquelle nutzt man u. a. zur Modulation eines Signals.

Im Fall eines Chorus moduliert man „die Abtastfrequenz“. Konkret tut man das, in dem man die Delay-Zeit kontinuierlich erhöht und reduziert. Diese Delay-Zeit ist in der Regel sehr kurz und liegt im Fall von Chorus in der Regel 5-50ms. Man nimmt eine Referenzdelayzeit. Z.b. 20ms und moduliert diese mit LFO zwischen 10ms und 30ms. Dadurch verlangsamt und beschleunigt das Signal und es entsteht eine Frequenzverschiebung. Dies wird musikalisch als eine Intonation wahrgenommen.

Implementierung

LFO

Für das Flanger-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird.

/*
LFO
*/
float c_flanger::lfo(void){

	float y_lfo;

	//Calculate LFO value
	y_lfo=sin(a_lfo);

	//Update angle
	a_lfo+=a_step;
	if(a_lfo>=2*PI){
		a_lfo=a_lfo-2*PI;
	}

	return y_lfo;
}

/*
Calculate rotating delay
*/
float c_flanger::get_current_delay(void){

	//Calculate time
	float t;
	t=(float)d_base+depth*lfo();

	//Return the delay time
	return t;

}

LFO

float c_flanger::lfo(void){

float y_lfo;

//Calculate LFO value

y_lfo=sin(a_lfo);

//Update angle

a_lfo+=a_step;

if(a_lfo>=2*PI){

a_lfo=a_lfo-2*PI;

}

return y_lfo;

}

Calculate rotating delay

float c_flanger::get_current_delay(void){

//Calculate time

float t;

t=(float)d_base+depth*lfo();

//Return the delay time

return t;

}

Hauptroutine

Der Algorithmus vom Chorus ist vergleichbar mit einem Delay-Algorithmus ohne Feedback und mit variabler Delay-Zeit.

/* 
Flanger main process
*/
float c_flanger::process(float x){

	float y;

	float t_c;	//Current delay

	//Get tap distance
	t_c=get_current_delay(); //Tap distance

	//Calculate the position of the pointer
	int wptr;

	wptr=fptr-lrint(t_c*FSms);

	if(wptr<0){
		wptr+=flanger_len;
	}

	//Calculate output
	y=G_d*drybuf[dryptr] + G_w*fbuf[wptr];

	//Update the buffer
	fbuf[fptr]=x+G_fb*fbuf[wptr];
	drybuf[dryptr]=x;

	//Increment
	fptr++;
	if(fptr>=flanger_len){
		fptr=0;
	}

	dryptr++;
	if(dryptr>=l_drybuf){
		dryptr=0;
	}

	return y;
}

Flanger main process

float c_flanger::process(float x){

float y;

float t_c; //Current delay

//Get tap distance

t_c=get_current_delay(); //Tap distance

//Calculate the position of the pointer

int wptr;

wptr=fptr-lrint(t_c*FSms);

if(wptr<0){

wptr+=flanger_len;

}

//Calculate output

y=G_d*drybuf[dryptr] + G_w*fbuf[wptr];

//Update the buffer

fbuf[fptr]=x+G_fb*fbuf[wptr];

drybuf[dryptr]=x;

//Increment

fptr++;

if(fptr>=flanger_len){

fptr=0;

}

dryptr++;

if(dryptr>=l_drybuf){

dryptr=0;

}

return y;

}

Ein Prozess ohne Verzögerung vom trockenen Signal sieht folgendermaßen aus:

/*
Main process without delay on dry line
*/
float c_flanger::process_nondelay(float x){

	float y;

	float t_c;	//Current delay

	//Get tap distance
	t_c=get_current_delay(); //Tap distance

	//Calculate the position of the pointer
	int wptr;

	wptr=fptr-lrint(t_c*FSms);

	if(wptr<0){
		wptr+=flanger_len;
	}

	//Calculate output
	y=G_d*x + G_w*fbuf[wptr];

	//Update the buffer
	fbuf[fptr]=x+G_fb*fbuf[wptr];

	//Increment
	fptr++;
	if(fptr>=flanger_len){
		fptr=0;
	}

	return y;
}

Main process without delay on dry line

float c_flanger::process_nondelay(float x){

float y;

float t_c; //Current delay

//Get tap distance

t_c=get_current_delay(); //Tap distance

//Calculate the position of the pointer

int wptr;

wptr=fptr-lrint(t_c*FSms);

if(wptr<0){

wptr+=flanger_len;

}

//Calculate output

y=G_d*x + G_w*fbuf[wptr];

//Update the buffer

fbuf[fptr]=x+G_fb*fbuf[wptr];

//Increment

fptr++;

if(fptr>=flanger_len){

fptr=0;

}

return y;

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre Rythmus - Flanger - Depth:50 - Rate: 1 - FB:50

Gitarre Rythmus - Flanger - Depth:50 - Rate: 2 - FB:20

Gitarre Rythmus - Flanger - Depth:50 - Rate: 2 - FB:50

Gitarre Rythmus - Flanger - Depth:10 - Rate: 2 - FB:50

Gitarre Rythmus - Flanger - Depth:10 - Rate: 10 - FB:70

Digitaler Chorus-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Ein Choruseffekt (engl. für Chor-Effekt) ist ein Modulationseffekt, der das Eingangssignal kopiert und dessen Tonhöhe (Pitch) mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Somit entsteht eine „imperfekte“ Kopie vom Eingangssignal, das dem Ausgangssignal beigemischt wird. Dadurch entsteht der sogenannte Chor-Effekt. Im folgenden ist das Grundprinzip eines Chorus aufgezeigt.

Im obigen Diagramm gibt es nur eine Kopie des Eingangssignals (single-tap). Es ist auch üblich mehrere Kopien zu machen und mit verschiedenen Parametern einen „mehrköpfigen“ Chor zu erzielen.

Parameter

Folgende Kontrollparameter sind für einen Chorus-Effekt üblich:

Frequenz

Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.

Tiefe (Depth)

Wet/Dry

Hiermit wird kontrolliert, wie stark das modulierte Signal ins Ausgangssignal beigemischt werden soll.

Multi-Tap

Man kann das Eingangssignal auch mehr als ein mal abzweigen und modulieren. Wenn man die Einstellungen nicht für jeden Tap vornehmen will, kann man diese algorithmisch beliebig zusammensetzen.

Modulation mit LFO

Ein LFO ist nichts anderes als ein Signalgenerator, der in der Regel ein niederfrequentes Sinus-Signal generiert. Diese Signalquelle nutzt man u. a. zur Modulation eines Signals.

Implementierung

LFO

Für das Chorus-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird. Beim Multi-tap-Chorus braucht man nicht mehrere Puffer sondern nur mehrere LFOs und mehrere Zeiger auf das Puffer.

/*
LFO
*/
float c_chorus::lfo(void){

	float y_lfo;

	//Calculate LFO value
	y_lfo=sin(a_lfo);

	//Update angle
	a_lfo+=a_step;
	if(a_lfo>=2*PI){
		a_lfo=a_lfo-2*PI;
	}

	return y_lfo;
}

/*
Calculate rotating delay
*/
float c_chorus::get_current_delay(void){

	//Calculate time
	float t;
	t=d_base+depth*lfo();

	//Return the delay time
	return t;

}

LFO

float c_chorus::lfo(void){

float y_lfo;

//Calculate LFO value

y_lfo=sin(a_lfo);

//Update angle

a_lfo+=a_step;

if(a_lfo>=2*PI){

a_lfo=a_lfo-2*PI;

}

return y_lfo;

}

Calculate rotating delay

float c_chorus::get_current_delay(void){

//Calculate time

float t;

t=d_base+depth*lfo();

//Return the delay time

return t;

}

Hauptroutine

Der Algorithmus vom Chorus ist vergleichbar mit einem Delay-Algorithmus ohne Feedback und mit variabler Delay-Zeit.

/*
Main chorus single tap
*/
float c_chorus::process(float x){

	float y;

	float t_c;	//Current delay

	//Get tap distance
	t_c=get_current_delay(); //Tap distance

	//Calculate the position of the pointer
	int wptr;

	wptr=cptr-lrint(t_c*FSms);

	if(wptr<0){
		wptr+=chorus_len;
	}

	//Calculate output
	y=G_d*x + G_w*cbuf[wptr];

	//Update the buffer
	cbuf[cptr]=x;

	//Increment
	cptr++;
	if(cptr>=chorus_len){
		cptr-=chorus_len;
	}

	return y;
}

Main chorus single tap

float c_chorus::process(float x){

float y;

float t_c; //Current delay

//Get tap distance

t_c=get_current_delay(); //Tap distance

//Calculate the position of the pointer

int wptr;

wptr=cptr-lrint(t_c*FSms);

if(wptr<0){

wptr+=chorus_len;

}

//Calculate output

y=G_d*x + G_w*cbuf[wptr];

//Update the buffer

cbuf[cptr]=x;

//Increment

cptr++;

if(cptr>=chorus_len){

cptr-=chorus_len;

}

return y;

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Rythmus Chorus - Depth: 10 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 90 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 2Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 15Hz

Digitales Delay

22. November 2019 / solocan / Noch kein Kommentar

Ein Delay (Engl. für Verzögerung) ist in digitaler Ausführung -im Gegensatz zu analog- ein recht simpel zu implementierender Effekt. In der Grundform ohne Rückkopplung verzögert es das Eingangssignal um einen voreingestellten Zeitversatz und mischt das verzögerte Signal zum Eingangssignal (trockenes Signal) bei. Dabei entsteht ein Delay-Effekt. Mit der Rückkopplung, siehe Abbildung, wird das verzögerte Signal durch ein Feedbackverstärkung $G_{FB}$ abgeschwächt und zum Eingangssignal der Verzögerungseingang $a[n]$ zurückgemischt.

Parameter

Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:

Delay-Zeit

Einstellung der Delay-Zeit. Üblicherweise in Millisekunden. Oft wird zur Angabe der Delay-Zeit eine „Tapping“ Funktion zur Verfügung gestellt, mit der der Benutzer den Takt mit einem Taster vorgeben kann und dieser Takt wird in die Zeit umgerechnet.

Takt

Der Parameter, ob der angetippter Takt als z.B. als Viertel, Achtel oder Sechszehntel zu verstehen ist.

Rückkopplungsdämpfung (Feedback gain)

Mit diesem Parameter kontrolliert man die Dämpfung der Rückkopplung. Aus Stabilitsgründen muss sich diese im Intervall von

(1) $\begin{equation*} 0 \leq G_{FB} <1 \end{equation*}$

befinden.

Multi-Tap

Man kann das Eingangssignal auch mehr als ein mal abzweigen und verzögern. Wenn man die Einstellungen nicht für jeden Tap vornehmen will, kann man diese algorithmisch beliebig zusammensetzen (lassen).

Pre-Delay

Die Verzögerung des trockenen Signals.

Wet/Dry

Hiermit wird kontrolliert, wie stark das verzögerte Signal ins Ausgangssignal beigemischt werden soll.

Implementierung

Für das Delay wird ein großes Kreispuffer für $z^{-M}= benötigt, in dem Delay-Signal aufgenommen wird.

/*Main process of delay line */
float c_delay::process(float x){

	float y;

	//Calculate output
	y=dbuf[dptr]*G_w+x*G_d;

	//Update buffer
	dbuf[dptr]=x+dbuf[dptr]*G_fb;

	//Increment pointer (circular buffer)
	dptr++;

        //Reset pointer (circular buffer)
	if(dptr>=n_distance){
		dptr=0;
	}

	return y;
}

/*Main process of delay line */

float c_delay::process(float x){

float y;

//Calculate output

y=dbuf[dptr]*G_w+x*G_d;

//Update buffer

dbuf[dptr]=x+dbuf[dptr]*G_fb;

//Increment pointer (circular buffer)

dptr++;

//Reset pointer (circular buffer)

if(dptr>=n_distance){

dptr=0;

}

return y;

}

Die Variable n_distance ist das Delay time umgerechnet in Anzahl der Samples und berechnet sich (nach jedem Delay-Time update) folgendermaßen:

/*
Routine for setting the delay time
*/
void c_delay::set_time(float *time){

        //Delay time is incoming as milliseconds
	delay_time=*time
	n_distance=(unsigned long)(*time*FSms);

	//Security for delay length
	if(n_distance>delay_max){
		n_distance=delay_max;
	}

	reset_buffer();

}

Routine for setting the delay time

void c_delay::set_time(float *time){

//Delay time is incoming as milliseconds

delay_time=*time

n_distance=(unsigned long)(*time*FSms);

//Security for delay length

if(n_distance>delay_max){

n_distance=delay_max;

}

reset_buffer();

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Rythmus Delay-Time: 600ms - Feedback: 0.5 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0.5 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0.9 - Wet gain:0.2

Digitales Allpassfilter

21. November 2019 / solocan / Noch kein Kommentar

Das Allpassfilter lässt alle Frequenzen durch, verursacht allerdings eine Phasenverschiebung, welches als Verzögerungselement verwendet werden kann.

Die Übertragungsfunktion eines digitalen Allpassfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{s^2-\frac{1}{Q}s+1}{s^2+\frac{1}{Q}s+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\alpha \\ b_{n,0}&=\frac{1}{a_0} (1-\alpha) \\ b_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ b_{n,2}&=1\\ a_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{a_0} (1-\alpha) \\ \end{align} \end{equation*}$

wobei

(3) $\begin{equation*} \begin{align} f_0 &: Grenzfrequenz\\ F_s&: Abtastrate\\ \omega_0&=2 \pi \frac{f_0}{F_s}\\ \frac{1}{Q}&=2 \sinh(\frac{\ln(2) BW}{2})\\ \alpha&=\frac{sin(\omega_0)}{2 Q} \end{align} \end{equation*}$

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=a0_inv;
bn1=(float)((-2 cosw0)*a0_inv);
bn2=1;
an1=(float)((-2 cosw0)*a0_inv);
an2=(float)((1-alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=a0_inv;

bn1=(float)((-2 cosw0)*a0_inv);

bn2=1;

an1=(float)((-2 cosw0)*a0_inv);

an2=(float)((1-alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.