Databases Reference
In-Depth Information
over time. For situations like these, we would like to have the quantizer adapt to the changes
in the source output.
For mean-removed and gain-shape vector quantizers, we can adapt the scalar aspect of the
quantizer, that is, the quantization of the mean or the gain, using the techniques discussed in
the previous chapter. In this section, we look at a few approaches to adapting the codebook of
the vector quantizer to changes in the characteristics of the input.
One way of adapting the codebook to changing input characteristics is to start with a very
large codebook designed to accommodate a wide range of source characteristics [
165
]. This
large codebook can be ordered in some manner known to both transmitter and receiver. Given
a sequence of input vectors to be quantized, the encoder can select a subset of the larger
codebook to be used. Information about which vectors from the large codebook were used
can be transmitted as a binary string. For example, if the large codebook contained 10 vectors,
and the encoder was to use the second, third, fifth, and ninth vectors, we would send the
binary string 0110100010, with a 1 representing the position of the codeword used in the large
codebook. This approach permits the use of a small codebook that is matched to the local
behavior of the source.
This approach can be used with particular effectiveness with the recursively indexed vector
quantizer [
163
]. Recall that in the recursively indexed vector quantizer, the quantized output
is always within a prescribed distance of the inputs, determined by the index
I
. This means
that the set of output values of the RIVQ can be viewed as an accurate representation of the
inputs and their statistics. Therefore, we can treat a subset of the output set of the previous
intervals as our large codebook. We can then use the method described in [
165
] to inform the
receiver of which elements of the previous outputs form the codebook for the next interval.
This method (while not the most efficient) is quite simple. Suppose an output set, in order of
first appearance, is
{
p
,
a
,
q
,
s
,
l
,
t
,
r
}
, and the desired codebook for the interval to be encoded
{
,
,
,
}
is
. Then we would transmit the binary string 0110101 to the receiver. The 1s
correspond to the letters in the output set, which would be elements of the desired codebook.
We select the subset for the current interval by finding the closest vectors from our collection
of past outputs to the input vectors of the current set. This means that there is an inherent
delay of one interval imposed by this approach. The overhead required to send the codebook
selection is
M
a
q
l
r
/
N
, where
M
is the number of vectors in the output set and
N
is the interval
size.
Another approach to updating the codebook is to check the distortion incurred while quan-
tizing each input vector. Whenever this distortion is above some specified threshold, a different
higher-rate mechanism is used to encode the input. The higher-rate mechanism might be the
scalar quantization of each component, or the use of a high-rate lattice vector quantizer. This
quantized representation of the input is transmitted to the receiver and, at the same time, added
to both the encoder and decoder codebooks. In order to keep the size of the codebook the
same, an entry must be discarded when a new vector is added to the codebook. Selecting an
entry to discard is handled in a number of different ways. Variations of this approach have
been used for speech coding, image coding, and video coding (see [154, 155, 156, 157, 158]
for more details).
