Kategorie: Effects (page 1 of 3)

Analoger Dynamikkompressor

7. Dezember 2019 / solocan / Noch kein Kommentar

Die Dynamikkompression (engl. Dynamic range compression) ist ein Prozess, der die Dynamik komprimiert bzw. reduziert. Das wird gemacht, indem die lauten Bereiche, die einen Schwellwert überschreiten, leiser gemacht werden, während die leiseren Bereiche unreduziert passieren. Die Charakteristik der Kompression lässt sich am Besten in einer Dynamikkurve darstellen, die die Beziehung zwischen der Einganglautstärke und Ausgangslautstärke beschreibt.

Die Steigung $\frac{b}{a}$ beschreibt die Kompressionsrate, mit der das Signal abgeschwächt wird. Dies greift ab dem Überschreiten eines Threshold-Werts.

Technische Beschreibung

Das Herzstück eines Kompressors ist ein spannungskontrollierter Verstärker (VCA). Im analogen Design, wird das mit komplexen Schaltungen realisiert. In der Digitaltechnik ist dies ein simpler Verstärkungsfaktor, mit dem das Signal multipliziert wird. In analoger Welt kann der VCA u. a. mit

Optokopplern (optische Kompressor)
diskreten Transistorschaltungen
integrierten Schaltkreisen

realisiert werden.

Der Verstärkungsfaktor wird in einem parallelen Pfad berechnet. Der parallele Pfad besteht aus einem Lautstärkendetektor (in der Regel realisiert mit Effektivleistung, RMS) und einer Logik, die die Reduktion aus der Lautstärke berechnet (Gain computer).

Loudness detector

Einer der wichtigsten Bestandteile einer Kompression ist die Berechnung der Lautstärke, Hier wird kontinuierlich ermittelt, wie hoch die empfundene Lautstärke ist. Gängigste Methode dafür ist der Effektivwert als quadratischer Mittelwert des relevanten Sampleabschnitts.

(1) $\begin{equation*} RMS=\sqrt{\frac{1}{n}\sum_{i=1}^{n}x_i^2} \end{equation*}$

Der RMS-Wert dient als Eingang für den Gain-Computer. Der Gain-Computer berechnet daraus die Verstärkung, die dem Signal appliziert werden soll. Es appliziert die Dynamikkurve, s. oben.

Parameter

Folgende Kontrollparameter sind für einen Kompressor Effekt üblich:

Input gain

Die Eingangsverstärkung wird auf das Eingangssignal appliziert, um das Signalniveau in einen gewünschten Platz in der Dynamikkurve zu platzieren. Alternativ kann man auch Threshold verschieben.

Threshold

Der Threshold (dt. für Schranke/Grenze) ist der Grenzwert, ab dessen Überschreitung eine Gain-Reduktion erfolgt, s. Diagramm.

Kompressionsrate

Sie beschreibt die Stärke der Gain-Reduktion nach Threshold, in der Dynamikkurve ist dies als Tangenzwert $\frac{b}{a}$ gezeigt.

Ab einem Wert von 60:1 wird von einem Limiter gesprochen.

Make-Up Gain

Der Gain-Computer appliziert eine Gain-Reduktion. Das bedeutet, die gesamte Lautstärke des Signals sinkt. Um das ältere Lautstärkenniveau zu erreichen, wird ein Make-Up Gain am Ausgang appliziert.

Soft-Knee / Hard-Knee

Ab dem Threshold ändert sich die Verstärkung, die man appliziert. Dieser Übergang, der in der Dynamikkurve oben scharf gezeichnet wurde, kann auch mild erfolgen. So dass die Gain-Reduktion langsam eintritt.

Attack

Der Attack-Wert bestimmt, wann die Gain-Reduktion nach einer Überschreitung eintreten soll. Sie liegt im Bereich von 5 bis 250 ms.

Release

Der Release-Wert bestimmt, wann nach einer Unterschreitung des Tresholds die Gain-Reduktion wieder aussetzen soll. Sie liegt üblicherweise im Bereich von 5 bis 100ms.

Analoge Implementierung

Bei Flex 500 wurde ein Kompressor auf Basis des integrierten Schaltkreises THAT4301 von THAT Corporation eingesetzt. Dieser beinhaltet

1x VCA
1x Loudness (RMS) detector
3x Opamps

und somit alles, was man für eine grundlegende Kompressorimplementierung braucht. Die Applikation und die Dimensionierung der externen Komponenten können dem Datenblatt entnommen werden.

Die Applikation für den Flex 500 sieht folgendermaßen aus:

Zudem existiert ein SPICE-Modell für den IC THAT4301, sodass man die Schaltung auch simulieren kann.

Kompressor Simulationsmodell für LTSpice herunterladen

