leansdr::cstln_lut< SOFTSYMB, R > Struct Template Reference

#include <sdr.h>

Inheritance diagram for leansdr::cstln_lut< SOFTSYMB, R >:

Collaboration diagram for leansdr::cstln_lut< SOFTSYMB, R >:

Classes
struct	result

Public Member Functions
	cstln_lut (cstln_base::predef type, float mer=10, float gamma1=0, float gamma2=0, float gamma3=0)
result *	lookup (float I, float Q)
result *	lookup (int I, int Q)
void	dump (FILE *f)
void	harden ()

Public Attributes
int	m_typeCode
int	m_rateCode
bool	m_setByModcod
Public Attributes inherited from leansdr::cstln_base
float	amp_max
complex< int8_t > *	symbols
int	nsymbols
int	nrotations

Private Member Functions
complex< signed char >	polar (float r, int n, float i)
void	polar2 (int i, float r, float a0, float a1, float a2, float a3)
void	make_qam (int n)
void	make_lut_from_symbols (float mer)

Private Attributes
result	lut [R][R]

Additional Inherited Members
Public Types inherited from leansdr::cstln_base
enum	predef {   BPSK, QPSK, PSK8, APSK16,   APSK32, APSK64E, QAM16, QAM64,   QAM256, COUNT }
Static Public Attributes inherited from leansdr::cstln_base
static const char *	names []

Detailed Description

template<typename SOFTSYMB, int R>
struct leansdr::cstln_lut< SOFTSYMB, R >

Definition at line 485 of file sdr.h.

Constructor & Destructor Documentation

cstln_lut()

template<typename SOFTSYMB, int R>

leansdr::cstln_lut< SOFTSYMB, R >::cstln_lut ( cstln_base::predef  type, float  mer = 10, float  gamma1 = 0, float  gamma2 = 0, float  gamma3 = 0  )

inline

