#include <dvb.h>

Inheritance diagram for leansdr::viterbi_sync:

Collaboration diagram for leansdr::viterbi_sync:

Classes
struct	sync

Public Types
typedef uint8_t	TS

typedef uint8_t	TCS

typedef uint8_t	TUS

typedef int32_t	TBM

typedef int32_t	TPM

typedef viterbi_dec_interface< TUS, TCS, TBM, TPM >	dvb_dec_interface

typedef bitpath< uint32_t, TUS, 1, 32 >	path_12

typedef trellis< TS, 64, TUS, 2, 4 >	trellis_12

typedef viterbi_dec< TS, 64, TUS, 2, TCS, 4, TBM, TPM, path_12 >	dvb_dec_12

typedef bitpath< uint64_t, TUS, 3, 21 >	path_23

typedef trellis< TS, 64, TUS, 4, 8 >	trellis_23

typedef viterbi_dec< TS, 64, TUS, 4, TCS, 8, TBM, TPM, path_23 >	dvb_dec_23

typedef bitpath< uint64_t, TUS, 4, 16 >	path_46

typedef trellis< TS, 64, TUS, 16, 64 >	trellis_46

typedef viterbi_dec< TS, 64, TUS, 16, TCS, 64, TBM, TPM, path_46 >	dvb_dec_46

typedef bitpath< uint64_t, TUS, 3, 21 >	path_34

typedef trellis< TS, 64, TUS, 8, 16 >	trellis_34

typedef viterbi_dec< TS, 64, TUS, 8, TCS, 16, TBM, TPM, path_34 >	dvb_dec_34

typedef bitpath< uint64_t, TUS, 4, 16 >	path_45

typedef trellis< TS, 64, TUS, 16, 32 >	trellis_45

typedef viterbi_dec< TS, 64, TUS, 16, TCS, 32, TBM, TPM, path_45 >	dvb_dec_45

typedef bitpath< uint64_t, TUS, 5, 12 >	path_56

typedef trellis< TS, 64, TUS, 32, 64 >	trellis_56

typedef viterbi_dec< TS, 64, TUS, 32, TCS, 64, TBM, TPM, path_56 >	dvb_dec_56

typedef bitpath< uint64_t, TUS, 7, 9 >	path_78

typedef trellis< TS, 64, TUS, 128, 256 >	trellis_78

typedef viterbi_dec< TS, 64, TUS, 128, TCS, 256, TBM, TPM, path_78 >	dvb_dec_78

Public Member Functions
	viterbi_sync (scheduler sch, pipebuf< eucl_ss > &_in, pipebuf< unsigned char > &_out, cstln_lut< eucl_ss, 256 > _cstln, code_rate cr)

TCS *	init_map (bool conj, float angle)

TUS	update_sync (int s, eucl_ss pin, TPM discr)

void	run ()

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 ()

virtual void	shutdown ()

Public Attributes
int	resync_period

Public Attributes inherited from leansdr::runnable_common
const char *	name

Private Attributes
pipereader< eucl_ss >	in

pipewriter< unsigned char >	out

cstln_lut< eucl_ss, 256 > *	cstln

fec_spec *	fec

int	bits_per_symbol

int	nsyncs

int	nshifts

struct leansdr::viterbi_sync::sync *	syncs

int	current_sync

int	resync_phase

Static Private Attributes
static const int	chunk_size = 128

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

Detailed Description

Definition at line 1466 of file dvb.h.

Member Typedef Documentation

◆ dvb_dec_12

typedef viterbi_dec<TS, 64, TUS, 2, TCS, 4, TBM, TPM, path_12> leansdr::viterbi_sync::dvb_dec_12

Definition at line 1476 of file dvb.h.

◆ dvb_dec_23

typedef viterbi_dec<TS, 64, TUS, 4, TCS, 8, TBM, TPM, path_23> leansdr::viterbi_sync::dvb_dec_23

Definition at line 1481 of file dvb.h.

◆ dvb_dec_34

