Method _decode

src/Module/Decoder/BCH/Standard/Decoder_BCH_std.cpp:53–221

template<typename B, typename R>
int
Decoder_BCH_std<B, R>::_decode(B* Y_N, const size_t frame_id)
{
    int i, j, syn_error = 0;

    /* first form the syndromes */
    for (i = 1; i <= t2; i++)
    {
        s[i] = 0;
        for (j = 0; j < this->N; j++)
            if (Y_N[j] != 0) s[i] ^= alpha_to[(i * j) % this->N_p2_1];
        if (s[i] != 0) syn_error = 1; /* set error flag if non-zero syndrome */
        /* convert syndrome from polynomial form to index form  */
        s[i] = (int)index_of[s[i]];
    }

    this->last_is_codeword[frame_id] = !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 :   d[u] is the 'mu'th discrepancy, where
         * u='mu'+1 and 'mu' (the Greek letter!) is the step number
         * ranging from -1 to 2*this->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 (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 (i = 0; i <= l[u]; i++)
                {
                    elp[u + 1][i] = elp[u][i];
                    elp[u][i] = (int)index_of[elp[u][i]];
                }
            }