Definition at line 487 of file sdr.h.

    {
        switch (type)
        {
        case BPSK:
            amp_max = 1;
            nrotations = 2;
            nsymbols = 2;
            symbols = new complex<signed char>[nsymbols];
#if 0 // BPSK at 0°
            symbols[0] = polar(1, 2, 0);
            symbols[1] = polar(1, 2, 1);
            printf("cstln_lut::cstln_lut: BPSK at 0 degrees\n");
#else // BPSK at 45°
            symbols[0] = polar(1, 8, 1);
            symbols[1] = polar(1, 8, 5);
            printf("cstln_lut::cstln_lut: BPSK at 45 degrees\n");
#endif
            make_lut_from_symbols(mer);
            break;
        case QPSK:
            amp_max = 1;
            // EN 300 421, section 4.5 Baseband shaping and modulation
            // EN 302 307, section 5.4.1
            nrotations = 4;
            nsymbols = 4;
            symbols = new complex<signed char>[nsymbols];
            symbols[0] = polar(1, 4, 0.5);
            symbols[1] = polar(1, 4, 3.5);
            symbols[2] = polar(1, 4, 1.5);
            symbols[3] = polar(1, 4, 2.5);
            make_lut_from_symbols(mer);
            printf("cstln_lut::cstln_lut: QPSK\n");
            break;
        case PSK8:
            amp_max = 1;
            // EN 302 307, section 5.4.2
            nrotations = 8;
            nsymbols = 8;
            symbols = new complex<signed char>[nsymbols];
            symbols[0] = polar(1, 8, 1);
            symbols[1] = polar(1, 8, 0);
            symbols[2] = polar(1, 8, 4);
            symbols[3] = polar(1, 8, 5);
            symbols[4] = polar(1, 8, 2);
            symbols[5] = polar(1, 8, 7);
            symbols[6] = polar(1, 8, 3);
            symbols[7] = polar(1, 8, 6);
            make_lut_from_symbols(mer);
            printf("cstln_lut::cstln_lut: PSK8\n");
            break;
        case APSK16:
        {
            // Default gamma for non-DVB-S2 applications.
            if (gamma1 == 0)
                gamma1 = 2.57;
            // EN 302 307, section 5.4.3
            float r1 = sqrtf(4.0f / (1.0f + 3.0f * gamma1 * gamma1));
            float r2 = gamma1 * r1;
            amp_max = r2;
            nrotations = 4;
            nsymbols = 16;
            symbols = new complex<signed char>[nsymbols];
            symbols[0] = polar(r2, 12, 1.5);
            symbols[1] = polar(r2, 12, 10.5);
            symbols[2] = polar(r2, 12, 4.5);
            symbols[3] = polar(r2, 12, 7.5);
            symbols[4] = polar(r2, 12, 0.5);
            symbols[5] = polar(r2, 12, 11.5);
            symbols[6] = polar(r2, 12, 5.5);
            symbols[7] = polar(r2, 12, 6.5);
            symbols[8] = polar(r2, 12, 2.5);
            symbols[9] = polar(r2, 12, 9.5);
            symbols[10] = polar(r2, 12, 3.5);
            symbols[11] = polar(r2, 12, 8.5);
            symbols[12] = polar(r1, 4, 0.5);
            symbols[13] = polar(r1, 4, 3.5);
            symbols[14] = polar(r1, 4, 1.5);
            symbols[15] = polar(r1, 4, 2.5);
            make_lut_from_symbols(mer);
            printf("cstln_lut::cstln_lut: APSK16: gamma1=%f r1=%f r2=%f\n", gamma1, r1, r2);
            break;
        }
        case APSK32:
        {
            // Default gammas for non-DVB-S2 applications.
            if (gamma1 == 0)
                gamma1 = 2.53;
            if (gamma2 == 0)
                gamma2 = 4.30;
            // EN 302 307, section 5.4.3
            float r1 = sqrtf(
                8.0f / (1.0f + 3.0f * gamma1 * gamma1 + 4 * gamma2 * gamma2));
            float r2 = gamma1 * r1;
            float r3 = gamma2 * r1;
            amp_max = r3;
            nrotations = 4;
            nsymbols = 32;
            symbols = new complex<signed char>[nsymbols];
            symbols[0] = polar(r2, 12, 1.5);
            symbols[1] = polar(r2, 12, 2.5);
            symbols[2] = polar(r2, 12, 10.5);
            symbols[3] = polar(r2, 12, 9.5);
            symbols[4] = polar(r2, 12, 4.5);
            symbols[5] = polar(r2, 12, 3.5);
            symbols[6] = polar(r2, 12, 7.5);
            symbols[7] = polar(r2, 12, 8.5);
            symbols[8] = polar(r3, 16, 1);
            symbols[9] = polar(r3, 16, 3);
            symbols[10] = polar(r3, 16, 14);
            symbols[11] = polar(r3, 16, 12);
            symbols[12] = polar(r3, 16, 6);
            symbols[13] = polar(r3, 16, 4);
            symbols[14] = polar(r3, 16, 9);
            symbols[15] = polar(r3, 16, 11);
            symbols[16] = polar(r2, 12, 0.5);
            symbols[17] = polar(r1, 4, 0.5);
            symbols[18] = polar(r2, 12, 11.5);
            symbols[19] = polar(r1, 4, 3.5);
            symbols[20] = polar(r2, 12, 5.5);
            symbols[21] = polar(r1, 4, 1.5);
            symbols[22] = polar(r2, 12, 6.5);
            symbols[23] = polar(r1, 4, 2.5);
            symbols[24] = polar(r3, 16, 0);
            symbols[25] = polar(r3, 16, 2);
            symbols[26] = polar(r3, 16, 15);
            symbols[27] = polar(r3, 16, 13);
            symbols[28] = polar(r3, 16, 7);
            symbols[29] = polar(r3, 16, 5);
            symbols[30] = polar(r3, 16, 8);
            symbols[31] = polar(r3, 16, 10);
            make_lut_from_symbols(mer);
            printf("cstln_lut::cstln_lut: APSK32: gamma1=%f gamma2=%f, r1=%f r2=%f r3=%f\n", gamma1, gamma2, r1, r2, r3);
            break;
        }
        case APSK64E:
        {
            // Default gammas for non-DVB-S2 applications.
            if (gamma1 == 0)
                gamma1 = 2.4;
            if (gamma2 == 0)
                gamma2 = 4.3;
            if (gamma3 == 0)
                gamma3 = 7.0;
            // EN 302 307-2, section 5.4.5, Table 13e
            float r1 = sqrtf(
                64.0f / (4.0f + 12.0f * gamma1 * gamma1 + 20.0f * gamma2 * gamma2 + 28.0f * gamma3 * gamma3));
            float r2 = gamma1 * r1;
            float r3 = gamma2 * r1;
            float r4 = gamma3 * r1;
            amp_max = r4;
            nrotations = 4;
            nsymbols = 64;
            symbols = new complex<signed char>[nsymbols];
            polar2(0, r4, 1.0 / 4, 7.0 / 4, 3.0 / 4, 5.0 / 4);
            polar2(4, r4, 13.0 / 28, 43.0 / 28, 15.0 / 28, 41.0 / 28);
            polar2(8, r4, 1.0 / 28, 55.0 / 28, 27.0 / 28, 29.0 / 28);
            polar2(12, r1, 1.0 / 4, 7.0 / 4, 3.0 / 4, 5.0 / 4);
            polar2(16, r4, 9.0 / 28, 47.0 / 28, 19.0 / 28, 37.0 / 28);
            polar2(20, r4, 11.0 / 28, 45.0 / 28, 17.0 / 28, 39.0 / 28);
            polar2(24, r3, 1.0 / 20, 39.0 / 20, 19.0 / 20, 21.0 / 20);
            polar2(28, r2, 1.0 / 12, 23.0 / 12, 11.0 / 12, 13.0 / 12);
            polar2(32, r4, 5.0 / 28, 51.0 / 28, 23.0 / 28, 33.0 / 28);
            polar2(36, r3, 9.0 / 20, 31.0 / 20, 11.0 / 20, 29.0 / 20);
            polar2(40, r4, 3.0 / 28, 53.0 / 28, 25.0 / 28, 31.0 / 28);
            polar2(44, r2, 5.0 / 12, 19.0 / 12, 7.0 / 12, 17.0 / 12);
            polar2(48, r3, 1.0 / 4, 7.0 / 4, 3.0 / 4, 5.0 / 4);
            polar2(52, r3, 7.0 / 20, 33.0 / 20, 13.0 / 20, 27.0 / 20);
            polar2(56, r3, 3.0 / 20, 37.0 / 20, 17.0 / 20, 23.0 / 20);
            polar2(60, r2, 1.0 / 4, 7.0 / 4, 3.0 / 4, 5.0 / 4);
            make_lut_from_symbols(mer);
            printf("cstln_lut::cstln_lut: APSK64E: gamma1=%f gamma2=%f, gamm3=%f r1=%f r2=%f r3=%f r4=%f\n", gamma1, gamma2, gamma3, r1, r2, r3, r4);
            break;
        }
        case QAM16:
            amp_max = 0;
            make_qam(16);
            break;
        case QAM64:
            amp_max = 1;
            make_qam(64);
            break;
        case QAM256:
            amp_max = 1;
            make_qam(256);
            break;
        default:
            fail("Constellation not implemented");
        }
    }