typedef viterbi_dec<TS, 64, TUS, 8, TCS, 16, TBM, TPM, path_34> leansdr::viterbi_sync::dvb_dec_34

Definition at line 1491 of file dvb.h.

◆ dvb_dec_45

typedef viterbi_dec<TS, 64, TUS, 16, TCS, 32, TBM, TPM, path_45> leansdr::viterbi_sync::dvb_dec_45

Definition at line 1496 of file dvb.h.

◆ dvb_dec_46

typedef viterbi_dec<TS, 64, TUS, 16, TCS, 64, TBM, TPM, path_46> leansdr::viterbi_sync::dvb_dec_46

Definition at line 1486 of file dvb.h.

◆ dvb_dec_56

typedef viterbi_dec<TS, 64, TUS, 32, TCS, 64, TBM, TPM, path_56> leansdr::viterbi_sync::dvb_dec_56

Definition at line 1501 of file dvb.h.

◆ dvb_dec_78

typedef viterbi_dec<TS, 64, TUS, 128, TCS, 256, TBM, TPM, path_78> leansdr::viterbi_sync::dvb_dec_78

Definition at line 1506 of file dvb.h.

◆ dvb_dec_interface

typedef viterbi_dec_interface<TUS, TCS, TBM, TPM> leansdr::viterbi_sync::dvb_dec_interface

Definition at line 1471 of file dvb.h.

◆ path_12

typedef bitpath<uint32_t, TUS, 1, 32> leansdr::viterbi_sync::path_12

Definition at line 1474 of file dvb.h.

◆ path_23

typedef bitpath<uint64_t, TUS, 3, 21> leansdr::viterbi_sync::path_23

Definition at line 1479 of file dvb.h.

◆ path_34

typedef bitpath<uint64_t, TUS, 3, 21> leansdr::viterbi_sync::path_34

Definition at line 1489 of file dvb.h.

◆ path_45

typedef bitpath<uint64_t, TUS, 4, 16> leansdr::viterbi_sync::path_45

Definition at line 1494 of file dvb.h.

◆ path_46

typedef bitpath<uint64_t, TUS, 4, 16> leansdr::viterbi_sync::path_46

Definition at line 1484 of file dvb.h.

◆ path_56

typedef bitpath<uint64_t, TUS, 5, 12> leansdr::viterbi_sync::path_56

Definition at line 1499 of file dvb.h.

◆ path_78

typedef bitpath<uint64_t, TUS, 7, 9> leansdr::viterbi_sync::path_78

Definition at line 1504 of file dvb.h.

◆ TBM

typedef int32_t leansdr::viterbi_sync::TBM

Definition at line 1469 of file dvb.h.

◆ TCS

typedef uint8_t leansdr::viterbi_sync::TCS

Definition at line 1468 of file dvb.h.

◆ TPM

typedef int32_t leansdr::viterbi_sync::TPM

Definition at line 1470 of file dvb.h.

◆ trellis_12

typedef trellis<TS, 64, TUS, 2, 4> leansdr::viterbi_sync::trellis_12

Definition at line 1475 of file dvb.h.

◆ trellis_23

typedef trellis<TS, 64, TUS, 4, 8> leansdr::viterbi_sync::trellis_23

Definition at line 1480 of file dvb.h.

◆ trellis_34

typedef trellis<TS, 64, TUS, 8, 16> leansdr::viterbi_sync::trellis_34

Definition at line 1490 of file dvb.h.

◆ trellis_45

typedef trellis<TS, 64, TUS, 16, 32> leansdr::viterbi_sync::trellis_45

Definition at line 1495 of file dvb.h.

◆ trellis_46

typedef trellis<TS, 64, TUS, 16, 64> leansdr::viterbi_sync::trellis_46

Definition at line 1485 of file dvb.h.

◆ trellis_56

typedef trellis<TS, 64, TUS, 32, 64> leansdr::viterbi_sync::trellis_56

Definition at line 1500 of file dvb.h.

◆ trellis_78

typedef trellis<TS, 64, TUS, 128, 256> leansdr::viterbi_sync::trellis_78

