From 57feffc1c824df8c2dda9c505aeecf7412e213f7 Mon Sep 17 00:00:00 2001
From: Jean-Marc Valin
Date: Sun, 14 Nov 2010 22:18:42 -0500
Subject: [PATCH] CELT encoder
---
doc/draft-ietf-codec-opus.xml | 312 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 312 insertions(+)
diff --git a/doc/draft-ietf-codec-opus.xml b/doc/draft-ietf-codec-opus.xml
index abb2ce05..bfd371ac 100644
--- a/doc/draft-ietf-codec-opus.xml
+++ b/doc/draft-ietf-codec-opus.xml
@@ -448,6 +448,318 @@ Copy from SILK draft.
Copy from CELT draft.
+
+
+
+The MDCT implementation has no special characteristics. The
+input is a windowed signal (after pre-emphasis) of 2*N samples and the output is N
+frequency-domain samples. A low-overlap window is used to reduce the algorithmic delay.
+It is derived from a basic (full overlap) window that is the same as the one used in the Vorbis codec: W(n)=[sin(pi/2*sin(pi/2*(n+.5)/L))]^2. The low-overlap window is created by zero-padding the basic window and inserting ones in the middle, such that the resulting window still satisfies power complementarity. The MDCT is computed in mdct_forward() (mdct.c), which includes the windowing operation and a scaling of 2/N.
+
+
+
+
+
+The MDCT output is divided into bands that are designed to match the ear's critical bands,
+with the exception that each band has to be at least 3 bins wide. For each band, the encoder
+computes the energy that will later be encoded. Each band is then normalized by the
+square root of the non-quantized energy, such that each band now forms a unit vector X.
+The energy and the normalization are computed by compute_band_energies()
+and normalise_bands() (bands.c), respectively.
+
+
+
+
+
+
+It is important to quantize the energy with sufficient resolution because
+any energy quantization error cannot be compensated for at a later
+stage. Regardless of the resolution used for encoding the shape of a band,
+it is perceptually important to preserve the energy in each band. CELT uses a
+coarse-fine strategy for encoding the energy in the base-2 log domain,
+as implemented in quant_bands.c
+
+
+
+The coarse quantization of the energy uses a fixed resolution of
+6 dB and is the only place where entropy coding is used.
+To minimize the bitrate, prediction is applied both in time (using the previous frame)
+and in frequency (using the previous bands). The 2-D z-transform of
+the prediction filter is: A(z_l, z_b)=(1-a*z_l^-1)*(1-z_b^-1)/(1-b*z_b^-1)
+where b is the band index and l is the frame index. The prediction coefficients are
+a=0.8 and b=0.7 when not using intra energy and a=b=0 when using intra energy.
+The time-domain prediction is based on the final fine quantization of the previous
+frame, while the frequency domain (within the current frame) prediction is based
+on coarse quantization only (because the fine quantization has not been computed
+yet). We approximate the ideal
+probability distribution of the prediction error using a Laplace distribution. The
+coarse energy quantization is performed by quant_coarse_energy() and
+quant_coarse_energy() (quant_bands.c).
+
+
+
+The Laplace distribution for each band is defined by a 16-bit (Q15) decay parameter.
+Thus, the value 0 has a frequency count of p[0]=2*(16384*(16384-decay)/(16384+decay)). The
+values +/- i each have a frequency count p[i] = (p[i-1]*decay)>>14. The value of p[i] is always
+rounded down (to avoid exceeding 32768 as the sum of all frequency counts), so it is possible
+for the sum to be less than 32768. In that case additional values with a frequency count of 1 are encoded. The signed values corresponding to symbols 0, 1, 2, 3, 4, ...
+are [0, +1, -1, +2, -2, ...]. The encoding of the Laplace-distributed values is
+implemented in ec_laplace_encode() (laplace.c).
+
+
+
+
+
+
+After the coarse energy quantization and encoding, the bit allocation is computed
+() and the number of bits to use for refining the
+energy quantization is determined for each band. Let B_i be the number of fine energy bits
+for band i; the refinement is an integer f in the range [0,2^B_i-1]. The mapping between f
+and the correction applied to the coarse energy is equal to (f+1/2)/2^B_i - 1/2. Fine
+energy quantization is implemented in quant_fine_energy()
+(quant_bands.c).
+
+
+
+If any bits are unused at the end of the encoding process, these bits are used to
+increase the resolution of the fine energy encoding in some bands. Priority is given
+to the bands for which the allocation () was rounded
+down. At the same level of priority, lower bands are encoded first. Refinement bits
+are added until there are no unused bits. This is implemented in quant_energy_finalise()
+(quant_bands.c).
+
+
+
+
+
+
+
+
+Bit allocation is performed based only on information available to both
+the encoder and decoder. The same calculations are performed in a bit-exact
+manner in both the encoder and decoder to ensure that the result is always
+exactly the same. Any mismatch would cause an error in the decoded output.
+The allocation is computed by compute_allocation() (rate.c),
+which is used in both the encoder and the decoder.
+
+For a given band, the bit allocation is nearly constant across
+frames that use the same number of bits for Q1, yielding a
+pre-defined signal-to-mask ratio (SMR) for each band. Because the
+bands each have a width of one Bark, this is equivalent to modeling the
+masking occurring within each critical band, while ignoring inter-band
+masking and tone-vs-noise characteristics. While this is not an
+optimal bit allocation, it provides good results without requiring the
+transmission of any allocation information.
+
+
+
+
+For every encoded or decoded frame, a target allocation must be computed
+using the projected allocation. In the reference implementation this is
+performed by compute_allocation() (rate.c).
+The target computation begins by calculating the available space as the
+number of whole bits which can be fit in the frame after Q1 is stored according
+to the range coder (ec_[enc/dec]_tell()) and then multiplying by 8.
+Then the two projected prototype allocations whose sums multiplied by 8 are nearest
+to that value are determined. These two projected prototype allocations are then interpolated
+by finding the highest integer interpolation coefficient in the range 0-8
+such that the sum of the higher prototype times the coefficient, plus the
+sum of the lower prototype multiplied by
+the difference of 16 and the coefficient, is less than or equal to the
+available sixteenth-bits.
+The reference implementation performs this step using a binary search in
+interp_bits2pulses() (rate.c). The target
+allocation is the interpolation coefficient times the higher prototype, plus
+the lower prototype multiplied by the difference of 16 and the coefficient,
+for each of the CELT bands.
+
+
+
+Because the computed target will sometimes be somewhat smaller than the
+available space, the excess space is divided by the number of bands, and this amount
+is added equally to each band. Any remaining space is added to the target one
+sixteenth-bit at a time, starting from the first band. The new target now
+matches the available space, in sixteenth-bits, exactly.
+
+
+
+The allocation target is separated into a portion used for fine energy
+and a portion used for the Spherical Vector Quantizer (PVQ). The fine energy
+quantizer operates in whole-bit steps. For each band the number of bits per
+channel used for fine energy is calculated by 50 minus the log2_frac(), with
+1/16 bit precision, of the number of MDCT bins in the band. That result is multiplied
+by the number of bins in the band and again by twice the number of
+channels, and then the value is set to zero if it is less than zero. Added
+to that result is 16 times the number of MDCT bins times the number of
+channels, and it is finally divided by 32 times the number of MDCT bins times the
+number of channels. If the result times the number of channels is greater than than the
+target divided by 16, the result is set to the target divided by the number of
+channels divided by 16. Then if the value is greater than 7 it is reset to 7 because a
+larger amount of fine energy resolution was determined not to be make an improvement in
+perceived quality. The resulting number of fine energy bits per channel is
+then multiplied by the number of channels and then by 16, and subtracted
+from the target allocation. This final target allocation is what is used for the
+PVQ.
+
+
+
+
+
+
+This section needs to be updated.
+
+
+
+
+
+CELT uses a Pyramid Vector Quantization (PVQ)
+codebook for quantizing the details of the spectrum in each band that have not
+been predicted by the pitch predictor. The PVQ codebook consists of all sums
+of K signed pulses in a vector of N samples, where two pulses at the same position
+are required to have the same sign. Thus the codebook includes
+all integer codevectors y of N dimensions that satisfy sum(abs(y(j))) = K.
+
+
+
+In bands where neither pitch nor folding is used, the PVQ is used to encode
+the unit vector that results from the normalization in
+ directly. Given a PVQ codevector y,
+the unit vector X is obtained as X = y/||y||, where ||.|| denotes the
+L2 norm.
+
+
+
+
+Although the allocation is performed in 1/16 bit units, the quantization requires
+an integer number of pulses K. To do this, the encoder searches for the value
+of K that produces the number of bits that is the nearest to the allocated value
+(rounding down if exactly half-way between two values), subject to not exceeding
+the total number of bits available. The computation is performed in 1/16 of
+bits using log2_frac() and ec_enc_tell(). The number of codebooks entries can
+be computed as explained in . The difference
+between the number of bits allocated and the number of bits used is accumulated to a
+balance (initialised to zero) that helps adjusting the
+allocation for the next bands. One third of the balance is subtracted from the
+bit allocation of the next band to help achieving the target allocation. The only
+exceptions are the band before the last and the last band, for which half the balance
+and the whole balance are subtracted, respectively.
+
+
+
+
+
+
+The search for the best codevector y is performed by alg_quant()
+(vq.c). There are several possible approaches to the
+search with a tradeoff between quality and complexity. The method used in the reference
+implementation computes an initial codeword y1 by projecting the residual signal
+R = X - p' onto the codebook pyramid of K-1 pulses:
+
+
+y0 = round_towards_zero( (K-1) * R / sum(abs(R)))
+
+
+
+Depending on N, K and the input data, the initial codeword y0 may contain from
+0 to K-1 non-zero values. All the remaining pulses, with the exception of the last one,
+are found iteratively with a greedy search that minimizes the normalized correlation
+between y and R:
+
+
+
+J = -R^T*y / ||y||
+
+
+
+The search described above is considered to be a good trade-off between quality
+and computational cost. However, there are other possible ways to search the PVQ
+codebook and the implementors MAY use any other search methods.
+
+
+
+
+
+
+The best PVQ codeword is encoded as a uniformly-distributed integer value
+by encode_pulses() (cwrs.c).
+The codeword is converted to a unique index in the same way as specified in
+. The indexing is based on the calculation of V(N,K) (denoted N(L,K) in ), which is the number of possible combinations of K pulses
+in N samples. The number of combinations can be computed recursively as
+V(N,K) = V(N+1,K) + V(N,K+1) + V(N+1,K+1), with V(N,0) = 1 and V(0,K) = 0, K != 0.
+There are many different ways to compute V(N,K), including pre-computed tables and direct
+use of the recursive formulation. The reference implementation applies the recursive
+formulation one line (or column) at a time to save on memory use,
+along with an alternate,
+univariate recurrence to initialise an arbitrary line, and direct
+polynomial solutions for small N. All of these methods are
+equivalent, and have different trade-offs in speed, memory usage, and
+code size. Implementations MAY use any methods they like, as long as
+they are equivalent to the mathematical definition.
+
+
+
+The indexing computations are performed using 32-bit unsigned integers. For large codebooks,
+32-bit integers are not sufficient. Instead of using 64-bit integers (or more), the encoding
+is made slightly sub-optimal by splitting each band into two equal (or near-equal) vectors of
+size (N+1)/2 and N/2, respectively. The number of pulses in the first half, K1, is first encoded as an
+integer in the range [0,K]. Then, two codebooks are encoded with V((N+1)/2, K1) and V(N/2, K-K1).
+The split operation is performed recursively, in case one (or both) of the split vectors
+still requires more than 32 bits. For compatibility reasons, the handling of codebooks of more
+than 32 bits MUST be implemented with the splitting method, even if 64-bit arithmetic is available.
+
+
+
+
+
+
+
+
+When encoding a stereo stream, some parameters are shared across the left and right channels, while others are transmitted separately for each channel, or jointly encoded. Only one copy of the flags for the features, transients and pitch (pitch period and gains) are transmitted. The coarse and fine energy parameters are transmitted separately for each channel. Both the coarse energy and fine energy (including the remaining fine bits at the end of the stream) have the left and right bands interleaved in the stream, with the left band encoded first.
+
+
+
+The main difference between mono and stereo coding is the PVQ coding of the normalized vectors. In stereo mode, a normalized mid-side (M-S) encoding is used. Let L and R be the normalized vector of a certain band for the left and right channels, respectively. The mid and side vectors are computed as M=L+R and S=L-R and no longer have unit norm.
+
+
+
+From M and S, an angular parameter theta=2/pi*atan2(||S||, ||M||) is computed. The theta parameter is converted to a Q14 fixed-point parameter itheta, which is quantized on a scale from 0 to 1 with an interval of 2^-qb, where qb = (b-2*(N-1)*(40-log2_frac(N,4)))/(32*(N-1)), b is the number of bits allocated to the band, and log2_frac() is defined in cwrs.c. From here on, the value of itheta MUST be treated in a bit-exact manner since
+both the encoder and decoder rely on it to infer the bit allocation.
+
+
+Let m=M/||M|| and s=S/||S||; m and s are separately encoded with the PVQ encoder described in . The number of bits allocated to m and s depends on the value of itheta. The number of bits allocated to coding m is obtained by:
+
+
+
+
+imid = bitexact_cos(itheta);
+iside = bitexact_cos(16384-itheta);
+delta = (N-1)*(log2_frac(iside,6)-log2_frac(imid,6))>>2;
+qalloc = log2_frac((1<<qb)+1,4);
+mbits = (b-qalloc/2-delta)/2;
+

+
+
+where bitexact_cos() is a fixed-point cosine approximation that MUST be bit-exact with the reference implementation
+in mathops.h. The spectral folding operation is performed independently for the mid and side vectors.
+
+
+
+
+
+After all the quantization is completed, the quantized energy is used along with the
+quantized normalized band data to resynthesize the MDCT spectrum. The inverse MDCT () and the weighted overlap-add are applied and the signal is stored in the synthesis buffer so it can be used for pitch prediction.
+The encoder MAY omit this step of the processing if it knows that it will not be using
+the pitch predictor for the next few frames. If the de-emphasis filter () is applied to this resynthesized
+signal, then the output will be the same (within numerical precision) as the decoder's output.
+
+
+
+
+
+Each CELT frame can be encoded in a different number of octets, making it possible to vary the bitrate at will. This property can be used to implement source-controlled variable bitrate (VBR). Support for VBR is OPTIONAL for the encoder, but a decoder MUST be prepared to decode a stream that changes its bit-rate dynamically. The method used to vary the bit-rate in VBR mode is left to the implementor, as long as each frame can be decoded by the reference decoder.
+
+
+
--
2.11.0