Human hearing is very sensitive to noise in frequency regions where the audio signal is quiet, and less sensitive to noise where the signal is loud (called noise masking). SNS exploits this by making the quantization noise in quiet frequency regions smaller and the noise in loud regions larger — overall, the noise is perceptually hidden under the signal.

SNS works by computing 16 scale factors (one per group of 4 bands), quantizing them with 38 bits total, interpolating them back to 64 per-band values, and then multiplying each MDCT coefficient by its corresponding scale factor. This shapes (normalizes) the spectrum so that the spectral quantizer that follows can apply a uniform step size across all bands — the non-uniform energy is “pre-normalized” away.

SNS always works with 64 bands. If the actual NB < 64 (only happens for 7.5 ms at 8 kHz where NB = 60), the EB array is padded to 64 by duplicating the lowest-frequency entries. This ensures the VQ operates on the same-size input regardless of configuration.

The 64-band energy array EB is smoothed with a 3-tap FIR filter to remove sharp variations between adjacent bands:

A frequency tilt is applied to boost high-frequency energy, compensating for the natural roll-off in audio spectra:

Noise floor: A minimum noise floor of −40 dB relative to the average band energy is added to EP(b) to prevent zero or near-zero energy bands from causing extreme scale factors.

Log transform: The energy is converted to a log scale (log2) halved, giving EL(b) in units of bits/2.

Band grouping: The 64-band log-energy vector EL is downsampled to 16 values E4(b2) using a 6-tap FIR filter with weights {1,2,3,3,2,1}/12. Each output E4(b2) represents a group of 4 adjacent bands, with weighted overlap at the edges.

Mean removal + scaling: The mean is removed and the result is scaled by 0.85 to produce the initial 16 scale factors scf0(b2).

Attack handling: If Fatt(k) = 1 (attack detected), the scale factors are additionally smoothed across bands to reduce temporal pre-echo artifacts. The smoothing factor is 0.5 for 10 ms and 0.3 for 7.5 ms frames.

The final 16 scale factors scf(n) describe the relative spectral energy shape of the current frame. These 16 values are then quantized and transmitted to the decoder.

The 16 scale factors are split into two halves: scf(0..7) and scf(8..15). Each half is independently quantized using a pre-trained codebook with 32 entries of dimension 8:

The closest codebook entry to each half is found by minimum MSE. The combined first-stage vector st1 is formed by joining the two best-match codebook entries. The Stage 1 residual r1 = scf − st1 captures what Stage 1 missed.

The Stage 2 PVQ quantizer works in a DCT-rotated domain. First, the 16-dimensional stage 1 residual r1 is rotated using a 16×16 DCT matrix D: t2rot = D × r1. This decorrelates the residual, making PVQ search more efficient.

Four shape candidates are evaluated:

A PVQ(N, K) vector has N dimensions and exactly K unit pulses. The “regular” shapes concentrate pulses in the lower 10 coefficients (lower SNS frequency), while the “outlier” shapes spread them over all 16 (for signals with outlier high-frequency components).

For each shape, an adjustment gain index (gain_i) is also searched, giving 18 total gain-shape combinations. The combination minimizing MSE in the rotated domain is selected. The selected shape vector is then IDCT-rotated back: scfQ = st1 + Gain × DT × xq.

The PVQ enumeration (converting the integer pulse vector to a compact index called MPVQ index + leading sign) uses a recursive offset table from Section 3.7.3.2.

The 16 quantized scale factors scfQ(n) are interpolated to 64 values (one per band) using piecewise linear interpolation with steps of 1/8 between consecutive scale factor pairs:

Finally, the log-domain scale factors are converted back to linear multipliers:

Note: At the encoder, the sign is negative (dividing by the scale factor normalizes the spectrum). At the decoder, the sign is positive (multiplying by the scale factor re-introduces the spectral shape).

The interpolated scale factors gSNS(b) are applied to the MDCT coefficients. All coefficients within band b are multiplied by the same scale factor:

for b = 0 to NB−1:
    for k = Ifs(b) to Ifs(b+1)−1:
        Xs(k) = X(k) × gSNS(b)

The output Xs(k) is the SNS-shaped spectrum that is passed to TNS (Section 3.3.8) for further noise shaping.

/* SNS Analysis — simplified C (Section 3.3.7.2) */

/* Step 1: Smoothing  */
float ES[64];
ES[0]  = 0.75f * EB[0] + 0.25f * EB[1];
ES[63] = 0.25f * EB[62] + 0.75f * EB[63];
for (int b = 1; b < 63; b++)
    ES[b] = 0.25f * EB[b-1] + 0.5f * EB[b] + 0.25f * EB[b+1];

/* Step 2: Pre-emphasis (gtilt depends on fs) */
float EP[64];
for (int b = 0; b < 64; b++)
    EP[b] = ES[b] * powf(10.0f, (float)b * gtilt / 630.0f);

/* Step 3: Noise floor at -40 dB relative to mean */
float sum = 0.0f;
for (int b = 0; b < 64; b++) sum += EP[b];
float noise_floor = fmaxf((sum / 64.0f) * 1e-4f, powf(2.0f, -32.0f));
for (int b = 0; b < 64; b++)
    EP[b] = fmaxf(EP[b], noise_floor);

/* Step 4: Log transform */
float EL[64];
for (int b = 0; b < 64; b++)
    EL[b] = log2f(1e-31f + EP[b]) / 2.0f;

/* Step 5: Band grouping - downsample 64 bands to 16 using weighted filter */
float w[6] = {1.0f/12, 2.0f/12, 3.0f/12, 3.0f/12, 2.0f/12, 1.0f/12};
float E4[16];
for (int b2 = 0; b2 < 16; b2++) {
    float e = 0.0f;
    for (int k = 0; k < 6; k++) {
        int idx = 4*b2 + k - 1;
        idx = (idx < 0) ? 0 : (idx > 63) ? 63 : idx;
        e += w[k] * EL[idx];
    }
    E4[b2] = e;
}

/* Step 6: Mean removal + 0.85 scaling */
float mean = 0.0f;
for (int n = 0; n < 16; n++) mean += E4[n];
mean /= 16.0f;
float scf[16];
for (int n = 0; n < 16; n++)
    scf[n] = 0.85f * (E4[n] - mean);