gnuradio.fec

Blocks for forward error correction.

gnuradio.fec.async_decoder(generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) → async_decoder_sptr
async_decoder_sptr.active_thread_priority(async_decoder_sptr self) → int
async_decoder_sptr.declare_sample_delay(async_decoder_sptr self, int which, int delay)

declare_sample_delay(async_decoder_sptr self, unsigned int delay)

async_decoder_sptr.general_work(async_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int
async_decoder_sptr.message_subscribers(async_decoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
async_decoder_sptr.min_noutput_items(async_decoder_sptr self) → int
async_decoder_sptr.pc_input_buffers_full_avg(async_decoder_sptr self, int which) → float

pc_input_buffers_full_avg(async_decoder_sptr self) -> pmt_vector_float

async_decoder_sptr.pc_noutput_items_avg(async_decoder_sptr self) → float
async_decoder_sptr.pc_nproduced_avg(async_decoder_sptr self) → float
async_decoder_sptr.pc_output_buffers_full_avg(async_decoder_sptr self, int which) → float

pc_output_buffers_full_avg(async_decoder_sptr self) -> pmt_vector_float

async_decoder_sptr.pc_throughput_avg(async_decoder_sptr self) → float
async_decoder_sptr.pc_work_time_avg(async_decoder_sptr self) → float
async_decoder_sptr.pc_work_time_total(async_decoder_sptr self) → float
async_decoder_sptr.sample_delay(async_decoder_sptr self, int which) → unsigned int
async_decoder_sptr.set_min_noutput_items(async_decoder_sptr self, int m)
async_decoder_sptr.set_thread_priority(async_decoder_sptr self, int priority) → int
async_decoder_sptr.thread_priority(async_decoder_sptr self) → int
gnuradio.fec.async_encoder(generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) → async_encoder_sptr
async_encoder_sptr.active_thread_priority(async_encoder_sptr self) → int
async_encoder_sptr.declare_sample_delay(async_encoder_sptr self, int which, int delay)

declare_sample_delay(async_encoder_sptr self, unsigned int delay)

async_encoder_sptr.general_work(async_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int
async_encoder_sptr.message_subscribers(async_encoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
async_encoder_sptr.min_noutput_items(async_encoder_sptr self) → int
async_encoder_sptr.pc_input_buffers_full_avg(async_encoder_sptr self, int which) → float

pc_input_buffers_full_avg(async_encoder_sptr self) -> pmt_vector_float

async_encoder_sptr.pc_noutput_items_avg(async_encoder_sptr self) → float
async_encoder_sptr.pc_nproduced_avg(async_encoder_sptr self) → float
async_encoder_sptr.pc_output_buffers_full_avg(async_encoder_sptr self, int which) → float

pc_output_buffers_full_avg(async_encoder_sptr self) -> pmt_vector_float

async_encoder_sptr.pc_throughput_avg(async_encoder_sptr self) → float
async_encoder_sptr.pc_work_time_avg(async_encoder_sptr self) → float
async_encoder_sptr.pc_work_time_total(async_encoder_sptr self) → float
async_encoder_sptr.sample_delay(async_encoder_sptr self, int which) → unsigned int
async_encoder_sptr.set_min_noutput_items(async_encoder_sptr self, int m)
async_encoder_sptr.set_thread_priority(async_encoder_sptr self, int priority) → int
async_encoder_sptr.thread_priority(async_encoder_sptr self) → int
gnuradio.fec.ber_bf(bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) → ber_bf_sptr
ber_bf_sptr.active_thread_priority(ber_bf_sptr self) → int
ber_bf_sptr.declare_sample_delay(ber_bf_sptr self, int which, int delay)

declare_sample_delay(ber_bf_sptr self, unsigned int delay)

ber_bf_sptr.message_subscribers(ber_bf_sptr self, swig_int_ptr which_port) → swig_int_ptr
ber_bf_sptr.min_noutput_items(ber_bf_sptr self) → int
ber_bf_sptr.pc_input_buffers_full_avg(ber_bf_sptr self, int which) → float

pc_input_buffers_full_avg(ber_bf_sptr self) -> pmt_vector_float

ber_bf_sptr.pc_noutput_items_avg(ber_bf_sptr self) → float
ber_bf_sptr.pc_nproduced_avg(ber_bf_sptr self) → float
ber_bf_sptr.pc_output_buffers_full_avg(ber_bf_sptr self, int which) → float

pc_output_buffers_full_avg(ber_bf_sptr self) -> pmt_vector_float

ber_bf_sptr.pc_throughput_avg(ber_bf_sptr self) → float
ber_bf_sptr.pc_work_time_avg(ber_bf_sptr self) → float
ber_bf_sptr.pc_work_time_total(ber_bf_sptr self) → float
ber_bf_sptr.sample_delay(ber_bf_sptr self, int which) → unsigned int
ber_bf_sptr.set_min_noutput_items(ber_bf_sptr self, int m)
ber_bf_sptr.set_thread_priority(ber_bf_sptr self, int priority) → int
ber_bf_sptr.thread_priority(ber_bf_sptr self) → int
ber_bf_sptr.total_errors(ber_bf_sptr self) → long
gnuradio.fec.conv_bit_corr_bb(std::vector< unsigned long long, std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) → conv_bit_corr_bb_sptr
conv_bit_corr_bb_sptr.active_thread_priority(conv_bit_corr_bb_sptr self) → int
conv_bit_corr_bb_sptr.data_garble_rate(conv_bit_corr_bb_sptr self, int taps, float syn_density) → float
conv_bit_corr_bb_sptr.declare_sample_delay(conv_bit_corr_bb_sptr self, int which, int delay)

declare_sample_delay(conv_bit_corr_bb_sptr self, unsigned int delay)

conv_bit_corr_bb_sptr.message_subscribers(conv_bit_corr_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
conv_bit_corr_bb_sptr.min_noutput_items(conv_bit_corr_bb_sptr self) → int
conv_bit_corr_bb_sptr.pc_input_buffers_full_avg(conv_bit_corr_bb_sptr self, int which) → float

pc_input_buffers_full_avg(conv_bit_corr_bb_sptr self) -> pmt_vector_float

conv_bit_corr_bb_sptr.pc_noutput_items_avg(conv_bit_corr_bb_sptr self) → float
conv_bit_corr_bb_sptr.pc_nproduced_avg(conv_bit_corr_bb_sptr self) → float
conv_bit_corr_bb_sptr.pc_output_buffers_full_avg(conv_bit_corr_bb_sptr self, int which) → float

pc_output_buffers_full_avg(conv_bit_corr_bb_sptr self) -> pmt_vector_float

conv_bit_corr_bb_sptr.pc_throughput_avg(conv_bit_corr_bb_sptr self) → float
conv_bit_corr_bb_sptr.pc_work_time_avg(conv_bit_corr_bb_sptr self) → float
conv_bit_corr_bb_sptr.pc_work_time_total(conv_bit_corr_bb_sptr self) → float
conv_bit_corr_bb_sptr.sample_delay(conv_bit_corr_bb_sptr self, int which) → unsigned int
conv_bit_corr_bb_sptr.set_min_noutput_items(conv_bit_corr_bb_sptr self, int m)
conv_bit_corr_bb_sptr.set_thread_priority(conv_bit_corr_bb_sptr self, int priority) → int
conv_bit_corr_bb_sptr.thread_priority(conv_bit_corr_bb_sptr self) → int
gnuradio.fec.decode_ccsds_27_fb() → decode_ccsds_27_fb_sptr
decode_ccsds_27_fb_sptr.active_thread_priority(decode_ccsds_27_fb_sptr self) → int
decode_ccsds_27_fb_sptr.declare_sample_delay(decode_ccsds_27_fb_sptr self, int which, int delay)

declare_sample_delay(decode_ccsds_27_fb_sptr self, unsigned int delay)

decode_ccsds_27_fb_sptr.message_subscribers(decode_ccsds_27_fb_sptr self, swig_int_ptr which_port) → swig_int_ptr
decode_ccsds_27_fb_sptr.min_noutput_items(decode_ccsds_27_fb_sptr self) → int
decode_ccsds_27_fb_sptr.pc_input_buffers_full_avg(decode_ccsds_27_fb_sptr self, int which) → float

pc_input_buffers_full_avg(decode_ccsds_27_fb_sptr self) -> pmt_vector_float

decode_ccsds_27_fb_sptr.pc_noutput_items_avg(decode_ccsds_27_fb_sptr self) → float
decode_ccsds_27_fb_sptr.pc_nproduced_avg(decode_ccsds_27_fb_sptr self) → float
decode_ccsds_27_fb_sptr.pc_output_buffers_full_avg(decode_ccsds_27_fb_sptr self, int which) → float

pc_output_buffers_full_avg(decode_ccsds_27_fb_sptr self) -> pmt_vector_float

decode_ccsds_27_fb_sptr.pc_throughput_avg(decode_ccsds_27_fb_sptr self) → float
decode_ccsds_27_fb_sptr.pc_work_time_avg(decode_ccsds_27_fb_sptr self) → float
decode_ccsds_27_fb_sptr.pc_work_time_total(decode_ccsds_27_fb_sptr self) → float
decode_ccsds_27_fb_sptr.sample_delay(decode_ccsds_27_fb_sptr self, int which) → unsigned int
decode_ccsds_27_fb_sptr.set_min_noutput_items(decode_ccsds_27_fb_sptr self, int m)
decode_ccsds_27_fb_sptr.set_thread_priority(decode_ccsds_27_fb_sptr self, int priority) → int
decode_ccsds_27_fb_sptr.thread_priority(decode_ccsds_27_fb_sptr self) → int
gnuradio.fec.decoder(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) → decoder_sptr
decoder_sptr.active_thread_priority(decoder_sptr self) → int
decoder_sptr.declare_sample_delay(decoder_sptr self, int which, int delay)

declare_sample_delay(decoder_sptr self, unsigned int delay)

decoder_sptr.fixed_rate_ninput_to_noutput(decoder_sptr self, int ninput) → int
decoder_sptr.fixed_rate_noutput_to_ninput(decoder_sptr self, int noutput) → int
decoder_sptr.forecast(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)
decoder_sptr.general_work(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int
decoder_sptr.message_subscribers(decoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
decoder_sptr.min_noutput_items(decoder_sptr self) → int
decoder_sptr.pc_input_buffers_full_avg(decoder_sptr self, int which) → float

pc_input_buffers_full_avg(decoder_sptr self) -> pmt_vector_float

decoder_sptr.pc_noutput_items_avg(decoder_sptr self) → float
decoder_sptr.pc_nproduced_avg(decoder_sptr self) → float
decoder_sptr.pc_output_buffers_full_avg(decoder_sptr self, int which) → float

pc_output_buffers_full_avg(decoder_sptr self) -> pmt_vector_float

decoder_sptr.pc_throughput_avg(decoder_sptr self) → float
decoder_sptr.pc_work_time_avg(decoder_sptr self) → float
decoder_sptr.pc_work_time_total(decoder_sptr self) → float
decoder_sptr.sample_delay(decoder_sptr self, int which) → unsigned int
decoder_sptr.set_min_noutput_items(decoder_sptr self, int m)
decoder_sptr.set_thread_priority(decoder_sptr self, int priority) → int
decoder_sptr.thread_priority(decoder_sptr self) → int
gnuradio.fec.depuncture_bb(int puncsize, int puncpat, int delay=0, char symbol=127) → depuncture_bb_sptr
depuncture_bb_sptr.active_thread_priority(depuncture_bb_sptr self) → int
depuncture_bb_sptr.declare_sample_delay(depuncture_bb_sptr self, int which, int delay)

declare_sample_delay(depuncture_bb_sptr self, unsigned int delay)

depuncture_bb_sptr.message_subscribers(depuncture_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
depuncture_bb_sptr.min_noutput_items(depuncture_bb_sptr self) → int
depuncture_bb_sptr.pc_input_buffers_full_avg(depuncture_bb_sptr self, int which) → float

pc_input_buffers_full_avg(depuncture_bb_sptr self) -> pmt_vector_float

depuncture_bb_sptr.pc_noutput_items_avg(depuncture_bb_sptr self) → float
depuncture_bb_sptr.pc_nproduced_avg(depuncture_bb_sptr self) → float
depuncture_bb_sptr.pc_output_buffers_full_avg(depuncture_bb_sptr self, int which) → float

pc_output_buffers_full_avg(depuncture_bb_sptr self) -> pmt_vector_float

depuncture_bb_sptr.pc_throughput_avg(depuncture_bb_sptr self) → float
depuncture_bb_sptr.pc_work_time_avg(depuncture_bb_sptr self) → float
depuncture_bb_sptr.pc_work_time_total(depuncture_bb_sptr self) → float
depuncture_bb_sptr.sample_delay(depuncture_bb_sptr self, int which) → unsigned int
depuncture_bb_sptr.set_min_noutput_items(depuncture_bb_sptr self, int m)
depuncture_bb_sptr.set_thread_priority(depuncture_bb_sptr self, int priority) → int
depuncture_bb_sptr.thread_priority(depuncture_bb_sptr self) → int
gnuradio.fec.encode_ccsds_27_bb() → encode_ccsds_27_bb_sptr
encode_ccsds_27_bb_sptr.active_thread_priority(encode_ccsds_27_bb_sptr self) → int
encode_ccsds_27_bb_sptr.declare_sample_delay(encode_ccsds_27_bb_sptr self, int which, int delay)

declare_sample_delay(encode_ccsds_27_bb_sptr self, unsigned int delay)

encode_ccsds_27_bb_sptr.message_subscribers(encode_ccsds_27_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
encode_ccsds_27_bb_sptr.min_noutput_items(encode_ccsds_27_bb_sptr self) → int
encode_ccsds_27_bb_sptr.pc_input_buffers_full_avg(encode_ccsds_27_bb_sptr self, int which) → float

pc_input_buffers_full_avg(encode_ccsds_27_bb_sptr self) -> pmt_vector_float

encode_ccsds_27_bb_sptr.pc_noutput_items_avg(encode_ccsds_27_bb_sptr self) → float
encode_ccsds_27_bb_sptr.pc_nproduced_avg(encode_ccsds_27_bb_sptr self) → float
encode_ccsds_27_bb_sptr.pc_output_buffers_full_avg(encode_ccsds_27_bb_sptr self, int which) → float

pc_output_buffers_full_avg(encode_ccsds_27_bb_sptr self) -> pmt_vector_float

encode_ccsds_27_bb_sptr.pc_throughput_avg(encode_ccsds_27_bb_sptr self) → float
encode_ccsds_27_bb_sptr.pc_work_time_avg(encode_ccsds_27_bb_sptr self) → float
encode_ccsds_27_bb_sptr.pc_work_time_total(encode_ccsds_27_bb_sptr self) → float
encode_ccsds_27_bb_sptr.sample_delay(encode_ccsds_27_bb_sptr self, int which) → unsigned int
encode_ccsds_27_bb_sptr.set_min_noutput_items(encode_ccsds_27_bb_sptr self, int m)
encode_ccsds_27_bb_sptr.set_thread_priority(encode_ccsds_27_bb_sptr self, int priority) → int
encode_ccsds_27_bb_sptr.thread_priority(encode_ccsds_27_bb_sptr self) → int
gnuradio.fec.encoder(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) → encoder_sptr
encoder_sptr.active_thread_priority(encoder_sptr self) → int
encoder_sptr.declare_sample_delay(encoder_sptr self, int which, int delay)

declare_sample_delay(encoder_sptr self, unsigned int delay)

encoder_sptr.fixed_rate_ninput_to_noutput(encoder_sptr self, int ninput) → int
encoder_sptr.fixed_rate_noutput_to_ninput(encoder_sptr self, int noutput) → int
encoder_sptr.forecast(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)
encoder_sptr.general_work(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int
encoder_sptr.message_subscribers(encoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
encoder_sptr.min_noutput_items(encoder_sptr self) → int
encoder_sptr.pc_input_buffers_full_avg(encoder_sptr self, int which) → float

pc_input_buffers_full_avg(encoder_sptr self) -> pmt_vector_float

encoder_sptr.pc_noutput_items_avg(encoder_sptr self) → float
encoder_sptr.pc_nproduced_avg(encoder_sptr self) → float
encoder_sptr.pc_output_buffers_full_avg(encoder_sptr self, int which) → float

pc_output_buffers_full_avg(encoder_sptr self) -> pmt_vector_float

encoder_sptr.pc_throughput_avg(encoder_sptr self) → float
encoder_sptr.pc_work_time_avg(encoder_sptr self) → float
encoder_sptr.pc_work_time_total(encoder_sptr self) → float
encoder_sptr.sample_delay(encoder_sptr self, int which) → unsigned int
encoder_sptr.set_min_noutput_items(encoder_sptr self, int m)
encoder_sptr.set_thread_priority(encoder_sptr self, int priority) → int
encoder_sptr.thread_priority(encoder_sptr self) → int
gnuradio.fec.generic_decoder(*args, **kwargs)

Proxy of C++ gr::fec::generic_decoder class

generic_decoder_sptr.base_unique_id(generic_decoder_sptr self) → int
generic_decoder_sptr.d_name(generic_decoder_sptr self) → std::string const &
generic_decoder_sptr.generic_work(generic_decoder_sptr self, void * inbuffer, void * outbuffer)
generic_decoder_sptr.get_history(generic_decoder_sptr self) → int
generic_decoder_sptr.get_input_conversion(generic_decoder_sptr self) → char const *
generic_decoder_sptr.get_input_item_size(generic_decoder_sptr self) → int
generic_decoder_sptr.get_input_size(generic_decoder_sptr self) → int
generic_decoder_sptr.get_iterations(generic_decoder_sptr self) → float
generic_decoder_sptr.get_output_conversion(generic_decoder_sptr self) → char const *
generic_decoder_sptr.get_output_item_size(generic_decoder_sptr self) → int
generic_decoder_sptr.get_output_size(generic_decoder_sptr self) → int
generic_decoder_sptr.get_shift(generic_decoder_sptr self) → float
generic_decoder_sptr.my_id(generic_decoder_sptr self) → int
generic_decoder_sptr.rate(generic_decoder_sptr self) → double
generic_decoder_sptr.set_frame_size(generic_decoder_sptr self, unsigned int frame_size) → bool
gnuradio.fec.generic_encoder(*args, **kwargs)

Proxy of C++ gr::fec::generic_encoder class

generic_encoder_sptr.base_unique_id(generic_encoder_sptr self) → int
generic_encoder_sptr.d_name(generic_encoder_sptr self) → std::string const &
generic_encoder_sptr.generic_work(generic_encoder_sptr self, void * in_buffer, void * out_buffer)
generic_encoder_sptr.get_input_conversion(generic_encoder_sptr self) → char const *
generic_encoder_sptr.get_input_size(generic_encoder_sptr self) → int
generic_encoder_sptr.get_output_conversion(generic_encoder_sptr self) → char const *
generic_encoder_sptr.get_output_size(generic_encoder_sptr self) → int
generic_encoder_sptr.my_id(generic_encoder_sptr self) → int
generic_encoder_sptr.rate(generic_encoder_sptr self) → double
generic_encoder_sptr.set_frame_size(generic_encoder_sptr self, unsigned int frame_size) → bool
gnuradio.fec.puncture_bb(int puncsize, int puncpat, int delay=0) → puncture_bb_sptr
puncture_bb_sptr.active_thread_priority(puncture_bb_sptr self) → int
puncture_bb_sptr.declare_sample_delay(puncture_bb_sptr self, int which, int delay)

declare_sample_delay(puncture_bb_sptr self, unsigned int delay)

puncture_bb_sptr.message_subscribers(puncture_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
puncture_bb_sptr.min_noutput_items(puncture_bb_sptr self) → int
puncture_bb_sptr.pc_input_buffers_full_avg(puncture_bb_sptr self, int which) → float

pc_input_buffers_full_avg(puncture_bb_sptr self) -> pmt_vector_float

puncture_bb_sptr.pc_noutput_items_avg(puncture_bb_sptr self) → float
puncture_bb_sptr.pc_nproduced_avg(puncture_bb_sptr self) → float
puncture_bb_sptr.pc_output_buffers_full_avg(puncture_bb_sptr self, int which) → float

pc_output_buffers_full_avg(puncture_bb_sptr self) -> pmt_vector_float

puncture_bb_sptr.pc_throughput_avg(puncture_bb_sptr self) → float
puncture_bb_sptr.pc_work_time_avg(puncture_bb_sptr self) → float
puncture_bb_sptr.pc_work_time_total(puncture_bb_sptr self) → float
puncture_bb_sptr.sample_delay(puncture_bb_sptr self, int which) → unsigned int
puncture_bb_sptr.set_min_noutput_items(puncture_bb_sptr self, int m)
puncture_bb_sptr.set_thread_priority(puncture_bb_sptr self, int priority) → int
puncture_bb_sptr.thread_priority(puncture_bb_sptr self) → int
gnuradio.fec.puncture_ff(int puncsize, int puncpat, int delay) → puncture_ff_sptr
puncture_ff_sptr.active_thread_priority(puncture_ff_sptr self) → int
puncture_ff_sptr.declare_sample_delay(puncture_ff_sptr self, int which, int delay)

declare_sample_delay(puncture_ff_sptr self, unsigned int delay)

puncture_ff_sptr.message_subscribers(puncture_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
puncture_ff_sptr.min_noutput_items(puncture_ff_sptr self) → int
puncture_ff_sptr.pc_input_buffers_full_avg(puncture_ff_sptr self, int which) → float

pc_input_buffers_full_avg(puncture_ff_sptr self) -> pmt_vector_float

puncture_ff_sptr.pc_noutput_items_avg(puncture_ff_sptr self) → float
puncture_ff_sptr.pc_nproduced_avg(puncture_ff_sptr self) → float
puncture_ff_sptr.pc_output_buffers_full_avg(puncture_ff_sptr self, int which) → float

pc_output_buffers_full_avg(puncture_ff_sptr self) -> pmt_vector_float

puncture_ff_sptr.pc_throughput_avg(puncture_ff_sptr self) → float
puncture_ff_sptr.pc_work_time_avg(puncture_ff_sptr self) → float
puncture_ff_sptr.pc_work_time_total(puncture_ff_sptr self) → float
puncture_ff_sptr.sample_delay(puncture_ff_sptr self, int which) → unsigned int
puncture_ff_sptr.set_min_noutput_items(puncture_ff_sptr self, int m)
puncture_ff_sptr.set_thread_priority(puncture_ff_sptr self, int priority) → int
puncture_ff_sptr.thread_priority(puncture_ff_sptr self) → int
gnuradio.fec.tagged_decoder(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) → tagged_decoder_sptr
tagged_decoder_sptr.active_thread_priority(tagged_decoder_sptr self) → int
tagged_decoder_sptr.calculate_output_stream_length(tagged_decoder_sptr self, gr_vector_int const & ninput_items) → int
tagged_decoder_sptr.declare_sample_delay(tagged_decoder_sptr self, int which, int delay)

declare_sample_delay(tagged_decoder_sptr self, unsigned int delay)

tagged_decoder_sptr.message_subscribers(tagged_decoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
tagged_decoder_sptr.min_noutput_items(tagged_decoder_sptr self) → int
tagged_decoder_sptr.pc_input_buffers_full_avg(tagged_decoder_sptr self, int which) → float

pc_input_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float

tagged_decoder_sptr.pc_noutput_items_avg(tagged_decoder_sptr self) → float
tagged_decoder_sptr.pc_nproduced_avg(tagged_decoder_sptr self) → float
tagged_decoder_sptr.pc_output_buffers_full_avg(tagged_decoder_sptr self, int which) → float

pc_output_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float

tagged_decoder_sptr.pc_throughput_avg(tagged_decoder_sptr self) → float
tagged_decoder_sptr.pc_work_time_avg(tagged_decoder_sptr self) → float
tagged_decoder_sptr.pc_work_time_total(tagged_decoder_sptr self) → float
tagged_decoder_sptr.sample_delay(tagged_decoder_sptr self, int which) → unsigned int
tagged_decoder_sptr.set_min_noutput_items(tagged_decoder_sptr self, int m)
tagged_decoder_sptr.set_thread_priority(tagged_decoder_sptr self, int priority) → int
tagged_decoder_sptr.thread_priority(tagged_decoder_sptr self) → int
tagged_decoder_sptr.work(tagged_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int
gnuradio.fec.tagged_encoder(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) → tagged_encoder_sptr
tagged_encoder_sptr.active_thread_priority(tagged_encoder_sptr self) → int
tagged_encoder_sptr.calculate_output_stream_length(tagged_encoder_sptr self, gr_vector_int const & ninput_items) → int
tagged_encoder_sptr.declare_sample_delay(tagged_encoder_sptr self, int which, int delay)

declare_sample_delay(tagged_encoder_sptr self, unsigned int delay)

tagged_encoder_sptr.message_subscribers(tagged_encoder_sptr self, swig_int_ptr which_port) → swig_int_ptr
tagged_encoder_sptr.min_noutput_items(tagged_encoder_sptr self) → int
tagged_encoder_sptr.pc_input_buffers_full_avg(tagged_encoder_sptr self, int which) → float

pc_input_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float

tagged_encoder_sptr.pc_noutput_items_avg(tagged_encoder_sptr self) → float
tagged_encoder_sptr.pc_nproduced_avg(tagged_encoder_sptr self) → float
tagged_encoder_sptr.pc_output_buffers_full_avg(tagged_encoder_sptr self, int which) → float

pc_output_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float

tagged_encoder_sptr.pc_throughput_avg(tagged_encoder_sptr self) → float
tagged_encoder_sptr.pc_work_time_avg(tagged_encoder_sptr self) → float
tagged_encoder_sptr.pc_work_time_total(tagged_encoder_sptr self) → float
tagged_encoder_sptr.sample_delay(tagged_encoder_sptr self, int which) → unsigned int
tagged_encoder_sptr.set_min_noutput_items(tagged_encoder_sptr self, int m)
tagged_encoder_sptr.set_thread_priority(tagged_encoder_sptr self, int priority) → int
tagged_encoder_sptr.thread_priority(tagged_encoder_sptr self) → int
tagged_encoder_sptr.work(tagged_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) → int