Circular buffer wrap around with chorus effect

Question

I am developing an embedded DSP audio processor and am trying to implement a chorus effect. To my understanding, the chorus effect is multiple delayed versions of the original signal, where the delay itself is random. In my program I have set the delays to be randomly defined upon initialization and then remain static during the program execution.

The challenge I'm faced with is that in using a circular buffer to store my past signal, I cannot simply wrap delayed signals back around the circular buffer as there is multiple delays present.

With a single delay I can simply check if the delay required exceeds the current position in the circular buffer, if so, I can jump to the end of the circular buffer subtract the delay and add my current position in the circular buffer.

if (Delay > Current_Position_in_Buffer)
{
    Circular_Array[Length_of_Array + Current_Position_in_Buffer - Delay];
}
else
{
    Circular_Array[Current_Position_in_Buffer - Delay];
}

Is there an efficient way to check and adjust the position in my circular array of each delayed signal, without separately checking each delay with an if statement?

Answer 1

If I understood correctly what you are asking, then this is probably more of a programming question... But the solution would be to use modular arithmetic to compute the position of the delay. With a length equal to a power of 2, this could be accomplished with an AND instruction.

const int Mask = (1 << 16) - 1;
Circular_Array[(Current_Position_in_Buffer - Delay) & Mask];

In this example, the length of your buffer is $2^{16}$.

More generally you can use the modulo operator, but it will be slower.

Answer 2

In many DSPs, you get a programmable Address Calculation Unit – I think that's what mainly caused the (former) popularity of the Motorola 56k DSP family. You can typically just program that to do your "wraparound indexing" for you, without your code needing to check any addresses.

Now, the fact that you're writing this in C points to you using some processor platform with mature compiler support.

In that case, you should possibly not fret at all – memory access is typically way slower than a branch (what an if statement typically compiles to), so this might not make a difference at all – especially since many platforms (ARM, x86, SPARC (I think),…) do have conditional moves, which basically means that the loading of memory might start very early in the pipeline.

Answer 3

I was going to suggest a power of two length with an AND mask as hops answered. As MM suggests, memory fetch time may swamp slight optimizations like that. The modulo for the general case would be a much worse solution as it brings in a divide operation. For the general case, you still need an if statement, but you can improve it (insignificantly?) slightly by coding it like this:

Index = Current_Position_in_Buffer - Delay;
if( Index < 0 ) Index += Length_of_Array;

Circular_Array[Index];

Two cents worth, maybe.

Ced

Answer 4

Depending on memory available, processor cache size(s), and branch prediction performance (etc.), it might be a manual optimization to write data into the circular buffer twice, into the circular buffer, but also into an equal sized memory block directly before the circular buffer. That way, after the initial pre-fill, there will always be valid data in memory after subtracting the delay from the current index, and no modulo wrap-around of each offset will be required to read those offset samples.

On some systems, it might be possible to memory map a circular buffer into a memory address block right before that buffer, and thus a data write only needs to be done once for data to appear at both required memory addresses for non-modulo offset reads to be possible.