Some applications need DFT frequencies
of the most recent NN samples on an ongoing basis.
One example is DTMF, or touch-tone
telephone dialing, in which a detection circuit must constantly monitor the line for
two simultaneous frequencies indicating that a telephone button is depressed.
In such cases, most of the data in each successive block of samples is the same,
and it is possible to efficiently update the DFT value from the previous sample
to compute that of the current sample.
Figure 1 illustrates successive length-4 blocks of data for which
successive DFT values may be needed.
The running FFT algorithm described here can be used to compute
successive DFT values at a cost of only two complex multiplies and additions
per DFT frequency.

The running FFT algorithm is derived by expressing each DFT sample,
X
n
+
1
ω
k
X
n
+
1
ω
k
,
for the next block at time
n+1
n
1
in terms of the previous value,
X
n
ω
k
X
n
ω
k
,
at time nn.
X
n
ω
k
=∑
p
=0N−1xn−pe−(j
ω
k
p)
X
n
ω
k
p
N
1
0
x
n
p
ω
k
p
X
n
+
1
ω
k
=∑
p
=0N−1xn+1−pe−(j
ω
k
p)
X
n
+
1
ω
k
p
N
1
0
x
n
1
p
ω
k
p
Let
q=p−1
q
p
1
:
X
n
+
1
ω
k
=∑
q
=−1N−2xn−qe−(j
ω
k
(q−1))=ej
ω
k
∑
q
=0N−2xn−qe−(j
ω
k
q)+xn+1
X
n
+
1
ω
k
q
N
2
1
x
n
q
ω
k
q
1
ω
k
q
N
2
0
x
n
q
ω
k
q
x
n
1
Now let's add and subtract
e−(j
ω
k
(N−2))xn−N+1
ω
k
N
2
x
n
N
1
:

X
n
+
1
ω
k
=ej
ω
k
∑
q
=0N−2xn−qe−(j
ω
k
q)+ej
ω
k
xn−(N−1)e−(j
ω
k
(N−1))−e−(j
ω
k
(N−2))xn−N+1+xn+1=ej
ω
k
∑
q
=0N−1xn−qe−(j
ω
k
)+xn+1−e−(j
ω
k
)xn−N+1=ej
ω
k
X
n
ω
k
+xn+1−e−(j
ω
k
(N−2))xn−N+1
X
n
+
1
ω
k
ω
k
q
N
2
0
x
n
q
ω
k
q
ω
k
x
n
N
1
ω
k
N
1
ω
k
N
2
x
n
N
1
x
n
1
ω
k
q
N
1
0
x
n
q
ω
k
x
n
1
ω
k
x
n
N
1
ω
k
X
n
ω
k
x
n
1
ω
k
N
2
x
n
N
1

(1)
This running FFT algorithm requires only two complex multiplies and adds
per update, rather than N if each DFT value were recomputed according
to the DFT equation.
Another advantage of this algorithm is that it works for

*any*
ω
k
ω
k
,
rather than just the standard DFT frequencies.
This can make it advantageous for applications, such as DTMF detection,
where only a few arbitrary frequencies are needed.

Successive computation of a specific DFT frequency for overlapped blocks
can also be thought of as a length-NN
FIR filter.
The running FFT is an efficient recursive implementation of this
filter for this special case.
Figure 2 shows a block diagram of the running FFT
algorithm.
The running FFT is one way to compute DFT filterbanks.
If a window other than rectangular is desired, a running FFT
requires either a fast recursive implementation of the corresponding
windowed, modulated impulse response, or it must have few non-zero
coefficients so that it can be applied after the running FFT update
via frequency-domain convolution.
DFT-symmmetric raised-cosine windows are an example.