15 Dec
2005
15 Dec
'05
12:26 a.m.
Here's a poorly written description of my problem (the code in
question is written from scratch in C++, BTW):
I have a simple gain function that takes a number between 0 and 1 and
multiplies each input sample by that number. If I use the output of
an LFO to get that gain number, I gets clicks in my output (presumably
on when the LFO output changes by and number close to 1, as it would
with a pulse/square wave). How can I get rid of these clicks? Do I
need to "smooth" the output of the LFO, or my processed output? If
so, what is a good way to do that?
On a semi-related note, can someone recommend any Free libraries in C
or C++ that implement things like oscillators, filters, etc.?
15 Dec
15 Dec
5:17 a.m.
Le 15 déc. 05 à 05:26, Paul Coccoli a écrit :
Here's a poorly written description of my problem
(the code in
question is written from scratch in C++, BTW):
I have a simple gain function that takes a number between 0 and 1 and
multiplies each input sample by that number. If I use the output of
an LFO to get that gain number, I gets clicks in my output (presumably
on when the LFO output changes by and number close to 1, as it would
with a pulse/square wave). How can I get rid of these clicks? Do I
need to "smooth" the output of the LFO, or my processed output? If
so, what is a good way to do that?
On a semi-related note, can someone recommend any Free libraries in C
or C++ that implement things like oscillators, filters, etc.?
You may have a look at Faust, a dsp to C++ compiler : http://
faudiostream.sourceforge.net/
Regards
Stephane Letz
11:21 a.m.
On Wed, Dec 14, 2005 at 11:26:34PM -0500, Paul Coccoli wrote:
Here's a poorly written description of my problem
(the code in
question is written from scratch in C++, BTW):
I have a simple gain function that takes a number between 0 and 1 and
multiplies each input sample by that number. If I use the output of
an LFO to get that gain number, I gets clicks in my output (presumably
on when the LFO output changes by and number close to 1, as it would
with a pulse/square wave). How can I get rid of these clicks? Do I
need to "smooth" the output of the LFO, or my processed output? If
so, what is a good way to do that?
On a semi-related note, can someone recommend any Free libraries in C
or C++ that implement things like oscillators, filters, etc.?
You could smooth either; it depends on what sound you want. If you want
to change only the amplitude, but not the timbre of your output, your
only option is to smooth the gain input. However, filters on the output
could have a desirable musical effect, too.
One way to "smooth" your gain input is to write an LFO that does not
this:
___ __
| | |
__| |___|
but rather this:
___ __
/ \ /
__/ \___/
Another solution is to put either your gain input, or the final output
through something like a lowpass filter. An easy and efficient way to
implement one of these is called an "IIR" (Infinite Impulse Response)
filter, which involves calculating the next output by multiplying some
number of the previous inputs and outputs by some (usually constant)
coeficients and summing them. A google search for various combinations
of "IIR", "filter", and "DSP" should help you find some
useful
documentation.
Remember, for any problem, there are many solutions. When dealing with
music, (i'm assuming you are making music here) often trying your own
solutions and algorithms will lead to interesting sounds you did not
expect. Read about DSP and established algorithms, but never be afraid
to try your own.
12:43 p.m.
On Thursday 15 December 2005 04:26, Paul Coccoli wrote:
Here's a poorly written description of my problem
(the code in
question is written from scratch in C++, BTW):
I have a simple gain function that takes a number between 0 and 1 and
multiplies each input sample by that number. If I use the output of
an LFO to get that gain number, I gets clicks in my output (presumably
on when the LFO output changes by and number close to 1, as it would
with a pulse/square wave). How can I get rid of these clicks? Do I
need to "smooth" the output of the LFO, or my processed output? If
so, what is a good way to do that?
I assume that this happens with fast edges on the output of the LFO (like say
square waves), if so it is aliasing due to the fact that the LFO contains
components which when mixed with the audio fall outside the nyquest limit of
bandwidth <0.5 * sample rate.
You should use a band limited LFO or otherwise filter the control signal to
keep the mixing products from the multiplier within the nyquest limit.
Filtering can work, but it needs to be quite high order to get the highest
frequency component down far enough, and that introduces problems of its own,
mainly phase shifts and overshoot.
I would note that rolling the audio off at say 15K or so gives you much more
available control bandwidth then going over at 22K does (in a 44.1Khz
system), as in general the sum of the highest audio frequency and the highest
frequency on the control line must obey the nyquest limit.
On a semi-related note, can someone recommend any Free
libraries in C
or C++ that implement things like oscillators, filters, etc.?
LibDSP?
Also some good stuff in gnuRadio.
Regards, Dan.
2:07 p.m.
On Thu, Dec 15, 2005 at 04:43:31PM +0000, Dan Mills wrote:
On Thursday 15 December 2005 04:26, Paul Coccoli
wrote:
There is truth in what you say, but given the problem described, this is
likely more confusing than helpful to someone new to signal processing.
If the problem is that the input is a low frequency square wave, from a
Low Frequency Oscilator, the popping has nothing to do with the
"nyquest" limit. If the square wave were coming from an ideal source
(which it isn't) then any higher frequency components likely would be so
small as to be smaller than the quantization error.
The problem is simply that it contains high frequency components (under
the limit), or more intuitively, a sudden drop or rise. Drop or rise
more slowly, and the pops go away.
There is no need here for a high order filter here, and no risk of phase
shifts or overshoot. A simple first order lowpass filter will be quite
effective, as will any other simple techniques such as averaging or
changing the LFO function to put more slope on the rising and falling
edges.
Here's a poorly written description of my
problem (the code in
question is written from scratch in C++, BTW):
I have a simple gain function that takes a number between 0 and 1 and
multiplies each input sample by that number. If I use the output of
an LFO to get that gain number, I gets clicks in my output (presumably
on when the LFO output changes by and number close to 1, as it would
with a pulse/square wave). How can I get rid of these clicks? Do I
need to "smooth" the output of the LFO, or my processed output? If
so, what is a good way to do that?
I assume that this happens with fast edges on the output of the LFO (like say
square waves), if so it is aliasing due to the fact that the LFO contains
components which when mixed with the audio fall outside the nyquest limit of
bandwidth <0.5 * sample rate.
You should use a band limited LFO or otherwise filter the control signal to
keep the mixing products from the multiplier within the nyquest limit.
Filtering can work, but it needs to be quite high order to get the highest
frequency component down far enough, and that introduces problems of its own,
mainly phase shifts and overshoot.
I would note that rolling the audio off at say 15K or so gives you much more
available control bandwidth then going over at 22K does (in a 44.1Khz
system), as in general the sum of the highest audio frequency and the highest
frequency on the control line must obey the nyquest limit.
[...]
2:45 p.m.
On Thursday 15 December 2005 18:06, Phil Frost wrote:
There is truth in what you say, but given the problem
described, this is
likely more confusing than helpful to someone new to signal processing.
If the problem is that the input is a low frequency square wave, from a
Low Frequency Oscilator, the popping has nothing to do with the
"nyquest" limit. If the square wave were coming from an ideal source
(which it isn't) then any higher frequency components likely would be so
small as to be smaller than the quantization error.
The thing is that a LFO implemented as part of a plugin is an ideal source for
all practical purposes, it can and does do a step change in sample value (for
the nieve squarewave case) which if the LFO is running at 20Hz gives the
level of the 1001st harmonic as 1/1001 that of the fundamental, or some 60db
down. Low but hardly buried in the nose, as the mixing products will not be
harmonically related to either signal.
The problem is simply that it contains high frequency
components (under
the limit), or more intuitively, a sudden drop or rise. Drop or rise
more slowly, and the pops go away.
Does hooking the LFO output directly to a speaker click, if so this is the
problem, but if it only acts up when multiplied with another signal then I
still maintain that it is mixer products aliasing that is the problem.
There is no need here for a high order filter here,
and no risk of phase
shifts or overshoot. A simple first order lowpass filter will be quite
effective, as will any other simple techniques such as averaging or
changing the LFO function to put more slope on the rising and falling
edges.
Also the OP probably needs to make the rate of change continuous as that can
also cause a click.
Regards, Dan.
1:32 p.m.
Hello,
when I made my very first saw and square LFOs I got the same problem as you -
clicks caused by fast (single-sample) changes of LFO output value - these
happen once in a saw cycle and twice for a square cycle.
What I did is make the LFO forms smoother, to have a soft knee. Such a method
for a saw wave, for example, means it grows from 0 to 1 in 1/20 of the
perioud and then decays from 1 to 0 in the rest 19/20 of the period. I can
send you the C code if you need, it implements basic LFO functions using very
simple math.
I hope this helps.
Artemiy.
6850
days inactive
6851
days old
linux-audio-dev@lists.linuxaudio.org
6 comments
5 participants
participants (5)
-
Artemiy Pavlov -
Dan Mills -
Paul Coccoli -
Phil Frost -
Stéphane Letz