#include <dvbs2.h>

Inheritance diagram for leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >:

Collaboration diagram for leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >:

Classes
struct	helper_instance

struct	helper_job

struct	pool

Public Member Functions
	s2_fecdec_helper (scheduler sch, pipebuf< fecframe< SOFTBYTE >> &_in, pipebuf< bbframe > &_out, const char _command, pipebuf< int > _bitcount=NULL, pipebuf< int > _errcount=NULL)

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	batch_size

int	nhelpers

bool	must_buffer

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

Private Member Functions
bool	send_frame (fecframe< SOFTBYTE > *pin)

pool *	get_pool (const s2_pls *pls)

void	spawn_helper (helper_instance h, const s2_pls pls)

void	receive_frame (const helper_job *job)

Private Attributes
struct leansdr::s2_fecdec_helper::pool	pools [32][2]

simplequeue< helper_job, 1024 >	jobs

pipereader< fecframe< SOFTBYTE > >	in

pipewriter< bbframe >	out

const char *	command

SOFTBYTE	ldpc_buf [64800/8]

uint8_t	bch_buf [64800/8]

s2_bch_engines	s2bch

s2_bbscrambling	bbscrambling

pipewriter< int > *	bitcount

pipewriter< int > *	errcount

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

Detailed Description

template<typename SOFTBIT, typename SOFTBYTE>
struct leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >

Definition at line 2208 of file dvbs2.h.

Constructor & Destructor Documentation

◆ s2_fecdec_helper()

template<typename SOFTBIT , typename SOFTBYTE >

leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::s2_fecdec_helper	(	scheduler *	sch,
		pipebuf< fecframe< SOFTBYTE >> &	_in,
		pipebuf< bbframe > &	_out,
		const char *	_command,
		pipebuf< int > *	_bitcount = `NULL`,
		pipebuf< int > *	_errcount = `NULL`
	)

inline

Definition at line 2213 of file dvbs2.h.

         : runnable(sch, "S2 fecdec io"),
           batch_size(32),
           nhelpers(1),
           must_buffer(false),
           in(_in), out(_out),
           command(_command),
           bitcount(opt_writer(_bitcount, 1)),
           errcount(opt_writer(_errcount, 1))
     {
         for (int mc = 0; mc < 32; ++mc)
             for (int sf = 0; sf < 2; ++sf)
                 pools[mc][sf].procs = NULL;
     }

Member Function Documentation

◆ get_pool()

template<typename SOFTBIT , typename SOFTBYTE >

pool* leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::get_pool ( const s2_pls * pls )

inlineprivate

Definition at line 2309 of file dvbs2.h.

References i, leansdr::s2_pls::modcod, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::pool::nprocs, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::pool::procs, and leansdr::s2_pls::sf.

     {
         pool *p = &pools[pls->modcod][pls->sf];
         if (!p->procs)
         {
             p->procs = new helper_instance[nhelpers];
             for (int i = 0; i < nhelpers; ++i)
                 spawn_helper(&p->procs[i], pls);
             p->nprocs = nhelpers;
         }
         return p;
     }

◆ receive_frame()

template<typename SOFTBIT , typename SOFTBYTE >

void leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::receive_frame ( const helper_job * job )

inlineprivate

Definition at line 2373 of file dvbs2.h.

References leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::b_out, leansdr::bbframe::bytes, leansdr::check_modcod(), leansdr::bch_interface::decode(), leansdr::fatal(), leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::fd_rx, leansdr::s2_pls::framebits(), leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_job::h, leansdr::s2_pls::modcod, leansdr::opt_write(), leansdr::bbframe::pls, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_job::pls, leansdr::modcod_info::rate, leansdr::s2_pls::sf, leansdr::softbytes_harden(), leansdr::pipewriter< T >::wr(), and leansdr::pipewriter< T >::written().

     {
         // Read corrected frame from helper
         const s2_pls *pls = &job->pls;
         size_t iosize = (pls->framebits() / 8) * sizeof(ldpc_buf[0]);
         int nr = read(job->h->fd_rx, ldpc_buf, iosize);
         if (nr < 0)
             fatal("read(LDPC helper)");
         if (nr != iosize)
             fatal("partial read(LDPC helper)");
         --job->h->b_out;
         // Decode BCH.
         const modcod_info *mcinfo = check_modcod(job->pls.modcod);
         const fec_info *fi = &fec_infos[job->pls.sf][mcinfo->rate];
         uint8_t *hardbytes = softbytes_harden(ldpc_buf, fi->kldpc / 8, bch_buf);
         size_t cwbytes = fi->kldpc / 8;
         size_t msgbytes = fi->Kbch / 8;
         size_t chkbytes = cwbytes - msgbytes;
         bch_interface *bch = s2bch.bchs[job->pls.sf][mcinfo->rate];
         int ncorr = bch->decode(hardbytes, cwbytes);
         if (sch->debug2)
             fprintf(stderr, "BCHCORR = %d\n", ncorr);
         bool corrupted = (ncorr < 0);
         // Report VBER
         opt_write(bitcount, fi->Kbch);
         opt_write(errcount, (ncorr >= 0) ? ncorr : fi->Kbch);
 #if 0
       // TBD Some decoders want the bad packets.
     if ( corrupted ) {
       fprintf(stderr, "Passing bad frame\n");
       corrupted = false;
     }
 #endif
         if (!corrupted)
         {
             // Descramble and output
             bbframe *pout = out.wr();
             pout->pls = job->pls;
             bbscrambling.transform(hardbytes, fi->Kbch / 8, pout->bytes);
             out.written(1);
         }
         if (sch->debug)
             fprintf(stderr, "%c", corrupted ? '!' : ncorr ? '.' : '_');
     }

