leansdr::s2_frame_receiver< T, SOFTSYMB > Struct Template Reference

#include <dvbs2.h>

Inheritance diagram for leansdr::s2_frame_receiver< T, SOFTSYMB >:

Collaboration diagram for leansdr::s2_frame_receiver< T, SOFTSYMB >:

Classes
struct	sampler_state
struct	sync

Public Types
enum	{ COARSE_FREQ, FRAME_SEARCH, FRAME_LOCKED }

Public Member Functions
	s2_frame_receiver (scheduler *sch, sampler_interface< T > *_sampler, pipebuf< complex< T >> &_in, pipebuf< plslot< SOFTSYMB >> &_out, pipebuf< float > *_freq_out=NULL, pipebuf< float > *_ss_out=NULL, pipebuf< float > *_mer_out=NULL, pipebuf< complex< float >> *_cstln_out=NULL, pipebuf< complex< float >> *_cstln_pls_out=NULL, pipebuf< complex< float >> *_symbols_out=NULL, pipebuf< int > *_state_out=NULL)
void	run ()
void	init_coarse_freq ()
void	enter_coarse_freq ()
void	run_frame_coarse ()
void	enter_frame_search ()
void	run_frame_search ()
void	enter_frame_locked ()
void	run_frame_locked ()
void	shutdown ()
void	init_agc (const complex< T > *buf, int n)
void	track_agc (const complex< float > &p)
void	update_agc ()
complex< float >	descramble (sampler_state *ss, const complex< float > &p)
complex< float >	interp_next (sampler_state *ss)
void	align_phase (sampler_state *ss, const complex< float > &c)
uint8_t	track_symbol (sampler_state *ss, const complex< float > &p, cstln_lut< SOFTSYMB, 256 > *c, int mode)
void	add_syncs (cstln_lut< SOFTSYMB, 256 > *c)
Public Member Functions inherited from leansdr::runnable
	runnable (scheduler *_sch, const char *name)
Public Member Functions inherited from leansdr::runnable_common
	runnable_common (const char *_name)
virtual	~runnable_common ()

Public Attributes
sampler_interface< T > *	sampler
int	meas_decimation
float	Ftune
float	Fm
bool	strongpls
enum leansdr::s2_frame_receiver:: { ... }	state
float	min_freqw16
float	max_freqw16
complex< float >	diffcorr
int	coarse_count
float	freqw16
float	phase16
float	mu
float	omega
struct {
complex< float >   p
complex< float >   c
}	hist [3]
float	in_power
float	ev_power
float	agc_gain
float	agc_bw
cstln_lut< SOFTSYMB, 256 > *	qpsk
struct leansdr::s2_frame_receiver::sync	syncs [MAXSYNCS]
struct leansdr::s2_frame_receiver::sync *	current_sync [MAXSYNCS]
int	nsyncs
s2_plscodes< T >	plscodes
cstln_lut< SOFTSYMB, 256 > *	cstln
trig16	trig
modcod_info *	mcinfo
pipereader< complex< T > >	in
pipewriter< plslot< SOFTSYMB > >	out
int	meas_count
pipewriter< float > *	freq_out
pipewriter< float > *	ss_out
pipewriter< float > *	mer_out
pipewriter< complex< float > > *	cstln_out
pipewriter< complex< float > > *	cstln_pls_out
pipewriter< complex< float > > *	symbols_out
pipewriter< int > *	state_out
bool	report_state
s2_scrambling	scrambling
s2_sof< T >	sof
int	m_modcodType
int	m_modcodRate
Public Attributes inherited from leansdr::runnable_common
const char *	name

Static Public Attributes
static const int	MAX_SYMBOLS_PER_FRAME
static const int	MAXSYNCS = 8
static const int	MAX_SLOTS = 240
static const int	MAX_SYMBOLS

Additional Inherited Members
Protected Attributes inherited from leansdr::runnable
scheduler *	sch

Detailed Description

template<typename T, typename SOFTSYMB>
struct leansdr::s2_frame_receiver< T, SOFTSYMB >

Definition at line 436 of file dvbs2.h.

Member Enumeration Documentation

anonymous enum

template<typename T, typename SOFTSYMB>

anonymous enum

Enumerator
COARSE_FREQ
FRAME_SEARCH
FRAME_LOCKED

Definition at line 490 of file dvbs2.h.

    {
        COARSE_FREQ,
        FRAME_SEARCH,
        FRAME_LOCKED,
    } state;

Constructor & Destructor Documentation

s2_frame_receiver()

template<typename T, typename SOFTSYMB>

leansdr::s2_frame_receiver< T, SOFTSYMB >::s2_frame_receiver ( scheduler *  sch, sampler_interface< T > *  _sampler, pipebuf< complex< T >> &  _in, pipebuf< plslot< SOFTSYMB >> &  _out, pipebuf< float > *  _freq_out = NULL, pipebuf< float > *  _ss_out = NULL, pipebuf< float > *  _mer_out = NULL, pipebuf< complex< float >> *  _cstln_out = NULL, pipebuf< complex< float >> *  _cstln_pls_out = NULL, pipebuf< complex< float >> *  _symbols_out = NULL, pipebuf< int > *  _state_out = NULL  )

