After SNS shapes the spectrum so that quantization noise follows the signal energy across frequencies, there is still a second problem: the MDCT frame may contain a strong temporal event (like a vowel or a burst) concentrated in part of the frame’s time span. The quantization noise for this frame is spread across the whole time duration — you may hear a “pre-echo” before the burst.

TNS solves this by applying a linear prediction (LPC) filter in the frequency domain. This is the dual operation of time-domain LPC: instead of predicting time samples from past time samples, TNS predicts spectral coefficients from neighboring spectral coefficients. The effect is to concentrate the quantization noise temporally, reducing pre-echo.

Key facts about TNS in LC3:

• Up to 2 TNS filters per frame (1 for NB/WB/SSWB, 2 for SWB/FB)
• Each filter covers a specific frequency sub-range determined by the detected bandwidth
• Order: up to 8 reflection coefficients per filter
• TNS is disabled when near_nyquist_flag = 1 (to avoid aliasing artifacts)

TNS analysis is done independently for each filter f. The SNS-shaped spectrum Xs(k) (output of Section 3.3.7.5) is used as input. The analysis computes LPC coefficients and then converts them to reflection coefficients.

Step 1: Autocorrelation of the spectral sub-band

Each filter covers 3 sub-bands (sub_start, sub_stop from Table 3.15). The normalized autocorrelation r(k) for lags k = 0..8 is computed. If all three sub-band energies e(s) are zero, r(k) defaults to {3, 0, 0, …}.

Step 2: Lag windowing

This Gaussian window reduces the autocorrelation at higher lags, which stabilizes the Levinson-Durbin recursion by broadening spectral peaks.

Step 3: Levinson-Durbin recursion

The Levinson-Durbin algorithm converts the autocorrelation sequence rw into LPC coefficients a(k) (order 8) and a prediction error err:

err = rw[0];  a[0] = 1;
for k = 1 to 8:
    rc = − SUM(a[n] × rw[k−n], n=0..k−1) / err
    tmp[0..k] = update using a and rc
    a[0..k] = tmp[0..k]
    err = (1 − rc²) × err

Step 4: Prediction gain check

The TNS filter f is activated only if the prediction gain exceeds 1.5:

predGain = 1.5 means the LPC model explains only a modest amount of the spectral variance. Below this threshold, TNS would add complexity without meaningful benefit.

Step 5: LPC weighting (low bitrate only)

At low bitrates (nbits < 48 × Nms), LPC coefficients are bandwidth-expanded with a weighting factor γ to reduce filter sharpness:

Step 6: Convert LPC to reflection coefficients

The weighted LPC coefficients aw are converted back to 8 reflection coefficients rc(k) using the step-down procedure (inverse Levinson). The final rc(k, f) values are what get quantized and transmitted.

If TNS filter f is off: all rc(k, f) = 0.

Each reflection coefficient rc(k, f) is in the range (−1, 1). They are quantized using a uniform scalar quantizer in the arcsine domain — this spreads the quantization levels more evenly across the distribution of reflection coefficient values:

The index rci ranges from 0 to 16 (17 levels, centered at 8 which corresponds to rc = 0). The quantized value rcq is the sine of the dequantized arcsine index.

Filter order determination: The effective filter order rcorder(f) is the largest k+1 for which rcq(k, f) ≠ 0. Trailing zero coefficients are not transmitted.

Bit count for TNS:

The tables ac_tns_order_bits and ac_tns_coef_bits are in Section 3.7.5. They give the fractional bit costs (scaled by 2048) for arithmetic coding.

The actual filtering of the spectrum is done using a lattice structure, which implements the all-zero (FIR analysis) filter for each active TNS filter. The lattice form is used because it is numerically stable and directly uses the reflection coefficients without converting them to direct-form FIR coefficients.

The filter processes the spectral range [start_freq(f), stop_freq(f)) of Xs(k):

/* TNS Analysis Lattice Filter — Section 3.3.8.4 */
/* Initialize lattice states */
float st[8] = {0};

for each active filter f (f = 0 to num_tns_filters−1):
    if rcorder(f) > 0:
        for n = start_freq(f) to stop_freq(f)−1:
            t = Xs(n)
            st_save = t
            for k = 0 to rcorder(f)−2:
                st_tmp = rcq(k,f) * t + st[k]
                t      = t + rcq(k,f) * st[k]
                st[k]  = st_save
                st_save = st_tmp
            t        = t + rcq(rcorder(f)−1, f) * st[rcorder(f)−1]
            st[rcorder(f)−1] = st_save
            Xf(n) = t   /* filtered output */

The output Xf(k) is the TNS-filtered spectrum. The lattice states carry over from filter 0 to filter 1 if there are two filters. The initial state is all zeros at the start of each frame.

At the decoder, the inverse operation (synthesis filter — all-pole IIR) is applied to reconstruct Xs from Xf. The synthesis filter uses the same reflection coefficients but in reverse order and with opposite sign operations.