Here is the call graph for this function:

◆ run()

template<typename SOFTBIT , typename SOFTBYTE >

void leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 2232 of file dvbs2.h.

References leansdr::opt_writable(), leansdr::pipereader< T >::rd(), leansdr::pipereader< T >::read(), leansdr::pipereader< T >::readable(), and leansdr::pipewriter< T >::writable().

     {
         bool work_done = false;
         // Send work until all helpers block.
         bool all_blocked = false;
         while (in.readable() >= 1 && !jobs.full())
         {
             if (!send_frame(in.rd()))
             {
                 all_blocked = true;
                 break;
             }
             in.read(1);
             work_done = true;
         }
         // Risk blocking on read() only when we have nothing else to do
         // and we know a result is coming.
         while ((all_blocked || !work_done || jobs.full()) &&
                !jobs.empty() &&
                jobs.peek()->h->b_out &&
                out.writable() >= 1 &&
                opt_writable(bitcount, 1) && opt_writable(errcount, 1))
         {
             receive_frame(jobs.get());
         }
     }

Here is the call graph for this function:

◆ send_frame()

template<typename SOFTBIT , typename SOFTBYTE >

bool leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::send_frame ( fecframe< SOFTBYTE > * pin )

inlineprivate

Definition at line 2280 of file dvbs2.h.

     {
         pool *p = get_pool(&pin->pls);
         for (int i = 0; i < p->nprocs; ++i)
         {
             helper_instance *h = &p->procs[i];
             size_t iosize = (pin->pls.framebits() / 8) * sizeof(SOFTBYTE);
             // fprintf(stderr, "Writing %lu to fd %d\n", iosize, h->fd_tx);
             int nw = write(h->fd_tx, pin->bytes, iosize);
             if (nw < 0 && errno == EWOULDBLOCK)
                 continue;
             if (nw < 0)
                 fatal("write(LDPC helper");
             if (nw != iosize)
                 fatal("partial write(LDPC helper)");
             helper_job *job = jobs.put();
             job->pls = pin->pls;
             job->h = h;
             ++h->b_in;
             if (h->b_in >= h->batch_size)
             {
                 h->b_in -= h->batch_size;
                 h->b_out += h->batch_size;
             }
             return true;
         }
         return false;
     }

Here is the call graph for this function:

◆ spawn_helper()

template<typename SOFTBIT , typename SOFTBYTE >

void leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::spawn_helper	(	helper_instance *	h,
		const s2_pls *	pls
	)

inlineprivate

Definition at line 2322 of file dvbs2.h.

References leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::b_in, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::b_out, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::batch_size, leansdr::fatal(), leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::fd_rx, leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::helper_instance::fd_tx, leansdr::s2_pls::modcod, and leansdr::s2_pls::sf.

     {
         if (sch->debug)
             fprintf(stderr, "Spawning LDPC helper: modcod=%d sf=%d\n",
                     pls->modcod, pls->sf);
         int tx[2], rx[2];
         if (pipe(tx) || pipe(rx))
             fatal("pipe");
         // Size the pipes so that the helper never runs out of work to do.
         int pipesize = 64800 * batch_size;
         if (fcntl(tx[0], F_SETPIPE_SZ, pipesize) < 0 ||
             fcntl(rx[0], F_SETPIPE_SZ, pipesize) < 0 ||
             fcntl(tx[1], F_SETPIPE_SZ, pipesize) < 0 ||
             fcntl(rx[1], F_SETPIPE_SZ, pipesize) < 0)
         {
             fprintf(stderr,
                     "*** Failed to increase pipe size.\n"
                     "*** Try echo %d > /proc/sys/fs/pipe-max-size\n",
                     pipesize);
             if (must_buffer)
                 fatal("F_SETPIPE_SZ");
             else
                 fprintf(stderr, "*** Throughput will be suboptimal.\n");
         }
         int child = vfork();
         if (!child)
         {
             // Child process
             close(tx[1]);
             dup2(tx[0], 0);
             close(rx[0]);
             dup2(rx[1], 1);
             char mc_arg[16];
             sprintf(mc_arg, "%d", pls->modcod);
             const char *sf_arg = pls->sf ? "--shortframes" : NULL;
             const char *argv[] = {command, "--modcod", mc_arg, sf_arg, NULL};
             execve(command, (char *const *)argv, NULL);
             fatal(command);
         }
         h->fd_tx = tx[1];
         close(tx[0]);
         h->fd_rx = rx[0];
         close(rx[1]);
         h->batch_size = 32; // TBD
         h->b_in = h->b_out = 0;
         int flags = fcntl(h->fd_tx, F_GETFL);
         if (fcntl(h->fd_tx, F_SETFL, flags | O_NONBLOCK))
             fatal("fcntl(helper)");
     }

Here is the call graph for this function:

Member Data Documentation

◆ batch_size

template<typename SOFTBIT , typename SOFTBYTE >

int leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::batch_size

Definition at line 2210 of file dvbs2.h.

◆ bbscrambling

template<typename SOFTBIT , typename SOFTBYTE >

s2_bbscrambling leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::bbscrambling

private

Definition at line 2423 of file dvbs2.h.

◆ bch_buf

template<typename SOFTBIT , typename SOFTBYTE >

uint8_t leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::bch_buf[64800/8]

private

Definition at line 2421 of file dvbs2.h.

◆ bitcount

template<typename SOFTBIT , typename SOFTBYTE >

pipewriter<int>* leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::bitcount

private

Definition at line 2424 of file dvbs2.h.

◆ command

template<typename SOFTBIT , typename SOFTBYTE >

const char* leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::command

private

Definition at line 2419 of file dvbs2.h.

◆ errcount

template<typename SOFTBIT , typename SOFTBYTE >

pipewriter<int> * leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::errcount

private

Definition at line 2424 of file dvbs2.h.

◆ in

template<typename SOFTBIT , typename SOFTBYTE >

pipereader<fecframe<SOFTBYTE> > leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::in

private

Definition at line 2417 of file dvbs2.h.

◆ jobs

template<typename SOFTBIT , typename SOFTBYTE >

simplequeue<helper_job, 1024> leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::jobs

private

Definition at line 2278 of file dvbs2.h.

◆ ldpc_buf

template<typename SOFTBIT , typename SOFTBYTE >

SOFTBYTE leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::ldpc_buf[64800/8]

private

Definition at line 2420 of file dvbs2.h.

◆ must_buffer

template<typename SOFTBIT , typename SOFTBYTE >

bool leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::must_buffer

Definition at line 2212 of file dvbs2.h.

◆ nhelpers

template<typename SOFTBIT , typename SOFTBYTE >

int leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::nhelpers

Definition at line 2211 of file dvbs2.h.

◆ out

template<typename SOFTBIT , typename SOFTBYTE >

pipewriter<bbframe> leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::out

private

Definition at line 2418 of file dvbs2.h.

◆ pools

template<typename SOFTBIT , typename SOFTBYTE >

struct leansdr::s2_fecdec_helper::pool leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::pools[32][2]

private

◆ s2bch

template<typename SOFTBIT , typename SOFTBYTE >

s2_bch_engines leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >::s2bch

private

Definition at line 2422 of file dvbs2.h.

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

plugins/channelrx/demoddatv/leansdr/dvbs2.h

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename SOFTBIT, typename SOFTBYTE> struct leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >

Constructor & Destructor Documentation

◆ s2_fecdec_helper()

Member Function Documentation

◆ get_pool()

◆ receive_frame()

◆ run()

◆ send_frame()

◆ spawn_helper()

Member Data Documentation

◆ batch_size

◆ bbscrambling

◆ bch_buf

◆ bitcount

◆ command

◆ errcount

◆ in

◆ jobs

◆ ldpc_buf

◆ must_buffer

◆ nhelpers

◆ out

◆ pools

◆ s2bch

template<typename SOFTBIT, typename SOFTBYTE>
struct leansdr::s2_fecdec_helper< SOFTBIT, SOFTBYTE >