Method _decode

src/Module/Decoder/RS/Standard/Decoder_RS_std.cpp:40–245

template<typename B, typename R>
int
Decoder_RS_std<B, R>::_decode(S* Y_N, const size_t /*frame_id*/)
{
    bool syn_error = false;

    // first form the syndromes
    for (auto i = 1; i <= t2; i++)
    {
        s[i] = 0;
        for (auto j = 0; j < this->N_rs; j++)
        {
            auto y_idx = this->index_of[Y_N[j]];
            if (y_idx != -1) s[i] ^= this->alpha_to[(y_idx + i * j) % this->N_p2_1];
        }

        syn_error |= s[i] != 0; // set error flag if non-zero syndrome

        s[i] = this->index_of[s[i]]; // convert syndrome from polynomial form to index form
    }

    this->last_is_codeword = !syn_error;

    if (syn_error) // if there are errors, try to correct them
    {
        /*
         * Compute the error location polynomial via the Berlekamp
         * iterative algorithm. Following the terminology of Lin and
         * Costello's book :   discrepancy[u] is the 'mu'th discrepancy, where
         * u='mu'+1 and 'mu' (the Greek letter!) is the step number
         * ranging from -1 to 2*t (see L&C),  l[u] is the degree of
         * the elp at that step, and u_l[u] is the difference between
         * the step number and the degree of the elp.
         */
        // initialise table entries
        discrepancy[0] = 0;    // index form
        discrepancy[1] = s[1]; // index form
        elp[0][0] = 0;         // index form
        elp[1][0] = 1;         // polynomial form
        for (auto i = 1; i < t2; i++)
        {
            elp[0][i] = -1; // index form
            elp[1][i] = 0;  // polynomial form
        }
        l[0] = 0;
        l[1] = 0;
        u_lu[0] = -1;
        u_lu[1] = 0;

        int q, u = 0;
        do
        {
            u++;
            if (discrepancy[u] == -1)
            {
                l[u + 1] = l[u];
                for (auto i = 0; i <= l[u]; i++)
                {
                    elp[u + 1][i] = elp[u][i];