Implementation of FIR Filtering without padding - c

Question

Is it possible to implement FIR filtering action without padding the input and coefficients?
i.e. Let's say if the input and filter coefficients are of size 4, then the output will be 7 samples. So, while implementing, we generally add 3 more zeros to both input and filter coefficients making them equal to output size.
But, if the input and filter coefficients are of size 1024, then the output will be of 2047 samples. So, now, we need to add 1023 zeros to both input and filter coefficients. This is inefficient, right?
So, I just want to know is there any other way to implement FIR Filtering without padding?
The below code gives the idea I was talking about.
int x[7],h[7],y[7];
int i,j;
for(i=0;i<7;i++)
{
if(i<4)
{
x[i] = i+1;
h[i] = i+1;
}
if(i>=4)
{
x[i] = 0;
h[i] = 0;
}
}
for(i=0;i<7;i++)
{
y[i] = 0;
for(j=0;j<=i;j++)
{
y[i] = y[i] + h[j] * x [i-j];
}
}

Answer 1

To see what your code is doing, change the calculations to printfs, like this:
for(int i = 0; i < 7; i++)
{
printf("y[%d] = 0\n", i);
for(int j = 0; j <= i; j++)
{
printf("y[%d] += h[%d] * x[%d]\n", i, j, i-j);
}
printf("\n");
}
The output from that code (comments added) is:
y[0] = 0
y[0] += h[0] * x[0]
y[1] = 0
y[1] += h[0] * x[1]
y[1] += h[1] * x[0]
y[2] = 0
y[2] += h[0] * x[2]
y[2] += h[1] * x[1]
y[2] += h[2] * x[0]
y[3] = 0
y[3] += h[0] * x[3]
y[3] += h[1] * x[2]
y[3] += h[2] * x[1]
y[3] += h[3] * x[0]
y[4] = 0
y[4] += h[0] * x[4] // zero x
y[4] += h[1] * x[3]
y[4] += h[2] * x[2]
y[4] += h[3] * x[1]
y[4] += h[4] * x[0] // zero h
y[5] = 0
y[5] += h[0] * x[5] // zero x
y[5] += h[1] * x[4] // zero x
y[5] += h[2] * x[3]
y[5] += h[3] * x[2]
y[5] += h[4] * x[1] // zero h
y[5] += h[5] * x[0] // zero h
y[6] = 0
y[6] += h[0] * x[6] // zero x
y[6] += h[1] * x[5] // zero x
y[6] += h[2] * x[4] // zero x
y[6] += h[3] * x[3]
y[6] += h[4] * x[2] // zero h
y[6] += h[5] * x[1] // zero h
y[6] += h[6] * x[0] // zero h
The commented calculations are just a waste of time, since either the h value or the x value will be zero. To avoid the wasted calculations, the code needs to adjust the starting and ending values of j.
When i<=3 the starting value for j is 0, otherwise the starting value is i-3.
When i<=3 the ending value for j is i, otherwise the ending value is 3.
Therefore, the loops should look like this:
for(int i = 0; i < 7; i++)
{
printf("y[%d] = 0\n", i);
int start = (i <= 3) ? 0 : i-3;
int end = (i <= 3) ? i : 3;
for(int j = start; j <= end; j++)
{
printf("y[%d] += h[%d] * x[%d]\n", i, j, i-j);
}
printf("\n");
}
The output is:
y[0] = 0
y[0] += h[0] * x[0]
y[1] = 0
y[1] += h[0] * x[1]
y[1] += h[1] * x[0]
y[2] = 0
y[2] += h[0] * x[2]
y[2] += h[1] * x[1]
y[2] += h[2] * x[0]
y[3] = 0
y[3] += h[0] * x[3]
y[3] += h[1] * x[2]
y[3] += h[2] * x[1]
y[3] += h[3] * x[0]
y[4] = 0
y[4] += h[1] * x[3]
y[4] += h[2] * x[2]
y[4] += h[3] * x[1]
y[5] = 0
y[5] += h[2] * x[3]
y[5] += h[3] * x[2]
y[6] = 0
y[6] += h[3] * x[3]
This avoids the wasted calculations, and eliminates the need to pad the h and x arrays.

Answer 2

You can modify your function to only compute a value when the indexes are inside the valid ranges:
int x[4], h[4], y[7];
for (i = 0; i < 4; i++) {
if (i < 4) {
x[i] = i + 1;
h[i] = i + 1;
}
}
for (j = 0; j < 4; j++) {
if (i - j > 0 && i - j < 4) {
y[i] = y[i] + h[j] * x[i - j];
}
}
This will simply discard all the values that are outside of range of the data and filter coefficients.