Member Function Documentation

dump()

template<typename SOFTSYMB, int R>

void leansdr::cstln_lut< SOFTSYMB, R >::dump ( FILE *  f )

inline

Definition at line 839 of file sdr.h.

    {
        int bps = log2(nsymbols);
        fprintf(f, "P5\n%d %d\n255\n", R, R * (bps + 1));

        for (int bit = 0; bit < bps + 1; ++bit)
        {
            for (int Q = R / 2 - 1; Q >= -R / 2; --Q)
            {
                for (int I = -R / 2; I < R / 2; ++I)
                {
                    result *pr = &lut[I & (R - 1)][Q & (R - 1)];
                    uint8_t v;
                    if (bit < bps)
                        v = softsymb_to_dump(pr->ss, bit);
                    else
                        v = 128 + pr->phase_error / 64;
                    // Highlight the constellation symbols.
                    for (int s = 0; s < nsymbols; ++s)
                    {
                        if (symbols[s].re == I && symbols[s].im == Q)
                            v ^= 128;
                    }

                    fputc(v, f);
                }
            }
        }
    }

harden()

template<typename SOFTSYMB, int R>

void leansdr::cstln_lut< SOFTSYMB, R >::harden ( )

inline

Definition at line 870 of file sdr.h.

    {
        for (int i = 0; i < R; ++i)
        {
            for (int q = 0; q < R; ++q)
                softsymb_harden(&lut[i][q].ss);
        }
    }