Die gesamte KiCAD-Schaltung und das PCB Design ist verfügbar

KiCAD-Schaltung und PCB-Design herunterladen

Flex 500 – Analoger Equaliser / Tone stack

7. Dezember 2019 / solocan / Noch kein Kommentar

Der analoge EQ-Abschnitt besteht aus

Ein Tonestack mit zwei einstellbaren Kuhschwanzfiltern
- Low-Shelf
- High-Shelf
Drei parametrischen Equalisern
- Low-Mid-EQ
- Mid-EQ
- High-Mid-EQ

Die Schaltungskomponenten ist im folgenden gezeigt.

High-Low-Shelvingfilter Stack

Die Dimensionierung der Schaltung ist hier beschrieben.

Parametrischer Equalizer

Die Dimensionierung der Schaltungen ist hier beschrieben.

KiCAD-Schaltung und PCB-Design herunterladen

Analoger Low/High-Shelving Tonestack

7. Dezember 2019 / solocan / Noch kein Kommentar

Es gibt viele Tonestack-Schaltungen, die teilweise auf analysierte Designs basieren und teilweise empirisch ermittelte Dimensionierungsparameter besitzen. Diese sind oft vereinfachte zusammengeführte Frequenzfilter für die Klangregelung verschiedener Zwecke.

Eine Übersicht der Tone-Stacks mit einem eigenen Schaltungssimulator ist auf Duncan amps verfügbar:

http://www.duncanamps.com/tsc/

Mit diesem Tool kann man die Frequenzantwort seiner Schaltung angucken und empirisch eine Schaltung designen.

Beim Flex 500 wurde zusätzlich zum 3-stufigen parametrischen EQ auch ein beliebter Klangregler für Höhen und Tiefenregelung eingesetzt.

Die Komponenten dieser Schaltung können empirisch mit Hilfe der Schaltungssimulation dimensioniert werden.

Tonestack_LTSpice

KiCAD-Schaltung und PCB-Design herunterladen

Digitaler Distortion-Effekt

6. Dezember 2019 / solocan / Noch kein Kommentar

Der Distortion (dt. Verzerrung)-Effekt basiert auf starkem Übersteuern und/oder Limitieren eines Signals. Er ist ein sehr beliebter und verbreiteter E-Gitarreneffekt. Mit dem Effekt kann man sowohl mildere „Overdrive“ als auch starke „Metal“-Sounds erreichen.

Technisch basiert es in analoger Ausführung auf hartem Limitieren des Signals (Clipping) mit Hilfe von Dioden oder Übersteuern von Röhren. Davor und danach werden Filter und sonstige Effekte eingebaut, um einen guten Klang zu erzielen.

In digitaler Ausführung kann hingegen mit verschiedenen mathematischen Ansätzen gearbeitet werden, die analog schwer bis unmöglich umzusetzen sind., wie z.B. Parabeln und exponentiellen Funktionen.

Das harte Limitieren eines 1kHz Sinussignals kann man sich folgendermaßen vorstellen.

Rendered by QuickLaTeX.com

Mathematisch lässt sich das als

(1) $\begin{equation*} \begin{aligned} y=-y_{th} \quad &wenn\quad \sin(x)<-y_{th} \\ y=\sin(x) \quad &wenn\quad -y_{th}< \sin(x)< y_{th} \\ y=y_{th} \quad &wenn\quad \sin(x)>y_{th} \end{aligned} \end{equation*}$

beschreiben, wobei $y_{th}$ der Threshold-Wert ist, ab dem das Clipping erfolgt.

Auf dieser Grafik fallen zwei Sachen auf:

Ab dem Clipping stellt man den Pegel auf einen konstanten Wert : Gleichstrom!
Die Übergänge haben einen Knick =>Sehr hohe Frequenzen

Die Verzerrung tiefe Verzerrung wird als sehr unangenehm empfungen. Der Gleichstrom ( $f=0$ ) ist sogar schädlich für die Lautsprecher (wobei der üblicherweise von der Leistungselektronik herausgefiltert wird)

Das heißt, das einfache Clipping erzeugt zwar einen Distortion-Sound aber keinen Guten. Eine bessere Möglichkeit zum Verzerren ist die Anwendung von Soft-Clipping mit mathematischen Funktionen. Ein weicher Übergang zum Clipping und danach ein leichtes Überschwingen ist wünschenswert, um Gleichstrom zu vermeiden. Das kann mit folgender exponentiellen Funktion erreicht werden.

(2) $\begin{equation*} y=sgn(x) [1-e^{-k x sgn(x)}] \end{equation*}$

oder als teilweise Funktion