inline

Definition at line 446 of file dvbs2.h.

References leansdr::cstln_base::QPSK.

        : runnable(sch, "S2 frame receiver"),
          sampler(_sampler),
          meas_decimation(1048576),
          Ftune(0), Fm(0),
          strongpls(false),
          in_power(0), ev_power(0), agc_gain(1), agc_bw(1e-3),
          nsyncs(0),
          cstln(NULL),
          in(_in), out(_out, 1 + modcod_info::MAX_SLOTS_PER_FRAME),
          meas_count(0),
          freq_out(opt_writer(_freq_out)),
          ss_out(opt_writer(_ss_out)),
          mer_out(opt_writer(_mer_out)),
          cstln_out(opt_writer(_cstln_out, 1024)),
          cstln_pls_out(opt_writer(_cstln_pls_out, 1024)),
          symbols_out(opt_writer(_symbols_out, MAX_SYMBOLS_PER_FRAME)),
          state_out(opt_writer(_state_out)),
          report_state(false),
          scrambling(0),
          m_modcodType(-1),
          m_modcodRate(-1)
    {
        // Constellation for PLS
        qpsk = new cstln_lut<SOFTSYMB, 256>(cstln_base::QPSK);
        add_syncs(qpsk);

        init_coarse_freq();

#if TEST_DIVERSITY
        fprintf(stderr, "** DEBUG: Diversity test mode (slower)\n");
#endif
    }

Member Function Documentation

add_syncs()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::add_syncs ( cstln_lut< SOFTSYMB, 256 > *  c )

inline

Definition at line 1155 of file dvbs2.h.

