leansdr::hdlc_sync Struct Reference

#include <hdlc.h>

Inheritance diagram for leansdr::hdlc_sync:

Collaboration diagram for leansdr::hdlc_sync:

Public Member Functions
	hdlc_sync (scheduler *sch, pipebuf< u8 > &_in, pipebuf< u8 > &_out, int _minframesize, int _maxframesize, pipebuf< int > *_lock_out=NULL, pipebuf< int > *_framecount_out=NULL, pipebuf< int > *_fcserrcount_out=NULL, pipebuf< int > *_hdlcbytecount_out=NULL, pipebuf< int > *_databytecount_out=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	resync_period
bool	header16
hdlc_dec *	dec
int	errhist [NERRHIST]
Public Attributes inherited from leansdr::runnable_common
const char *	name

Private Member Functions
void	output_frame (u8 *f, int size)

Private Attributes
int	minframesize
int	maxframesize
int	chunk_size
pipereader< u8 >	in
pipewriter< u8 >	out
pipewriter< int > *	lock_out
pipewriter< int > *	framecount_out
pipewriter< int > *	fcserrcount_out
pipewriter< int > *	hdlcbytecount_out
pipewriter< int > *	databytecount_out
struct {
hdlc_dec *   dec
int   errhist [NERRHIST]
}	syncs [NSYNCS]
int	errslot
int	cur_sync
int	resync_phase
bool	lock_state

Static Private Attributes
static const int	NSYNCS = 2
static const int	NERRHIST = 2

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

Detailed Description

Definition at line 197 of file hdlc.h.

Constructor & Destructor Documentation

hdlc_sync()

leansdr::hdlc_sync::hdlc_sync ( scheduler *  sch, pipebuf< u8 > &  _in, pipebuf< u8 > &  _out, int  _minframesize, int  _maxframesize, pipebuf< int > *  _lock_out = NULL, pipebuf< int > *  _framecount_out = NULL, pipebuf< int > *  _fcserrcount_out = NULL, pipebuf< int > *  _hdlcbytecount_out = NULL, pipebuf< int > *  _databytecount_out = NULL  )

inline

Definition at line 199 of file hdlc.h.

References leansdr::scheduler::debug, leansdr::hdlc_dec::hdlc_dec(), leansdr::hdlc_dec::maxframesize, and leansdr::hdlc_dec::minframesize.

                                                       : runnable(sch, "hdlc_sync"),
                                                         minframesize(_minframesize),
                                                         maxframesize(_maxframesize),
                                                         chunk_size(maxframesize + 2),
                                                         in(_in),
                                                         out(_out, _maxframesize + chunk_size),
                                                         lock_out(opt_writer(_lock_out)),
                                                         framecount_out(opt_writer(_framecount_out)),
                                                         fcserrcount_out(opt_writer(_fcserrcount_out)),
                                                         hdlcbytecount_out(opt_writer(_hdlcbytecount_out)),
                                                         databytecount_out(opt_writer(_databytecount_out)),
                                                         cur_sync(0),
                                                         resync_phase(0),
                                                         lock_state(false),
                                                         resync_period(32),
                                                         header16(false)
    {
        for (int s = 0; s < NSYNCS; ++s)
        {
            syncs[s].dec = new hdlc_dec(minframesize, maxframesize, s != 0);

            for (int h = 0; h < NERRHIST; ++h)
                syncs[s].errhist[h] = 0;
        }

        syncs[cur_sync].dec->debug = sch->debug;
        errslot = 0;
    }

Here is the call graph for this function:

Member Function Documentation

output_frame()

void leansdr::hdlc_sync::output_frame ( u8 *  f, int  size  )

inlineprivate

Definition at line 353 of file hdlc.h.

References leansdr::opt_write().

    {
        if (header16)
        {
            // Removed 16-bit CRC, add 16-bit prefix -> Still <= maxframesize.
            out.write(size >> 8);
            out.write(size & 255);
        }

        memcpy(out.wr(), f, size);
        out.written(size);
        opt_write(framecount_out, 1);
    }

Here is the call graph for this function:

run()

void leansdr::hdlc_sync::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 237 of file hdlc.h.

References leansdr::hdlc_dec::maxframesize, leansdr::opt_writable(), and leansdr::opt_write().

    {
        if (!opt_writable(lock_out) || !opt_writable(framecount_out) || !opt_writable(fcserrcount_out) || !opt_writable(hdlcbytecount_out) || !opt_writable(databytecount_out))
        {
            return;
        }

        bool previous_lock_state = lock_state;
        int fcserrcount = 0, framecount = 0;
        int hdlcbytecount = 0, databytecount = 0;

        // Note: hdlc_dec may already hold one frame ready for output.
        while ((long)in.readable() >= chunk_size && (long)out.writable() >= maxframesize + chunk_size)
        {
            if (!resync_phase)
            {
                // Once every resync_phase, try all decoders
                for (int s = 0; s < NSYNCS; ++s)
                {
                    if (s != cur_sync)
                        syncs[s].dec->reset();

                    syncs[s].errhist[errslot] = 0;

                    for (u8 *pin = in.rd(), *pend = pin + chunk_size; pin < pend;)
                    {
                        int datasize, hdlc_errors, fcs_errors;
                        u8 *f = syncs[s].dec->decode(&pin, pend - pin, &datasize, &hdlc_errors, &fcs_errors);
                        syncs[s].errhist[errslot] += hdlc_errors;

                        if (s == cur_sync)
                        {
                            if (f)
                            {
                                lock_state = true;
                                output_frame(f, datasize);
                                databytecount += datasize;
                                ++framecount;
                            }

                            fcserrcount += fcs_errors;
                            framecount += fcs_errors;
                        }
                    }
                }

                errslot = (errslot + 1) % NERRHIST;
                // Switch to another sync option ?
                // Compare total error counts over about NERRHIST frames.
                int total_errors[NSYNCS];

                for (int s = 0; s < NSYNCS; ++s)
                {
                    total_errors[s] = 0;

                    for (int h = 0; h < NERRHIST; ++h)
                        total_errors[s] += syncs[s].errhist[h];
                }

                int best = cur_sync;

                for (int s = 0; s < NSYNCS; ++s)
                    if (total_errors[s] < total_errors[best])
                        best = s;

                if (best != cur_sync)
                {
                    lock_state = false;

                    if (sch->debug)
                        fprintf(stderr, "[%d:%d->%d:%d]", cur_sync, total_errors[cur_sync], best, total_errors[best]);

                    // No verbose messages on candidate syncs
                    syncs[cur_sync].dec->debug = false;
                    cur_sync = best;
                    syncs[cur_sync].dec->debug = sch->debug;
                }
            }
            else
            {
                // Use only the currently selected decoder
                for (u8 *pin = in.rd(), *pend = pin + chunk_size; pin < pend;)
                {
                    int datasize, hdlc_errors, fcs_errors;
                    u8 *f = syncs[cur_sync].dec->decode(&pin, pend - pin, &datasize, &hdlc_errors, &fcs_errors);

                    if (f)
                    {
                        lock_state = true;
                        output_frame(f, datasize);
                        databytecount += datasize;
                        ++framecount;
                    }

                    fcserrcount += fcs_errors;
                    framecount += fcs_errors;
                }
            } // resync_phase

            in.read(chunk_size);
            hdlcbytecount += chunk_size;

            if (++resync_phase >= resync_period)
                resync_phase = 0;
        } // Work to do

        if (lock_state != previous_lock_state)
            opt_write(lock_out, lock_state ? 1 : 0);

        opt_write(framecount_out, framecount);
        opt_write(fcserrcount_out, fcserrcount);
        opt_write(hdlcbytecount_out, hdlcbytecount);
        opt_write(databytecount_out, databytecount);
    }

Here is the call graph for this function:

Member Data Documentation

chunk_size

int leansdr::hdlc_sync::chunk_size

private

Definition at line 368 of file hdlc.h.

cur_sync

int leansdr::hdlc_sync::cur_sync

private

Definition at line 384 of file hdlc.h.

databytecount_out

pipewriter<int> * leansdr::hdlc_sync::databytecount_out

private

Definition at line 373 of file hdlc.h.

dec

hdlc_dec* leansdr::hdlc_sync::dec

Definition at line 379 of file hdlc.h.

errhist

int leansdr::hdlc_sync::errhist[NERRHIST]

Definition at line 380 of file hdlc.h.

errslot

int leansdr::hdlc_sync::errslot

private

Definition at line 383 of file hdlc.h.

fcserrcount_out

pipewriter<int> * leansdr::hdlc_sync::fcserrcount_out

private

Definition at line 372 of file hdlc.h.

framecount_out

pipewriter<int>* leansdr::hdlc_sync::framecount_out

private

Definition at line 372 of file hdlc.h.

hdlcbytecount_out

pipewriter<int>* leansdr::hdlc_sync::hdlcbytecount_out

private

Definition at line 373 of file hdlc.h.

header16

bool leansdr::hdlc_sync::header16

Definition at line 390 of file hdlc.h.

in

pipereader<u8> leansdr::hdlc_sync::in

private

Definition at line 369 of file hdlc.h.

lock_out

pipewriter<int>* leansdr::hdlc_sync::lock_out

private

Definition at line 371 of file hdlc.h.

lock_state

bool leansdr::hdlc_sync::lock_state

private

Definition at line 386 of file hdlc.h.

maxframesize

int leansdr::hdlc_sync::maxframesize

private

Definition at line 367 of file hdlc.h.

minframesize

int leansdr::hdlc_sync::minframesize

private

Definition at line 367 of file hdlc.h.

NERRHIST

const int leansdr::hdlc_sync::NERRHIST = 2

staticprivate

Definition at line 375 of file hdlc.h.

NSYNCS

const int leansdr::hdlc_sync::NSYNCS = 2

staticprivate

Definition at line 374 of file hdlc.h.

out

pipewriter<u8> leansdr::hdlc_sync::out

private

Definition at line 370 of file hdlc.h.

resync_period

int leansdr::hdlc_sync::resync_period

Definition at line 389 of file hdlc.h.

resync_phase

int leansdr::hdlc_sync::resync_phase

private

Definition at line 385 of file hdlc.h.

syncs

struct { ... } leansdr::hdlc_sync::syncs[NSYNCS]

---

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

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