Question

The DSP board I am currently using is DSK6416 from Spectrum Digital, and I am implementing a convolution algorithm in C to convolve input voice samples with a pre-recorded impulse response array. The objective is to speak into the microphone, and output the processed effect so we sound like we are speaking in that environment where the impulse response array is obtained.

The challenge I am facing now is doing the convolution live and keep up the pace of the input and output speed of the interrupt function at 8 kHz.

Here is my brain storming idea:

My current inefficient implementation that does not work is as follows:

The interrupt will stop the convolution process, output the index, and resume convolution at 8 kHz, or 1/8kHz seconds.

However, a complete iteration of convolution runs much slower than 1/8kHz seconds. So when the interrupt wants to output the data from the output array, the data is not ready yet.

My ideal implementation for fast pipelining convolution algorithm:

We would have many convolution processes running in the background while outputting the completed ones as time goes on. There will be many pipes running in parallel.

If I use the pipelining approach, we would need to have N = 10000 pipeline processes running in the background…

Now I have the idea down (at least I think I do, I might be wrong), I have no clue how to implement this on the DSK board using C programming language because C does not support object orientation.

The following is the pseudo-code for our C implementation:

#include <stdio.h>
#include "DSK6416_AIC23.h"
Uint32 fs=DSK6416_AIC23_FREQ_48KHZ;        //set sampling rate
#define DSK6416_AIC23_INPUT_MIC 0x0015
#define DSK6416_AIC23_INPUT_LINE 0x0011
Uint16 inputsource=DSK6416_AIC23_INPUT_MIC; // select input

//input & output parameters declaration
#define MAX_SIZE 10000
Uint32 curr_input;
Int16 curr_input2;
short input[1];
short impulse[MAX_SIZE ];
short output[MAX_SIZE ];
Int16 curr_output;

//counters declaration
Uint32 a, b, c, d;      //dip switch counters
int i, j, k;            //convolution iterations
int x;                  //counter for initializing output;                                     

interrupt void c_int11()         //interrupt running at 8 kHz
{
    //Reads Input
    //Start new pipe
    //Outputs output to speaker
}

void main()
{

//Read Impulse.txt into impulse array

    comm_intr();
    while(1)
    {

    if (DIP switch pressed)
    {
            //convolution here (our current inefficient convolution algorithm)
            //Need to run multiple of the same process in the background in parallel.

    for (int k = 0; k < MAX_SIZE; k++)
    {
        if (k==MAX_SIZE-1 && i == 0)  // special condition overwriting element at i = MAX_SIZE -1
        {
            output[k] = (impulse[k]*input[0]); 
        }
        else if (k+i < MAX_SIZE) // convolution from i to MAX_SIZE
        {
            output[k+i] += (impulse[k]*input[0]); 
        }

        else if (k+i-MAX_SIZE != i-1)  // convolution from 0 to i-2
        {
            output[k+i-MAX_SIZE] += (impulse[k]*input[0]); 
        }
        else   // overwrite element at i-1
        {
            output[i-1] = (impulse[k]*input[0]); 
        }
    }

    }

    else //if DIP switch is not pressed
    {
            DSK6416_LED_off(0);
            DSK6416_LED_off(1);
            DSK6416_LED_off(2);
            DSK6416_LED_off(3);
            j = 0; 
            curr_output = input[1];
            output_sample(curr_output);  //outputs unprocessed dry voice
    }
    } //end of while
    fclose(fp);
}

Is there a way to implement pipeline in C code to compile on the hardware DSP board so we can run multiple convolution iterations in the background all at the same time?

I drew some pictures, but I am new to this board so I can’t post images.

Please let me know if you need my pictorial ideas to help you help me~

Any help on how to implement this code is very much appreciated !!

Answer 1

You probably need to process data in chunks of some N samples. While one chunk is being I/O’d in an DAC/ADC interrupt handler, another one is being processed somewhere in main(). The main thing here is to make sure your processing of a chunk of N samples takes less time than receiving/transmitting N samples.

Here’s what it may look like in time (all things in every step (except step 1) happen “in parallel”):

1. buf1=buf3=zeroes, buf2=anything
2. ISR: DAC sends buf1, ADC receives buf2; main(): processes buf3
3. ISR: DAC sends buf3, ADC receives buf1; main(): processes buf2
4. ISR: DAC sends buf2, ADC receives buf3; main(): processes buf1

Repeat indefinitely from step 2.

Also, you may want to implement your convolution in assembly for extra speed. I’d look at some TI app notes or what not for an implementation. Perhaps it’s available in some library too.

You may also consider doing convolution via Fast Fourier Transform.