References leansdr::fail(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sync::hist, i, leansdr::complex< T >::im, M_PI, leansdr::cstln_base::nrotations, leansdr::cstln_base::nsymbols, leansdr::s2_frame_receiver< T, SOFTSYMB >::sync::offset16, leansdr::complex< T >::re, leansdr::cstln_base::symbols, and leansdr::s2_frame_receiver< T, SOFTSYMB >::sync::tobpsk.

    {
        int random_decision = 0;
        int nrot = c->nrotations;
#if 0
      if ( nrot == 4 ) {
    fprintf(stderr, "Special case for 8PSK locking as QPSK pi/8\n");
    nrot = 8;
      }
#endif
        for (int r = 0; r < nrot; ++r)
        {
            if (nsyncs == MAXSYNCS)
                fail("Bug: too many syncs");
            sync *s = &syncs[nsyncs++];
            s->offset16 = 65536.0 * r / nrot;
            float angle = -2 * M_PI * r / nrot;
            s->tobpsk = 0;
            for (int i = c->nsymbols; i--;)
            {
                complex<int8_t> p = c->symbols[i];
                float re = p.re * cosf(angle) - p.im * sinf(angle);
                float im = p.re * sinf(angle) + p.im * cosf(angle);
                int bit;
                if (im > 1)
                    bit = 0;
                else if (im < -1)
                    bit = 1;
                else
                {
                    bit = random_decision;
                    random_decision ^= 1;
                } // Near 0
                s->tobpsk = (s->tobpsk << 1) | bit;
            }
            s->hist = 0;
        }
    }

Here is the call graph for this function:

align_phase()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::align_phase ( sampler_state *  ss, const complex< float > &  c  )

inline

Definition at line 1073 of file dvbs2.h.

References leansdr::complex< T >::im, M_PI, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::ph16, and leansdr::complex< T >::re.

    {
#if 0
      // Reference implementation
      float err = atan2f(c.im,c.re) * (65536/(2*M_PI));
#else
        // Same performance as atan2f, faster
        if (!c.re)
            return;
        float err = c.im / c.re * (65536 / (2 * M_PI));
#endif
        ss->ph16 += err;
    }

descramble()

template<typename T, typename SOFTSYMB>

complex<float> leansdr::s2_frame_receiver< T, SOFTSYMB >::descramble ( sampler_state *  ss, const complex< float > &  p  )

inline

Definition at line 1018 of file dvbs2.h.

References leansdr::complex< T >::im, leansdr::complex< T >::re, and leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::scr.

    {
        int r = *ss->scr++;
        complex<float> res;
        switch (r)
        {
        case 3:
            res.re = -p.im;
            res.im = p.re;
            break;
        case 2:
            res.re = -p.re;
            res.im = -p.im;
            break;
        case 1:
            res.re = p.im;
            res.im = -p.re;
            break;
        default:
            res = p;
        }
        return res;
    }

enter_coarse_freq()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::enter_coarse_freq ( )

inline

Definition at line 556 of file dvbs2.h.

References leansdr::opt_write().

    {
        opt_write(state_out, 0);
        init_coarse_freq();
    }

Here is the call graph for this function:

enter_frame_locked()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::enter_frame_locked ( )

inline

Definition at line 673 of file dvbs2.h.

References leansdr::opt_write().

    {
        opt_write(state_out, 1);
        if (sch->debug)
            fprintf(stderr, "LOCKED\n");
        state = FRAME_LOCKED;
    }

Here is the call graph for this function:

enter_frame_search()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::enter_frame_search ( )

inline

Definition at line 595 of file dvbs2.h.

References leansdr::opt_write().

    {
        opt_write(state_out, 0);
        mu = 0;
        phase16 = 0;
        if (sch->debug)
            fprintf(stderr, "ACQ\n");
        state = FRAME_SEARCH;
    }

Here is the call graph for this function:

init_agc()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::init_agc ( const complex< T > *  buf, int  n  )

inline

Definition at line 988 of file dvbs2.h.

References leansdr::cnorm2(), and i.

    {
        in_power = 0;
        for (int i = 0; i < n; ++i)
            in_power += cnorm2(buf[i]);
        in_power /= n;
    }

Here is the call graph for this function:

init_coarse_freq()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::init_coarse_freq ( )

inline

Definition at line 547 of file dvbs2.h.

    {
        diffcorr = 0;
        coarse_count = 0;
        memset(hist, 0, sizeof(hist));
        state = COARSE_FREQ;
    }

interp_next()

template<typename T, typename SOFTSYMB>

complex<float> leansdr::s2_frame_receiver< T, SOFTSYMB >::interp_next ( sampler_state *  ss )

inline

Definition at line 1044 of file dvbs2.h.

References leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::fw16, leansdr::sampler_interface< T >::interp(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::mu, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::p, and leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::ph16.

    {
        // Skip to next sample
        while (ss->mu >= 1)
        {
            ++ss->p;
            ss->mu -= 1.0f;
        }
        // Interpolate
#if 0
      // Interpolate linearly then derotate.
      // This will fail with large carrier offsets (e.g. --tune).
      float cmu = 1.0f - ss->mu;
      complex<float> s(ss->p[0].re*cmu + ss->p[1].re*ss->mu,
               ss->p[0].im*cmu + ss->p[1].im*ss->mu);
      ss->mu += omega;
      // Derotate
      const complex<float> &rot = trig.expi(-ss->ph16);
      ss->ph16 += ss->fw16;
      return rot * s;
#else
        // Use generic interpolator
        complex<float> s = sampler->interp(ss->p, ss->mu, ss->ph16);
        ss->mu += omega;
        ss->ph16 += ss->fw16;
        return s;
#endif
    }

Here is the call graph for this function:

run()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 510 of file dvbs2.h.

References leansdr::modcod_info::MAX_SLOTS_PER_FRAME, leansdr::opt_writable(), leansdr::opt_write(), and leansdr::sampler_interface< T >::readahead().

    {
        // Require enough samples to detect one plheader,
        // TBD margin ?
        int min_samples = (1 + MAX_SYMBOLS_PER_FRAME +
                           plslot<SOFTSYMB>::LENGTH) *
                          omega * 2;
        while (in.readable() >= min_samples + sampler->readahead() &&
               out.writable() >= 1 + modcod_info::MAX_SLOTS_PER_FRAME &&
               opt_writable(freq_out, 1) &&
               opt_writable(ss_out, 1) &&
               opt_writable(mer_out, 1) &&
               opt_writable(symbols_out, MAX_SYMBOLS_PER_FRAME) &&
               opt_writable(state_out, 1))
        {
            if (report_state)
            {
                // Report unlocked state on first invocation.
                opt_write(state_out, 0);
                report_state = false;
            }
            switch (state)
            {
            case COARSE_FREQ:
                run_frame_coarse();
                break;
            case FRAME_SEARCH:
                run_frame_search();
                break;
            case FRAME_LOCKED:
                run_frame_locked();
                break;
            }
        }
    }

Here is the call graph for this function:

run_frame_coarse()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::run_frame_coarse ( )

inline

Definition at line 562 of file dvbs2.h.

References leansdr::complex< T >::im, M_PI, and leansdr::complex< T >::re.

    {
        freqw16 = 65536 * Ftune;
        min_freqw16 = freqw16 - 65536.0 / 9;
        max_freqw16 = freqw16 + 65536.0 / 9;

        complex<T> *pin = in.rd();
        complex<T> p = *pin++;
        int nsamples = MAX_SYMBOLS_PER_FRAME * omega;
        for (int s = nsamples; s--; ++pin)
        {
            complex<T> n = *pin;
            diffcorr.re += p.re * n.re + p.im * n.im;
            diffcorr.im += p.re * n.im - p.im * n.re;
            p = n;
        }
        in.read(nsamples);
        ++coarse_count;
        if (coarse_count == 50)
        {
            float freqw = atan2f(diffcorr.im, diffcorr.re) * omega;
            fprintf(stderr, "COARSE(%d): %f rad/symb (%.0f Hz at %.0f baud)\n",
                    coarse_count, freqw, freqw * Fm / (2 * M_PI), Fm);
#if 0
    freqw16 = freqw * 65536 / (2*M_PI);
#else
            fprintf(stderr, "Ignoring coarse det, using %f\n", freqw16 * Fm / 65536);
#endif
            enter_frame_search();
        }
    }

run_frame_locked()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::run_frame_locked ( )

inline

Definition at line 707 of file dvbs2.h.

References leansdr::modcod_info::c, leansdr::conjprod(), leansdr::cstln_amp, leansdr::modcod_info::esn0_nf, leansdr::FEC910, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::fw16, leansdr::modcod_info::g1, leansdr::modcod_info::g2, leansdr::modcod_info::g3, leansdr::hamming_weight(), i, leansdr::complex< T >::im, leansdr::plslot< SOFTSYMB >::is_pls, leansdr::plslot< SOFTSYMB >::LENGTH, leansdr::cstln_lut< SOFTSYMB, R >::m_rateCode, leansdr::s2_pls::modcod, leansdr::modcod_infos, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::mu, leansdr::cstln_base::names, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::normalize(), leansdr::modcod_info::nslots_nf, leansdr::modcod_info::nsymbols, leansdr::opt_write(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::p, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::ph16, leansdr::s2_pls::pilots, leansdr::plslot< SOFTSYMB >::pls, leansdr::modcod_info::rate, leansdr::complex< T >::re, leansdr::s2_pls::sf, leansdr::plslot< SOFTSYMB >::symbols, leansdr::sampler_interface< T >::update_freq(), and xfprintf.

    {
        complex<float> *psampled;
        if (cstln_out && cstln_out->writable() >= 1024)
            psampled = cstln_out->wr();
        else
            psampled = NULL;
        complex<float> *psampled_pls;
        if (cstln_pls_out && cstln_pls_out->writable() >= 1024)
            psampled_pls = cstln_pls_out->wr();
        else
            psampled_pls = NULL;

#if TEST_DIVERSITY
        complex<float> *psymbols = symbols_out ? symbols_out->wr() : NULL;
        float scale_symbols = 1.0 / cstln_amp;
#endif

        xfprintf(stderr, "lock0step fw= %f (%.0f Hz) mu=%f\n",
                 freqw16, freqw16 * Fm / 65536, mu);

        sampler_state ss = {in.rd(), mu, phase16, freqw16, scrambling.Rn};
        sampler->update_freq(ss.fw16 / omega);

        update_agc();

        // Read PLSCODE

        uint64_t plscode = 0;
        complex<float> pls_symbols[plscodes.LENGTH];
        for (int s = 0; s < plscodes.LENGTH; ++s)
        {
            complex<float> p = interp_next(&ss) * agc_gain;
#if TEST_DIVERSITY
            if (psymbols)
                *psymbols++ = p * scale_symbols;
#endif
            pls_symbols[s] = p;
            if (psampled_pls)
                *psampled_pls++ = p;
            int bit = (p.im < 1); // TBD suboptimal
            plscode = (plscode << 1) | bit;
        }
        int pls_index = -1;
        int pls_errors = S2_MAX_ERR_PLSCODE + 1; // dmin=32
        // TBD: Optimiser
        for (int i = 0; i < plscodes.COUNT; ++i)
        {
            int e = hamming_weight(plscode ^ plscodes.codewords[i]);
            if (e < pls_errors)
            {
                pls_errors = e;
                pls_index = i;
            }
        }
        if (pls_index < 0)
        {
            if (sch->debug2)
                fprintf(stderr, "Too many errors in plheader (%d)\n", pls_errors);
            in.read(ss.p - in.rd());
            enter_frame_search();
            return;
        }

        // Adjust phase with PLS
        complex<float> pls_corr = conjprod(plscodes.symbols[pls_index],
                                           pls_symbols, plscodes.LENGTH);
        ss.normalize();
        align_phase(&ss, pls_corr);

        s2_pls pls;
        pls.modcod = pls_index >> 2; // Guaranteed 0..31
        pls.sf = pls_index & 2;
        pls.pilots = pls_index & 1;
        xfprintf(stderr, "PLS: modcod %d, short=%d, pilots=%d (%d errors)\n",
                 pls.modcod, pls.sf, pls.pilots, pls_errors);
        const modcod_info *mcinfo = &modcod_infos[pls.modcod];
        if (!mcinfo->nslots_nf)
        {
            fprintf(stderr, "Unsupported or corrupted MODCOD\n");
            in.read(ss.p - in.rd());
            enter_frame_search();
            return;
        }
#if 1 // TBD use fec_infos
        if (pls.sf && mcinfo->rate == FEC910)
        {
            fprintf(stderr, "Unsupported or corrupted FEC\n");
            in.read(ss.p - in.rd());
            enter_frame_search();
            return;
        }
#endif
        // Store current MODCOD info
        if (mcinfo->c != m_modcodType) {
            m_modcodType = mcinfo->c;
        }
        if (mcinfo->rate != m_modcodRate) {
            m_modcodRate = mcinfo->rate;
        }

        // TBD Comparison of nsymbols is insufficient for DVB-S2X.
        if (!cstln || cstln->nsymbols != mcinfo->nsymbols)
        {
            if (cstln)
            {
                fprintf(stderr, "Warning: Variable MODCOD is inefficient\n");
                delete cstln;
            }
            fprintf(stderr, "Creating LUT for %s ratecode %d\n",
                    cstln_base::names[mcinfo->c], mcinfo->rate);
            cstln = new cstln_lut<SOFTSYMB, 256>(mcinfo->c, mcinfo->esn0_nf,
                                                 mcinfo->g1, mcinfo->g2, mcinfo->g3);
            cstln->m_rateCode = (int) mcinfo->rate;
            cstln->m_typeCode = (int) mcinfo->c;
            cstln->m_setByModcod = true;
#if 0
    fprintf(stderr, "Dumping constellation LUT to stdout.\n");
    cstln->dump(stdout);
#endif
        }

        int S = pls.sf ? mcinfo->nslots_nf / 4 : mcinfo->nslots_nf;

        plslot<SOFTSYMB> *pout = out.wr(), *pout0 = pout;

        // Output special slot with PLS information
        pout->is_pls = true;
        pout->pls = pls;
        ++pout;

        // Read slots and pilots

        int pilot_errors = 0;

        // Slots to skip until next PL slot (pilot or sof)
        int till_next_pls = pls.pilots ? 16 : S;

        for (int leansdr_slots = S; leansdr_slots--; ++pout, --till_next_pls)
        {
            if (till_next_pls == 0)
            {
                // Read pilot
                int errors = 0;
                complex<float> corr = 0;
                for (int s = 0; s < pilot_length; ++s)
                {
                    complex<float> p0 = interp_next(&ss);
                    track_agc(p0);
                    complex<float> p = p0 * agc_gain;
#if TEST_DIVERSITY
                    if (psymbols)
                        *psymbols++ = p * scale_symbols;
#endif
                    (void)track_symbol(&ss, p, qpsk, 1);
                    if (psampled_pls)
                        *psampled_pls++ = p;
                    complex<float> d = descramble(&ss, p);
                    if (d.im < 0 || d.re < 0)
                        ++errors;
                    corr.re += d.re + d.im;
                    corr.im += d.im - d.re;
                }
                if (errors > S2_MAX_ERR_PILOT)
                {
                    if (sch->debug2)
                        fprintf(stderr, "Too many errors in pilot (%d/36)\n", errors);
                    in.read(ss.p - in.rd());
                    enter_frame_search();
                    return;
                }
                pilot_errors += errors;
                ss.normalize();
                align_phase(&ss, corr);
                till_next_pls = 16;
            }
            // Read slot
            pout->is_pls = false;
            complex<float> p; // Export last symbols for cstln_out
            for (int s = 0; s < pout->LENGTH; ++s)
            {
                p = interp_next(&ss) * agc_gain;
#if TEST_DIVERSITY
                if (psymbols)
                    *psymbols++ = p * scale_symbols;
#endif
#if 1 || TEST_DIVERSITY
                (void)track_symbol(&ss, p, cstln, 0); // SLOW
#endif
                complex<float> d = descramble(&ss, p);
#if 0 // Slow
      SOFTSYMB *symb = &cstln->lookup(d.re, d.im)->ss;
#else // Avoid scaling floats. May wrap at very low SNR.
                SOFTSYMB *symb = &cstln->lookup((int)d.re, (int)d.im)->ss;
#endif
                pout->symbols[s] = *symb;
            }
            if (psampled)
                *psampled++ = p;
        } // slots

        // Read SOF

        memset(hist, 0, sizeof(hist));
        complex<float> sof_corr = 0;
        uint32_t sofbits = 0;
        for (int s = 0; s < sof.LENGTH; ++s)
        {
            complex<float> p0 = interp_next(&ss);
            track_agc(p0);
            complex<float> p = p0 * agc_gain;
#if TEST_DIVERSITY
            if (psymbols)
                *psymbols++ = p * scale_symbols;
#endif
            uint8_t symb = track_symbol(&ss, p, qpsk, 1);
            if (psampled_pls)
                *psampled_pls++ = p;
            int bit = (p.im < 0); // suboptimal
            sofbits = (sofbits << 1) | bit;
            sof_corr += conjprod(sof.symbols[s], p);
        }
        int sof_errors = hamming_weight(sofbits ^ sof.VALUE);
        if (sof_errors >= S2_MAX_ERR_SOF)
        {
            if (sch->debug2)
                fprintf(stderr, "Too many errors in SOF (%d/26)\n", sof_errors);
            in.read(ss.p - in.rd());
            enter_coarse_freq();
            return;
        }
        ss.normalize();
        align_phase(&ss, sof_corr);

        // Commit whole frame after final SOF.
        out.written(pout - pout0);

        // Write back sampler progress
        meas_count += ss.p - in.rd();
        in.read(ss.p - in.rd());
        mu = ss.mu;
        phase16 = ss.ph16;
        freqw16 = ss.fw16;

        // Measurements
        if (psampled)
            cstln_out->written(psampled - cstln_out->wr());
        if (psampled_pls)
            cstln_pls_out->written(psampled_pls - cstln_pls_out->wr());
#if TEST_DIVERSITY
        if (psymbols)
            symbols_out->written(psymbols - symbols_out->wr());
#endif
        if (meas_count >= meas_decimation)
        {
            opt_write(freq_out, freqw16 / 65536 / omega);
            opt_write(ss_out, in_power);
            // TBD Adjust if cfg.strongpls
            float mer = ev_power ? (float)cstln_amp * cstln_amp / ev_power : 1;
            opt_write(mer_out, 10 * logf(mer) / logf(10));
            meas_count -= meas_decimation;
        }

        int all_errors = pls_errors + pilot_errors + sof_errors;
        int max_errors = plscodes.LENGTH + sof.LENGTH;
        if (pls.pilots)
            max_errors += ((S - 1) / 16) * pilot_length;

        xfprintf(stderr, "success   fw= %f (%.0f Hz) mu= %f "
                         "errors=%d/64+%d+%d/26 = %2d/%d\n",
                 freqw16, freqw16 * Fm / 65536, mu,
                 pls_errors, pilot_errors, sof_errors, all_errors, max_errors);
        pl_errors += all_errors;
        pl_symbols += max_errors;
    }

Here is the call graph for this function:

run_frame_search()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::run_frame_search ( )

inline

Definition at line 605 of file dvbs2.h.

References floor(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::fw16, leansdr::hamming_weight(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::mu, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::normalize(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::p, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::ph16, and leansdr::sampler_interface< T >::update_freq().

    {
        complex<float> *psampled;
        if (cstln_out && cstln_out->writable() >= 1024)
            psampled = cstln_out->wr();
        else
            psampled = NULL;

        // Preserve float precision
        phase16 -= 65536 * floor(phase16 / 65536);

        int nsymbols = MAX_SYMBOLS_PER_FRAME; // TBD Adjust after PLS decoding

        sampler_state ss = {in.rd(), mu, phase16, freqw16};
        sampler->update_freq(ss.fw16 / omega);

        if (!in_power)
            init_agc(ss.p, 64);
        update_agc();

        for (int s = 0; s < nsymbols; ++s)
        {
            complex<float> p0 = interp_next(&ss);
            track_agc(p0);
            complex<float> p = p0 * agc_gain;

            // Constellation plot
            if (psampled && s < 1024)
                *psampled++ = p;

            // Demodulate everything as QPSK.
            // Occasionally it locks onto 8PSK at offet 2pi/16.
            uint8_t symb = track_symbol(&ss, p, qpsk, 1);

            // Feed symbol into all synchronizers.
            for (sync *ps = syncs; ps < syncs + nsyncs; ++ps)
            {
                ps->hist = (ps->hist << 1) | ((ps->tobpsk >> symb) & 1);
                int errors = hamming_weight((ps->hist & sof.MASK) ^ sof.VALUE);
                if (errors <= S2_MAX_ERR_SOF_INITIAL)
                {
                    if (sch->debug2)
                        fprintf(stderr, "Found SOF+%d at %d offset %f\n",
                                errors, s, ps->offset16);
                    ss.ph16 += ps->offset16;
                    in.read(ss.p - in.rd());
                    mu = ss.mu;
                    phase16 = ss.ph16;
                    freqw16 = ss.fw16;
                    if (psampled)
                        cstln_out->written(psampled - cstln_out->wr());
                    enter_frame_locked();
                    return;
                }
            }
            ss.normalize();
        }

        // Write back sampler progress
        in.read(ss.p - in.rd());
        mu = ss.mu;
        phase16 = ss.ph16;
        freqw16 = ss.fw16;
        if (psampled)
            cstln_out->written(psampled - cstln_out->wr());
    }

Here is the call graph for this function:

shutdown()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::shutdown ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 983 of file dvbs2.h.

    {
        fprintf(stderr, "PL SER: %f ppm\n", pl_errors / (pl_symbols + 1e-6) * 1e6);
    }

track_agc()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::track_agc ( const complex< float > &  p )

inline

Definition at line 995 of file dvbs2.h.

References leansdr::complex< T >::im, and leansdr::complex< T >::re.

    {
        float in_p = p.re * p.re + p.im * p.im;
        in_power = in_p * agc_bw + in_power * (1.0f - agc_bw);
    }

track_symbol()

template<typename T, typename SOFTSYMB>

uint8_t leansdr::s2_frame_receiver< T, SOFTSYMB >::track_symbol ( sampler_state *  ss, const complex< float > &  p, cstln_lut< SOFTSYMB, 256 > *  c, int  mode  )

inline

Definition at line 1087 of file dvbs2.h.

References leansdr::cstln_amp, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::fw16, leansdr::complex< T >::im, leansdr::cstln_lut< SOFTSYMB, R >::lookup(), leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::mu, leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler_state::ph16, leansdr::complex< T >::re, and leansdr::cstln_base::symbols.

    {
        static struct
        {
            float kph, kfw, kmu;
        } gains[2] = {
            {4e-2, 1e-4, 0.001 / (cstln_amp * cstln_amp)},
            {4e-2, 1e-4, 0.001 / (cstln_amp * cstln_amp)}};
        // Decision
        typename cstln_lut<SOFTSYMB, 256>::result *cr = c->lookup(p.re, p.im);
        // Carrier tracking
        ss->ph16 += cr->phase_error * gains[mode].kph;
        ss->fw16 += cr->phase_error * gains[mode].kfw;
        if (ss->fw16 < min_freqw16)
            ss->fw16 = min_freqw16;
        if (ss->fw16 > max_freqw16)
            ss->fw16 = max_freqw16;
        // Phase tracking
        hist[2] = hist[1];
        hist[1] = hist[0];
        hist[0].p = p;
        complex<int8_t> *cp = &c->symbols[cr->symbol];
        hist[0].c.re = cp->re;
        hist[0].c.im = cp->im;
        float muerr =
            ((hist[0].p.re - hist[2].p.re) * hist[1].c.re +
             (hist[0].p.im - hist[2].p.im) * hist[1].c.im) -
            ((hist[0].c.re - hist[2].c.re) * hist[1].p.re +
             (hist[0].c.im - hist[2].c.im) * hist[1].p.im);
        float mucorr = muerr * gains[mode].kmu;
        const float max_mucorr = 0.1;
        // TBD Optimize out statically
        if (mucorr < -max_mucorr)
            mucorr = -max_mucorr;
        if (mucorr > max_mucorr)
            mucorr = max_mucorr;
        ss->mu += mucorr;
        // Error vector for MER
        complex<float> ev(p.re - cp->re, p.im - cp->im);
        float ev_p = ev.re * ev.re + ev.im * ev.im;
        ev_power = ev_p * agc_bw + ev_power * (1.0f - agc_bw);
        return cr->symbol;
    }

Here is the call graph for this function:

update_agc()

template<typename T, typename SOFTSYMB>

void leansdr::s2_frame_receiver< T, SOFTSYMB >::update_agc ( )

inline

Definition at line 1001 of file dvbs2.h.

References leansdr::cstln_amp, and leansdr::gen_sqrt().

    {
        float in_amp = gen_sqrt(in_power);
        if (!in_amp)
            return;
        if (!strongpls || !cstln)
        {
            // Match RMS amplitude
            agc_gain = cstln_amp / in_amp;
        }
        else
        {
            // Match peak amplitude
            agc_gain = cstln_amp / cstln->amp_max / in_amp;
        }
    }

Here is the call graph for this function:

Member Data Documentation

agc_bw

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::agc_bw

Definition at line 1141 of file dvbs2.h.

agc_gain

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::agc_gain

Definition at line 1140 of file dvbs2.h.

c

template<typename T, typename SOFTSYMB>

complex<float> leansdr::s2_frame_receiver< T, SOFTSYMB >::c

Definition at line 1135 of file dvbs2.h.

coarse_count

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::coarse_count

Definition at line 501 of file dvbs2.h.

cstln

template<typename T, typename SOFTSYMB>

cstln_lut<SOFTSYMB, 256>* leansdr::s2_frame_receiver< T, SOFTSYMB >::cstln

Definition at line 1153 of file dvbs2.h.

Referenced by DATVDemod::feed(), and DATVDemod::InitDATVS2Framework().

cstln_out

template<typename T, typename SOFTSYMB>

pipewriter<complex<float> >* leansdr::s2_frame_receiver< T, SOFTSYMB >::cstln_out

Definition at line 1200 of file dvbs2.h.

cstln_pls_out

template<typename T, typename SOFTSYMB>

pipewriter<complex<float> >* leansdr::s2_frame_receiver< T, SOFTSYMB >::cstln_pls_out

Definition at line 1201 of file dvbs2.h.

current_sync

template<typename T, typename SOFTSYMB>

struct leansdr::s2_frame_receiver::sync * leansdr::s2_frame_receiver< T, SOFTSYMB >::current_sync[MAXSYNCS]

diffcorr

template<typename T, typename SOFTSYMB>

complex<float> leansdr::s2_frame_receiver< T, SOFTSYMB >::diffcorr

Definition at line 500 of file dvbs2.h.

ev_power

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::ev_power

Definition at line 1139 of file dvbs2.h.

Fm

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::Fm

Definition at line 441 of file dvbs2.h.

Referenced by DATVDemod::InitDATVS2Framework().

freq_out

template<typename T, typename SOFTSYMB>

pipewriter<float>* leansdr::s2_frame_receiver< T, SOFTSYMB >::freq_out

Definition at line 1199 of file dvbs2.h.

freqw16

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::freqw16

Definition at line 504 of file dvbs2.h.

Ftune

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::Ftune

Definition at line 440 of file dvbs2.h.

Referenced by DATVDemod::InitDATVS2Framework().

hist

struct { ... } leansdr::s2_frame_receiver< T, SOFTSYMB >::hist[3]

in

template<typename T, typename SOFTSYMB>

pipereader<complex<T> > leansdr::s2_frame_receiver< T, SOFTSYMB >::in

Definition at line 1196 of file dvbs2.h.

in_power

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::in_power

Definition at line 1139 of file dvbs2.h.

m_modcodRate

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::m_modcodRate

Definition at line 1209 of file dvbs2.h.

Referenced by DATVDemod::feed().

m_modcodType

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::m_modcodType

Definition at line 1208 of file dvbs2.h.

Referenced by DATVDemod::feed().

max_freqw16

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::max_freqw16

Definition at line 497 of file dvbs2.h.

MAX_SLOTS

template<typename T, typename SOFTSYMB>

const int leansdr::s2_frame_receiver< T, SOFTSYMB >::MAX_SLOTS = 240

static

Definition at line 1212 of file dvbs2.h.

MAX_SYMBOLS

template<typename T, typename SOFTSYMB>

const int leansdr::s2_frame_receiver< T, SOFTSYMB >::MAX_SYMBOLS

static

Initial value:

=
        (1 + MAX_SLOTS) * plslot<SOFTSYMB>::LENGTH + ((MAX_SLOTS - 1) / 16) * pilot_length

Definition at line 1213 of file dvbs2.h.

MAX_SYMBOLS_PER_FRAME

template<typename T, typename SOFTSYMB>

const int leansdr::s2_frame_receiver< T, SOFTSYMB >::MAX_SYMBOLS_PER_FRAME

static

Initial value:

=
        (1 + modcod_info::MAX_SLOTS_PER_FRAME) * plslot<hard_ss>::LENGTH +
        ((modcod_info::MAX_SLOTS_PER_FRAME - 1) / 16) * pilot_length

Definition at line 443 of file dvbs2.h.

MAXSYNCS

template<typename T, typename SOFTSYMB>

const int leansdr::s2_frame_receiver< T, SOFTSYMB >::MAXSYNCS = 8

static

Definition at line 1143 of file dvbs2.h.

mcinfo

template<typename T, typename SOFTSYMB>

modcod_info* leansdr::s2_frame_receiver< T, SOFTSYMB >::mcinfo

Definition at line 1195 of file dvbs2.h.

meas_count

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::meas_count

Definition at line 1198 of file dvbs2.h.

meas_decimation

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::meas_decimation

Definition at line 439 of file dvbs2.h.

Referenced by DATVDemod::InitDATVS2Framework().

mer_out

template<typename T, typename SOFTSYMB>

pipewriter<float> * leansdr::s2_frame_receiver< T, SOFTSYMB >::mer_out

Definition at line 1199 of file dvbs2.h.

min_freqw16

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::min_freqw16

Definition at line 497 of file dvbs2.h.

mu

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::mu

Definition at line 507 of file dvbs2.h.

nsyncs

template<typename T, typename SOFTSYMB>

int leansdr::s2_frame_receiver< T, SOFTSYMB >::nsyncs

Definition at line 1151 of file dvbs2.h.

omega

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::omega

Definition at line 508 of file dvbs2.h.

Referenced by DATVDemod::InitDATVS2Framework().

out

template<typename T, typename SOFTSYMB>

pipewriter<plslot<SOFTSYMB> > leansdr::s2_frame_receiver< T, SOFTSYMB >::out

Definition at line 1197 of file dvbs2.h.

p

template<typename T, typename SOFTSYMB>

complex<float> leansdr::s2_frame_receiver< T, SOFTSYMB >::p

Definition at line 1134 of file dvbs2.h.

phase16

template<typename T, typename SOFTSYMB>

float leansdr::s2_frame_receiver< T, SOFTSYMB >::phase16

Definition at line 505 of file dvbs2.h.

plscodes

template<typename T, typename SOFTSYMB>

s2_plscodes<T> leansdr::s2_frame_receiver< T, SOFTSYMB >::plscodes

Definition at line 1152 of file dvbs2.h.

qpsk

template<typename T, typename SOFTSYMB>

cstln_lut<SOFTSYMB, 256>* leansdr::s2_frame_receiver< T, SOFTSYMB >::qpsk

Definition at line 1142 of file dvbs2.h.

report_state

template<typename T, typename SOFTSYMB>

bool leansdr::s2_frame_receiver< T, SOFTSYMB >::report_state

Definition at line 1204 of file dvbs2.h.

sampler

template<typename T, typename SOFTSYMB>

sampler_interface<T>* leansdr::s2_frame_receiver< T, SOFTSYMB >::sampler

Definition at line 438 of file dvbs2.h.

scrambling

template<typename T, typename SOFTSYMB>

s2_scrambling leansdr::s2_frame_receiver< T, SOFTSYMB >::scrambling

Definition at line 1206 of file dvbs2.h.

sof

template<typename T, typename SOFTSYMB>

s2_sof<T> leansdr::s2_frame_receiver< T, SOFTSYMB >::sof

Definition at line 1207 of file dvbs2.h.

ss_out

template<typename T, typename SOFTSYMB>

pipewriter<float> * leansdr::s2_frame_receiver< T, SOFTSYMB >::ss_out

Definition at line 1199 of file dvbs2.h.

state

enum { ... } leansdr::s2_frame_receiver< T, SOFTSYMB >::state

state_out

template<typename T, typename SOFTSYMB>

pipewriter<int>* leansdr::s2_frame_receiver< T, SOFTSYMB >::state_out

Definition at line 1203 of file dvbs2.h.

strongpls

template<typename T, typename SOFTSYMB>

bool leansdr::s2_frame_receiver< T, SOFTSYMB >::strongpls

Definition at line 442 of file dvbs2.h.

Referenced by DATVDemod::InitDATVS2Framework().

symbols_out

template<typename T, typename SOFTSYMB>

pipewriter<complex<float> >* leansdr::s2_frame_receiver< T, SOFTSYMB >::symbols_out

Definition at line 1202 of file dvbs2.h.

syncs

template<typename T, typename SOFTSYMB>

struct leansdr::s2_frame_receiver::sync leansdr::s2_frame_receiver< T, SOFTSYMB >::syncs[MAXSYNCS]

trig

template<typename T, typename SOFTSYMB>

trig16 leansdr::s2_frame_receiver< T, SOFTSYMB >::trig

Definition at line 1194 of file dvbs2.h.

---

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

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