Definition at line 1505 of file dvb.h.

◆ TS

typedef uint8_t leansdr::viterbi_sync::TS

Definition at line 1468 of file dvb.h.

◆ TUS

typedef uint8_t leansdr::viterbi_sync::TUS

Definition at line 1468 of file dvb.h.

Constructor & Destructor Documentation

◆ viterbi_sync()

leansdr::viterbi_sync::viterbi_sync	(	scheduler *	sch,
		pipebuf< eucl_ss > &	_in,
		pipebuf< unsigned char > &	_out,
		cstln_lut< eucl_ss, 256 > *	_cstln,
		code_rate	cr
	)

inline

Definition at line 1531 of file dvb.h.

References leansdr::fail(), leansdr::FEC12, leansdr::FEC23, leansdr::FEC34, leansdr::FEC45, leansdr::FEC46, leansdr::FEC56, leansdr::FEC78, i, leansdr::trellis< TS, NSTATES, TUS, NUS, NCS >::init_convolutional(), leansdr::log2i(), M_PI, leansdr::cstln_base::nrotations, leansdr::cstln_base::nsymbols, and leansdr::deconvol_sync< Tbyte, BYTE_ERASED >::syncs.

                                : runnable(sch, "viterbi_sync"),
                                  in(_in),
                                  out(_out, chunk_size),
                                  cstln(_cstln),
                                  current_sync(0),
                                  resync_phase(0),
                                  resync_period(32) // 1/32 = 9% synchronization overhead TBD
     {
         bits_per_symbol = log2i(cstln->nsymbols);
         fec = &fec_specs[cr];
 
         { // Sanity check: FEC block size must be a multiple of label size.
             int symbols_per_block = fec->bits_out / bits_per_symbol;
             if (bits_per_symbol * symbols_per_block != fec->bits_out)
                 fail("Code rate not suitable for this constellation");
         }
 
         int nconj;
 
         switch (cstln->nsymbols)
         {
         case 2:
             nconj = 1;
             break; // Conjugation is not relevant for BPSK
         default:
             nconj = 2;
             break;
         }
 
         int nrotations;
 
         switch (cstln->nsymbols)
         {
         case 2:
         case 4:
             // For BPSK and QPSK, 180° rotation is handled as
             // polarity inversion in mpeg_sync.
             nrotations = cstln->nrotations / 2;
             break;
         default:
             nrotations = cstln->nrotations;
             break;
         }
 
         nshifts = fec->bits_out / bits_per_symbol;
         nsyncs = nconj * nrotations * nshifts;
 
         // TBD Many HOM constellations are labelled in such a way
         // that certain rot/conj combinations are equivalent to
         // polarity inversion.  We could reduce nsyncs.
 
         syncs = new sync[nsyncs];
 
         for (int s = 0; s < nsyncs; ++s)
         {
             // Bit pattern  [shift|conj|rot]
             int rot = s % nrotations;
             int conj = (s / nrotations) % nconj;
             int shift = s / nrotations / nconj;
             syncs[s].shift = shift;
 
             if (shift) // Reuse identical map
                 syncs[s].map = syncs[conj * nrotations + rot].map;
             else
                 syncs[s].map = init_map(conj,
                                         2 * M_PI * rot / cstln->nrotations);
 #if 0
             fprintf(stderr, "sync %3d: conj%d offs%d rot%d/%d map:",
                     s, conj, syncs[s].shift, rot, cstln->nrotations);
             for ( int i=0; i<cstln->nsymbols; ++i )
             fprintf(stderr, " %2d", syncs[s].map[i]);
             fprintf(stderr, "\n");
 #endif
         }
 
         if (cr == FEC12)
         {
             trellis_12 *trell = new trellis_12();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_12(trell);
         }
         else if (cr == FEC23)
         {
             trellis_23 *trell = new trellis_23();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_23(trell);
         }
         else if (cr == FEC46)
         {
             trellis_46 *trell = new trellis_46();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_46(trell);
         }
         else if (cr == FEC34)
         {
             trellis_34 *trell = new trellis_34();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_34(trell);
         }
         else if (cr == FEC45)
         {
             trellis_45 *trell = new trellis_45();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_45(trell);
         }
         else if (cr == FEC56)
         {
             trellis_56 *trell = new trellis_56();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_56(trell);
         }
         else if (cr == FEC78)
         {
             trellis_78 *trell = new trellis_78();
             trell->init_convolutional(fec->polys);
             for (int s = 0; s < nsyncs; ++s)
                 syncs[s].dec = new dvb_dec_78(trell);
         }
         else
         {
             fail("CR not supported");
         }
     }