lookup() [1/2]

template<typename SOFTSYMB, int R>

result* leansdr::cstln_lut< SOFTSYMB, R >::lookup ( float  I, float  Q  )

inline

Definition at line 689 of file sdr.h.

Referenced by leansdr::viterbi_sync::init_map(), leansdr::cstln_receiver< leansdr::f32, leansdr::eucl_ss >::run(), and leansdr::s2_frame_receiver< T, SOFTSYMB >::track_symbol().

    {
        // Handling of overflows beyond the lookup table:
        // - For BPSK/QPSK/8PSK we only care about the phase,
        //   so the following is harmless and improves locking at low SNR.
        // - For amplitude modulations this is not appropriate.
        //   However, if there is enough noise to cause overflow,
        //   demodulation would probably fail anyway.
        //
        // Comment-out for better throughput at high SNR.
#if 1
        while (I < -128 || I > 127 || Q < -128 || Q > 127)
        {
            I *= 0.5;
            Q *= 0.5;
        }
#endif
        return &lut[(u8)(s8)I][(u8)(s8)Q];
    }

Here is the caller graph for this function:

lookup() [2/2]

template<typename SOFTSYMB, int R>

result* leansdr::cstln_lut< SOFTSYMB, R >::lookup ( int  I, int  Q  )

inline

Definition at line 709 of file sdr.h.

    {
        // Ignore wrapping modulo 256
        return &lut[(u8)I][(u8)Q];
    }

make_lut_from_symbols()

template<typename SOFTSYMB, int R>

void leansdr::cstln_lut< SOFTSYMB, R >::make_lut_from_symbols ( float  mer )

inlineprivate

Definition at line 770 of file sdr.h.

    {
        // Note: Excessively low values of MER will break 16APSK and 32APSK.
        float sigma = cstln_amp * pow(10.0, (-mer / 20));

        // Precomputed values.
        // Shared scope so that we don't have to reset dists2[nsymbols..] to -1.
        struct full_ss fss;

        for (int s = 0; s < 256; ++s)
            fss.dists2[s] = -1;

        for (int I = -R / 2; I < R / 2; ++I)
        {
            for (int Q = -R / 2; Q < R / 2; ++Q)
            {
                // Nearest symbol
                fss.nearest = 0;
                fss.dists2[0] = 65535;
                // Conditional probabilities:
                // Sum likelyhoods from all candidate symbols.
                //
                // P(TX[b]==B | RX==IQ) =
                //   sum(S=0..nsymbols-1, P(TX[b]==B | RX==IQ && TXs==S))
                //
                // P(TX[b] == B | RX==IQ && TX==S) =
                //   P(TX[b]==B && RX==IQ && TX==S) / P(RX==IQ && TX==S)
                float probs[8][2];
                memset(probs, 0, sizeof(probs));

                for (int s = 0; s < nsymbols; ++s)
                {
                    float d2 = ((I - symbols[s].re) * (I - symbols[s].re) + (Q - symbols[s].im) * (Q - symbols[s].im));

                    if (d2 < fss.dists2[fss.nearest])
                        fss.nearest = s;

                    fss.dists2[s] = d2;
                    float p = expf(-d2 / (2 * sigma * sigma)) / (sqrtf(2 * M_PI) * sigma);

                    for (int bit = 0; bit < 8; ++bit)
                    {
                        probs[bit][(s >> bit) & 1] += p;
                    }
                }

                // Normalize
                for (int b = 0; b < 8; ++b)
                {
                    float p = probs[b][1] / (probs[b][0] + probs[b][1]);
                    // Avoid trouble when sigma is unrealistically low.
                    if (!isnormal(p))
                        p = 0;
                    fss.p[b] = p;
                }

                result *pr = &lut[I & (R - 1)][Q & (R - 1)];
                to_softsymb(&fss, &pr->ss);
                // Always record nearest symbol and phase error for C&T.
                pr->symbol = fss.nearest;
                float ph_symbol = atan2f(symbols[pr->symbol].im,
                                         symbols[pr->symbol].re);
                float ph_err = atan2f(Q, I) - ph_symbol;
                pr->phase_error = (int32_t)(ph_err * 65536 / (2 * M_PI)); // Mod 65536
            }
        }
    }

