The SNS decoder performs three steps in order:

The quantized scale factors are identical to those computed by the encoder — there is no additional error beyond what the encoder’s two-stage VQ introduces.

Stage 1 reads ind_LF (5 bits) and ind_HF (5 bits) from the bitstream and reconstructs the first-stage vector st1 from the LFCB and HFCB codebook tables:

Stage 2 reads the jointly encoded shape and gain bits from the bitstream. The reading and demultiplexing is the exact reverse of the encoder’s multiplexing:

The joint index is then split using the dec_split_st2VQ_CW function into submodeLSB, idxA, and (for regular shapes) LS_indB and idxB. The final shape_j and gain_i are recovered:

The dec_split_st2VQ_CW function handles the four submode cases (regular, regular_lf, outlier_near, outlier_far) and sets BEC_detect if the received joint index is out of the valid range for the decoded submode.

MPVQ de-enumeration converts the (LS_ind, MPVQ_ind) pair back to a signed integer PVQ pulse train vector y. This is the inverse of the MPVQ enumeration done by the encoder.

The algorithm uses the MPVQ_offsets table from Section 3.7.3.2. Starting from position 0 and walking forward to dim_in−1, it determines how many pulses are at each position using table lookups:

/* MPVQdeenum: convert (LS_ind, MPVQ_ind) → signed integer PVQ vector y */
/* Simplified flow: */
leading_sign = (LS_ind != 0) ? −1 : +1;
for pos = 0 to dim_in−1:
    if ind != 0:
        /* Find how many pulses go at this position using MPVQ_offsets */
        k_acc = k_max_local
        while ind < MPVQ_offsets[dim_in−1−pos][k_acc]: k_acc--
        /* Set vec_out[pos] based on k_delta and leading_sign */
        /* Update leading_sign from the next bits of ind */
        k_max_local -= k_delta
    else:
        vec_out[pos] = leading_sign × k_max_local
        break

The de-enumeration calls for each shape are in Table 3.21. For shape_j=0, two separate calls are made: MPVQdeenum(10,10,LS_indA,idxA,y0) for set A positions, and MPVQdeenum(6,1,LS_indB,idxB,z) for set B positions.

Unit energy normalization: The de-enumerated integer vector y_shape_j is normalized to unit energy over 16 dimensions: xq = y / sqrt(yT × y).

Scale factor synthesis: The adjustment gain G for (gain_i, shape_j) is looked up from Table 3.11. Then the quantized scale factor vector is reconstructed using the IDCT rotation (D^T matrix from Section 3.7.3.2):

This is identical to Equation 62 used by the encoder to synthesize the quantized scale factors from Stage 1 and Stage 2 components.

The 16 scfQ values are interpolated to 64 values using the same formula as the encoder (Equation 123 = identical to Equation 63 at the encoder). The NB < 64 reduction and linear domain conversion are also identical:

Note the critical sign difference from the encoder: here the sign is positive (multiplication = amplifying). At the encoder, the sign was negative (division = attenuating). The SNS encoder attenuates the spectrum by gSNS; the decoder amplifies it back.

The interpolated decoder-side scale factors gSNS(b) are applied to the TNS-decoded spectrum X̂s(k) to produce the final reconstructed spectrum X̂(k):

for (b = 0; b < Nb; b++) {
    for (k = Ifs(b); k < Ifs(b+1); k++) {
        Xh[k] = Xsh[k] * gSNS(b);   /* multiply (decoder) vs divide (encoder) */
    }
}

The output X̂(k) is the fully reconstructed spectral representation. It is now passed to the inverse LD-MDCT (Section 3.4.8) to convert back to the time domain.