(3) $\begin{equation*} \begin{aligned} y=1-e^{-k x} \quad& \text{wenn} \quad x\geq0 \\ y=-1+e^{k x} \quad& \text{wenn} \quad x<0 \end{aligned} \end{equation*}$

,wobei der Skalierungsfaktor $k$ als Vorverstärkung gesehen werden kann.

Im folgenden ist diese Signalform mit den Verstärkungsfaktoren $k=1$ und $k=5$ dargestellt.

Rendered by QuickLaTeX.com

Es gibt auch andere mathematische Ansätze, die ein Soft-Clipping modellieren und oft Zusammensetzung gestückelter Polynome sind.

Das Herzstück der Verzerrung ist also das Clipping, wobei dies noch lange nicht alles bei einem guten Distortion-Sound ist. Es gibt noch etwas unvernachlässigbares bei einem Distortion-Algorithmus: Die Frequenzfilter.

Hochpassfilter/Kuhschwanzfilter für Tiefen

Verzerrung von tiefen Frequenzen werden als sehr unangenehm empfunden. Daher möchte man oft einen Hochpassfilter vor dem Clipping-Block einschalten, um die tiefen Frequenzen herauszufiltern. Zudem entsteht bei Clipping sogar noch zusätzlich tiefe Frequnzen, Diese müssen dann nach dem Clipping herausgefiltert werden.

Tiefpassfilter / Kuhschwanzfilter für Höhen

Nach dem Clipping erhalten wir oft einen Sound, der je nach Clipping sehr kratzig klingen kann, weil erstens verzerrte Hochfrequenzen unangenehm empfunden werden als auch wir durch Clipping zusätzlich Hochfrequenzen erzeugen. Deshalb können wir nach dem Clipping auch einen Tiefpassfilter schalten und alle hohe Frequenzen dämpfen, um einen „runderen“ und weniger „kratzigen“ Klang zu erzielen.

Sonstige Bestandteile der Verzerrung

Oft haben schöne Distortion-Sounds viel mehr Komponenten als nur Clipping. Diese sind v.a.

Kompressoren vor und/oder nach dem Clipping
Zusätzliche Frequenzfilter für die Betonung
Zusätzliche Polynomfilter (Röhrensimulation)
Phaser / Doubler (Frequenzauslöschungen)
Asymmetrische Clipper (Röhren-ähnliche Distortion / Overdrive Sounds)

Die Zusammensetzung des Distortion Sounds hängt also neben dem Clipping-Algorithmus auch von anderen Komponenten, die für einen angenehmen verzerrten Sound sorgen.

Parameter

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

Vorverstärkung (Gain)

Die Stärke des Clippings hängt hauptsächlich vor unserer Vorskalierung $k$ ab. Das ist der Hauptparameter einer Distortion. Alles andere ist im Grunde optional. In der Benutzeroberfläche befinden sich nicht die Parameter einzelner Komponenten, sondern verschiedene künstliche Parameter wie „Presence“ oder gar Verstärkertypen „Brit, Vox, Marshall, etc.“, wobei diese empirisch ermittelter Parametersätze für die verwendeten Blöcke sind.

Nachverstärkung/Korrektur (Post-gain/Volume)

Dieser Parameter ist dafür da, um wieder auf den Pegel zurückzukommen von dem man sich durch das Clipping ggf. entfernt hat. Manchmal ist dieser Parameter nicht an den Endbenutzer weitergegeben, sondern durch Vorverstärkung berechnet.

Implementierung

Im folgenden ist ein grundlegender Distortion/Overdrive mit einem vorgeschalteten Hochpassfilter und nachgeschaltetem Tiefpassfilter implementiert.

/*
Main process of overdrive
*/
float c_overdrive::process(float x){

	float y;

	x=pre_filter.process(x);

	x=x*downscaler*gain;

	//Algorithm 1: y=sign(x)*(1-e(-1*sign(x)*x))
	if(x>0){
		y=1-exp(-1*x);
	}else{
		y=-1+exp(x);
	}

	y=y*upscaler;

	y=post_filter.process(y);

	return y;
}

Main process of overdrive

float c_overdrive::process(float x){

float y;

x=pre_filter.process(x);

x=x*downscaler*gain;

//Algorithm 1: y=sign(x)*(1-e(-1*sign(x)*x))

if(x>0){

y=1-exp(-1*x);

}else{

y=-1+exp(x);

}

y=y*upscaler;

y=post_filter.process(y);

return y;

}

Klangbeispiele

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

Gitarre - Rythmus trocken

Gitarre - Distortion - Kein Hochpass, kein Tiefpass

Gitarre - Distortion - Hochpass: 350Hz - Kein Tiefpass

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 4500Hz

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 3500Hz

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 2500Hz

Overdrive - Synthy

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;

}

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