Syntax for Floating Point Lifting Kernels
-----------------------------------------

Floating point lifting kernels may be implemented using either
fixed or floating point arithmetic, but the key distinction from
integer lifting kernels is that they are not intended for applications
requiring reversible Wavelet decomposition.  As such, it is reasonable
to approximate the lifting step taps and no explicit policy regarding
numerical rounding error is suggested, but the implementation should
try to preserve linearity as far as possible.

The file format is compatible with, but more compact than the corresponding
format used by VM2.1.  The key simplification is that only the lifting
steps themselves are actually loaded by the software; the associated
convolution kernels are computed by the software.  Also, we allow up to
eight lifting steps.

The first line of the file contains a sequence of positive integers,
identifying the support of each of the forward lifting steps.  The
number of such integers identifies the number of lifting steps -- there
is no need for trailing zeros as in VM2.1, although the use of trailing
zeros is acceptable.  The first integer identifies the support of the
first prediction step; the second identifies the support of the first
update step; additional integers identify the supports of subsequent
prediction and update steps.

Each of the subsequent lines corresponds to the relevant lifting step,
with all filter taps for the lifting step appearing consecutively on
the relevant line in impulse response order (not the inner-product
order defined for the interface functions described in "ifc.h").

In the application of these filter taps there is no difference between
update and prediction steps.  In both cases, the relevant filter is
applied to one subsequence (even for prediction steps and odd for update
steps) and the result is added to the other subsequence (odd for prediction
and even for update).  This is the same policy which was used by VM2.1 for
floating-point lifting kernels.