Here is the call graph for this function:

Member Function Documentation

◆ init_map()

TCS* leansdr::viterbi_sync::init_map	(	bool	conj,
		float	angle
	)

inline

Definition at line 1665 of file dvb.h.

References i, leansdr::complex< T >::im, leansdr::cstln_lut< SOFTSYMB, R >::lookup(), leansdr::cstln_base::nsymbols, leansdr::complex< T >::re, leansdr::cstln_lut< SOFTSYMB, R >::result::ss, and leansdr::cstln_base::symbols.

     {
         // Each constellation has its own pattern for labels.
         // Here we simply tabulate systematically.
         TCS *map = new TCS[cstln->nsymbols];
         float ca = cosf(angle), sa = sinf(angle);
 
         for (int i = 0; i < cstln->nsymbols; ++i)
         {
             int8_t I = cstln->symbols[i].re;
             int8_t Q = cstln->symbols[i].im;
 
             if (conj)
                 Q = -Q;
 
             int8_t RI = I * ca - Q * sa;
             int8_t RQ = I * sa + Q * ca;
             cstln_lut<eucl_ss, 256>::result *pr = cstln->lookup(RI, RQ);
             map[i] = pr->ss.nearest;
         }
 
         return map;
     }

Here is the call graph for this function:

◆ run()

void leansdr::viterbi_sync::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 1705 of file dvb.h.

References leansdr::scheduler::debug, leansdr::fail(), leansdr::pipereader< T >::rd(), leansdr::pipereader< T >::read(), leansdr::pipereader< T >::readable(), leansdr::runnable::sch, leansdr::pipewriter< T >::writable(), and leansdr::pipewriter< T >::write().

     {
         // Number of FEC blocks to fill the bitpath depth.
         // Before that we cannot discriminate between synchronizers
         int discr_delay = 64 / fec->bits_in;
 
         // Process [chunk_size] FEC blocks at a time
 
         TPM *totaldiscr = new TPM[nsyncs];
 
         while ((long)in.readable() >= nshifts * chunk_size + (nshifts - 1) && (long)out.writable() * 8 >= fec->bits_in * chunk_size)
         {
             for (int s = 0; s < nsyncs; ++s)
                 totaldiscr[s] = 0;
 
             uint64_t outstream = 0;
             int nout = 0;
             eucl_ss *pin = in.rd();
 
             for (int blocknum = 0; blocknum < chunk_size; ++blocknum, pin += nshifts)
             {
                 TPM discr;
                 TUS result = update_sync(current_sync, pin, &discr);
                 outstream = (outstream << fec->bits_in) | result;
                 nout += fec->bits_in;
 
                 if (blocknum >= discr_delay)
                     totaldiscr[current_sync] += discr;
 
                 if (!resync_phase)
                 {
                     // Every [resync_period] chunks, also run the other decoders.
                     for (int s = 0; s < nsyncs; ++s)
                     {
                         if (s == current_sync)
                             continue;
 
                         TPM discr;
                         (void)update_sync(s, pin, &discr);
 
                         if (blocknum >= discr_delay)
                             totaldiscr[s] += discr;
                     }
                 }
 
                 while (nout >= 8)
                 {
                     out.write(outstream >> (nout - 8));
                     nout -= 8;
                 }
             } // chunk_size
 
             in.read(chunk_size * nshifts);
 
             if (nout)
                 fail("overlapping out");
 
             if (!resync_phase)
             {
                 // Switch to another decoder ?
                 int best = current_sync;
 
                 for (int s = 0; s < nsyncs; ++s)
                     if (totaldiscr[s] > totaldiscr[best])
                         best = s;
 
                 if (best != current_sync)
                 {
                     if (sch->debug)
                         fprintf(stderr, "{%d->%d}", current_sync, best);
                     current_sync = best;
                 }
             }
 
             if (++resync_phase >= resync_period)
                 resync_phase = 0;
         }
 
         delete[] totaldiscr;
     }

