Applied Speech and Audio Processing: With matlab examples

5.4. Analysis-by-synthesis
127
5.4.2
Algebraic CELP
As mentioned previously, the computational complexity of the CELP coder is large: this
is due to the need to synthesise pseudo-speech for every vector within the codebook.
This already-complicated process must be repeated hundreds or thousands of times for
each analysis frame. Whilst many methods attempt to reduce the amount of computation
in the CELP coder by reducing the number of loops (see Section 5.4.3), algebraic CELP
(often known simply as ACELP) attempts to reduce the amount of computation required
within each loop.
Referring to Figure 5.17, the action required for each excitation vector is to amplify
it, perform LTP synthesis (to put in the pitch component) and perform LPC synthesis
(to add in the vocal tract components). Each of these are linear time-invariant (LTI)
processes which means that mathematically it does not matter in which order they are
performed. However in terms of processing complexity, it is often better to perform the
amplification last (so that the numbers being processed by the filters do not become too
large to be easily represented), and we will demonstrate that, in ACELP at least, it is
better to perform the LPC filter first.
The filtering process, as described in Section 2.3, consists of a series of multiplica-
tions. Filter coefficients are multiplied by input values, and summed to produce output
values. In the CELP encoder, this is done twice for each codeword – first in the LPC
filter and secondly in the LTP filter. These may have 10 and two coefficients respectively,
so clearly the LPC filter is the most computationally complex one. If it were possible to
reduce the complexity of the LPC filter, there would be a corresponding large reduction
in overall complexity.
In ACELP, the codewords are carefully constructed so that they are sparse (meaning
most elements are zero, with a few individual non-zero elements scattered around), with
each element in the vector being constrained to
+1, 0 or −1. These codewords are then
fed directly into the LPC synthesis filter. Let us remind ourselves what the filter looks
like mathematically:
y
(n) = a(1) × x(n) + a(2) × x(n − 1) + a(3) × x(n − 2) + · · · + a(m + 1)
× x(n − m).
In this case, x
( ) contains the input data, y( ) contains the output data, and the filter
coefficients are a
( ). If we rewrite the filter on the basis of some illustrative input vector
x
= [+1, 0, 0, −1, 0, 0, −1], meaning x(1) = +1, x(2) = 0, x(7) = −1 and so on, then
the filter equation reduces to:
y
(n) = a(1) + 0 + 0 − a(4) + 0 + 0 − a(7).
This equation involves no multiplications, simply a summation of all non-zero elements
(and being sparse there are few numbers that need to be summed). ACELP generally
operates with 80% of the elements in the codebook set to zero. This is significantly
simpler, and faster to calculate than the full filter equation that would be required with
a codebook vector of random elements.
A further advantage of ACELP is that it is entirely possible to calculate the position
(and value) of each non-zero element in the candidate vector on-the-fly. Such an action
requires some minor additional processing to generate the vectors, but does mean that

---

128