make_qam()

template<typename SOFTSYMB, int R>

void leansdr::cstln_lut< SOFTSYMB, R >::make_qam ( int  n )

inlineprivate

Definition at line 736 of file sdr.h.

    {
        nrotations = 4;
        nsymbols = n;
        symbols = new complex<signed char>[nsymbols];
        int m = sqrtl(n);
        float scale;

        { // Average power in first quadrant with unit grid
            int q = m / 2;
            float avgpower = 2 * (q * 0.25 + (q - 1) * q / 2.0 + (q - 1) * q * (2 * q - 1) / 6.0) / q;
            scale = 1.0 / sqrtf(avgpower);
        }
        // Arbitrary mapping

        int s = 0;

        for (int x = 0; x < m; ++x)
        {
            for (int y = 0; y < m; ++y)
            {
                float I = x - (float)(m - 1) / 2;
                float Q = y - (float)(m - 1) / 2;
                symbols[s].re = I * scale * cstln_amp;
                symbols[s].im = Q * scale * cstln_amp;
                ++s;
            }
        }

        make_lut_from_symbols(20); // TBD
    }

polar()

template<typename SOFTSYMB, int R>

complex<signed char> leansdr::cstln_lut< SOFTSYMB, R >::polar ( float  r, int  n, float  i  )

inlineprivate

Definition at line 716 of file sdr.h.

    {
        float a = i * 2 * M_PI / n;
        return complex<signed char>(r * cosf(a) * cstln_amp,
                                    r * sinf(a) * cstln_amp);
    }

polar2()

template<typename SOFTSYMB, int R>

void leansdr::cstln_lut< SOFTSYMB, R >::polar2 ( int  i, float  r, float  a0, float  a1, float  a2, float  a3  )

inlineprivate

Definition at line 724 of file sdr.h.

    {
        float a[] = {a0, a1, a2, a3};

        for (int j = 0; j < 4; ++j)
        {
            float phi = a[j] * M_PI;
            symbols[i + j] = complex<signed char>(r * cosf(phi) * cstln_amp,
                                                  r * sinf(phi) * cstln_amp);
        }
    }

Member Data Documentation

lut

template<typename SOFTSYMB, int R>

result leansdr::cstln_lut< SOFTSYMB, R >::lut[R][R]

private

Definition at line 768 of file sdr.h.

m_rateCode

template<typename SOFTSYMB, int R>

int leansdr::cstln_lut< SOFTSYMB, R >::m_rateCode

Definition at line 880 of file sdr.h.

Referenced by leansdr::s2_frame_receiver< T, SOFTSYMB >::run_frame_locked().

m_setByModcod

template<typename SOFTSYMB, int R>

bool leansdr::cstln_lut< SOFTSYMB, R >::m_setByModcod

Definition at line 881 of file sdr.h.

m_typeCode

template<typename SOFTSYMB, int R>

int leansdr::cstln_lut< SOFTSYMB, R >::m_typeCode

Definition at line 879 of file sdr.h.

---

The documentation for this struct was generated from the following file:

• plugins/channelrx/demoddatv/leansdr/sdr.h