Here is the call graph for this function:

◆ update_sync()

TUS leansdr::viterbi_sync::update_sync	(	int	s,
		eucl_ss *	pin,
		TPM *	discr
	)

inline

Definition at line 1689 of file dvb.h.

References leansdr::eucl_ss::discr2, i, leansdr::eucl_ss::nearest, and leansdr::deconvol_sync< Tbyte, BYTE_ERASED >::syncs.

     {
         // Read one FEC ouput block
         pin += syncs[s].shift;
         TCS cs = 0;
         TBM cost = 0;
 
         for (int i = 0; i < nshifts; ++i, ++pin)
         {
             cs = (cs << bits_per_symbol) | syncs[s].map[pin->nearest];
             cost -= pin->discr2;
         }
 
         return syncs[s].dec->update(cs, cost, discr);
     }

Member Data Documentation

◆ bits_per_symbol

int leansdr::viterbi_sync::bits_per_symbol

private

Definition at line 1513 of file dvb.h.

◆ chunk_size

const int leansdr::viterbi_sync::chunk_size = 128

staticprivate

Definition at line 1525 of file dvb.h.

◆ cstln

cstln_lut<eucl_ss, 256>* leansdr::viterbi_sync::cstln

private

Definition at line 1511 of file dvb.h.

◆ current_sync

int leansdr::viterbi_sync::current_sync

private

Definition at line 1524 of file dvb.h.

◆ fec

fec_spec* leansdr::viterbi_sync::fec

private

Definition at line 1512 of file dvb.h.

◆ in

pipereader<eucl_ss> leansdr::viterbi_sync::in

private

Definition at line 1509 of file dvb.h.

◆ nshifts

int leansdr::viterbi_sync::nshifts

private

Definition at line 1515 of file dvb.h.

◆ nsyncs

int leansdr::viterbi_sync::nsyncs

private

Definition at line 1514 of file dvb.h.

◆ out

pipewriter<unsigned char> leansdr::viterbi_sync::out

private

Definition at line 1510 of file dvb.h.

◆ resync_period

int leansdr::viterbi_sync::resync_period

Definition at line 1529 of file dvb.h.

◆ resync_phase

int leansdr::viterbi_sync::resync_phase

private

Definition at line 1526 of file dvb.h.

◆ syncs

struct leansdr::viterbi_sync::sync * leansdr::viterbi_sync::syncs

private

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

plugins/channelrx/demoddatv/leansdr/dvb.h

Classes

Public Types

Public Member Functions

Public Attributes

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ dvb_dec_12

◆ dvb_dec_23

◆ dvb_dec_34

◆ dvb_dec_45

◆ dvb_dec_46

◆ dvb_dec_56

◆ dvb_dec_78

◆ dvb_dec_interface

◆ path_12

◆ path_23

◆ path_34

◆ path_45

◆ path_46

◆ path_56

◆ path_78

◆ TBM

◆ TCS

◆ TPM

◆ trellis_12

◆ trellis_23

◆ trellis_34

◆ trellis_45

◆ trellis_46

◆ trellis_56

◆ trellis_78

◆ TS

◆ TUS

Constructor & Destructor Documentation

◆ viterbi_sync()

Member Function Documentation

◆ init_map()

◆ run()

◆ update_sync()

Member Data Documentation

◆ bits_per_symbol

◆ chunk_size

◆ cstln

◆ current_sync

◆ fec

◆ in

◆ nshifts

◆ nsyncs

◆ out

◆ resync_period

◆ resync_phase

◆ syncs