gnuradio.atsc: Signal Processing Blocks

gnuradio.atsc.bit_timing_loop() → atsc_bit_timing_loop_sptr

ATSC BitTimingLoop3

This class accepts a single real input and produces two outputs, the raw symbol (float) and the tag (atsc_syminfo)

atsc_bit_timing_loop_sptr.active_thread_priority(atsc_bit_timing_loop_sptr self) → int

atsc_bit_timing_loop_sptr.declare_sample_delay(atsc_bit_timing_loop_sptr self, int which, int delay)

declare_sample_delay(atsc_bit_timing_loop_sptr self, unsigned int delay)

atsc_bit_timing_loop_sptr.message_subscribers(atsc_bit_timing_loop_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_bit_timing_loop_sptr.min_noutput_items(atsc_bit_timing_loop_sptr self) → int

atsc_bit_timing_loop_sptr.pc_input_buffers_full_avg(atsc_bit_timing_loop_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_bit_timing_loop_sptr self) -> pmt_vector_float

atsc_bit_timing_loop_sptr.pc_noutput_items_avg(atsc_bit_timing_loop_sptr self) → float

atsc_bit_timing_loop_sptr.pc_nproduced_avg(atsc_bit_timing_loop_sptr self) → float

atsc_bit_timing_loop_sptr.pc_output_buffers_full_avg(atsc_bit_timing_loop_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_bit_timing_loop_sptr self) -> pmt_vector_float

atsc_bit_timing_loop_sptr.pc_work_time_avg(atsc_bit_timing_loop_sptr self) → float

atsc_bit_timing_loop_sptr.pc_work_time_total(atsc_bit_timing_loop_sptr self) → float

atsc_bit_timing_loop_sptr.reset(atsc_bit_timing_loop_sptr self)

atsc_bit_timing_loop_sptr.sample_delay(atsc_bit_timing_loop_sptr self, int which) → unsigned int

atsc_bit_timing_loop_sptr.set_min_noutput_items(atsc_bit_timing_loop_sptr self, int m)

atsc_bit_timing_loop_sptr.set_thread_priority(atsc_bit_timing_loop_sptr self, int priority) → int

atsc_bit_timing_loop_sptr.thread_priority(atsc_bit_timing_loop_sptr self) → int

gnuradio.atsc.deinterleaver() → atsc_deinterleaver_sptr

Deinterleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded > atsc_mpeg_packet_rs_encoded)

input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_rs_encoded.

atsc_deinterleaver_sptr.active_thread_priority(atsc_deinterleaver_sptr self) → int

atsc_deinterleaver_sptr.declare_sample_delay(atsc_deinterleaver_sptr self, int which, int delay)

declare_sample_delay(atsc_deinterleaver_sptr self, unsigned int delay)

atsc_deinterleaver_sptr.message_subscribers(atsc_deinterleaver_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_deinterleaver_sptr.min_noutput_items(atsc_deinterleaver_sptr self) → int

atsc_deinterleaver_sptr.pc_input_buffers_full_avg(atsc_deinterleaver_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_deinterleaver_sptr self) -> pmt_vector_float

atsc_deinterleaver_sptr.pc_noutput_items_avg(atsc_deinterleaver_sptr self) → float

atsc_deinterleaver_sptr.pc_nproduced_avg(atsc_deinterleaver_sptr self) → float

atsc_deinterleaver_sptr.pc_output_buffers_full_avg(atsc_deinterleaver_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_deinterleaver_sptr self) -> pmt_vector_float

atsc_deinterleaver_sptr.pc_work_time_avg(atsc_deinterleaver_sptr self) → float

atsc_deinterleaver_sptr.pc_work_time_total(atsc_deinterleaver_sptr self) → float

atsc_deinterleaver_sptr.reset(atsc_deinterleaver_sptr self)

atsc_deinterleaver_sptr.sample_delay(atsc_deinterleaver_sptr self, int which) → unsigned int

atsc_deinterleaver_sptr.set_min_noutput_items(atsc_deinterleaver_sptr self, int m)

atsc_deinterleaver_sptr.set_thread_priority(atsc_deinterleaver_sptr self, int priority) → int

atsc_deinterleaver_sptr.thread_priority(atsc_deinterleaver_sptr self) → int

gnuradio.atsc.depad() → atsc_depad_sptr

depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte char

input: atsc_mpeg_packet; output: unsigned char

atsc_depad_sptr.active_thread_priority(atsc_depad_sptr self) → int

atsc_depad_sptr.declare_sample_delay(atsc_depad_sptr self, int which, int delay)

declare_sample_delay(atsc_depad_sptr self, unsigned int delay)

atsc_depad_sptr.message_subscribers(atsc_depad_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_depad_sptr.min_noutput_items(atsc_depad_sptr self) → int

atsc_depad_sptr.pc_input_buffers_full_avg(atsc_depad_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_depad_sptr self) -> pmt_vector_float

atsc_depad_sptr.pc_noutput_items_avg(atsc_depad_sptr self) → float

atsc_depad_sptr.pc_nproduced_avg(atsc_depad_sptr self) → float

atsc_depad_sptr.pc_output_buffers_full_avg(atsc_depad_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_depad_sptr self) -> pmt_vector_float

atsc_depad_sptr.pc_work_time_avg(atsc_depad_sptr self) → float

atsc_depad_sptr.pc_work_time_total(atsc_depad_sptr self) → float

atsc_depad_sptr.reset(atsc_depad_sptr self)

atsc_depad_sptr.sample_delay(atsc_depad_sptr self, int which) → unsigned int

atsc_depad_sptr.set_min_noutput_items(atsc_depad_sptr self, int m)

atsc_depad_sptr.set_thread_priority(atsc_depad_sptr self, int priority) → int

atsc_depad_sptr.thread_priority(atsc_depad_sptr self) → int

gnuradio.atsc.derandomizer() → atsc_derandomizer_sptr

“dewhiten” incoming mpeg transport stream packets

input: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet;

atsc_derandomizer_sptr.active_thread_priority(atsc_derandomizer_sptr self) → int

atsc_derandomizer_sptr.declare_sample_delay(atsc_derandomizer_sptr self, int which, int delay)

declare_sample_delay(atsc_derandomizer_sptr self, unsigned int delay)

atsc_derandomizer_sptr.message_subscribers(atsc_derandomizer_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_derandomizer_sptr.min_noutput_items(atsc_derandomizer_sptr self) → int

atsc_derandomizer_sptr.pc_input_buffers_full_avg(atsc_derandomizer_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_derandomizer_sptr self) -> pmt_vector_float

atsc_derandomizer_sptr.pc_noutput_items_avg(atsc_derandomizer_sptr self) → float

atsc_derandomizer_sptr.pc_nproduced_avg(atsc_derandomizer_sptr self) → float

atsc_derandomizer_sptr.pc_output_buffers_full_avg(atsc_derandomizer_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_derandomizer_sptr self) -> pmt_vector_float

atsc_derandomizer_sptr.pc_work_time_avg(atsc_derandomizer_sptr self) → float

atsc_derandomizer_sptr.pc_work_time_total(atsc_derandomizer_sptr self) → float

atsc_derandomizer_sptr.reset(atsc_derandomizer_sptr self)

atsc_derandomizer_sptr.sample_delay(atsc_derandomizer_sptr self, int which) → unsigned int

atsc_derandomizer_sptr.set_min_noutput_items(atsc_derandomizer_sptr self, int m)

atsc_derandomizer_sptr.set_thread_priority(atsc_derandomizer_sptr self, int priority) → int

atsc_derandomizer_sptr.thread_priority(atsc_derandomizer_sptr self) → int

gnuradio.atsc.ds_to_softds() → atsc_ds_to_softds_sptr

Debug glue routine (atsc_data_segment > atsc_soft_data_segment)

input: atsc_data_segment; output: atsc_soft_data_segment.

atsc_ds_to_softds_sptr.active_thread_priority(atsc_ds_to_softds_sptr self) → int

atsc_ds_to_softds_sptr.declare_sample_delay(atsc_ds_to_softds_sptr self, int which, int delay)

declare_sample_delay(atsc_ds_to_softds_sptr self, unsigned int delay)

atsc_ds_to_softds_sptr.message_subscribers(atsc_ds_to_softds_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_ds_to_softds_sptr.min_noutput_items(atsc_ds_to_softds_sptr self) → int

atsc_ds_to_softds_sptr.pc_input_buffers_full_avg(atsc_ds_to_softds_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_ds_to_softds_sptr self) -> pmt_vector_float

atsc_ds_to_softds_sptr.pc_noutput_items_avg(atsc_ds_to_softds_sptr self) → float

atsc_ds_to_softds_sptr.pc_nproduced_avg(atsc_ds_to_softds_sptr self) → float

atsc_ds_to_softds_sptr.pc_output_buffers_full_avg(atsc_ds_to_softds_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_ds_to_softds_sptr self) -> pmt_vector_float

atsc_ds_to_softds_sptr.pc_work_time_avg(atsc_ds_to_softds_sptr self) → float

atsc_ds_to_softds_sptr.pc_work_time_total(atsc_ds_to_softds_sptr self) → float

atsc_ds_to_softds_sptr.reset(atsc_ds_to_softds_sptr self)

atsc_ds_to_softds_sptr.sample_delay(atsc_ds_to_softds_sptr self, int which) → unsigned int

atsc_ds_to_softds_sptr.set_min_noutput_items(atsc_ds_to_softds_sptr self, int m)

atsc_ds_to_softds_sptr.set_thread_priority(atsc_ds_to_softds_sptr self, int priority) → int

atsc_ds_to_softds_sptr.thread_priority(atsc_ds_to_softds_sptr self) → int

gnuradio.atsc.equalizer() → atsc_equalizer_sptr

ATSC equalizer (float,syminfo > float,syminfo)

first inputs are data samples, second inputs are tags. first outputs are equalized data samples, second outputs are tags.

atsc_equalizer_sptr.active_thread_priority(atsc_equalizer_sptr self) → int

atsc_equalizer_sptr.declare_sample_delay(atsc_equalizer_sptr self, int which, int delay)

declare_sample_delay(atsc_equalizer_sptr self, unsigned int delay)

atsc_equalizer_sptr.message_subscribers(atsc_equalizer_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_equalizer_sptr.min_noutput_items(atsc_equalizer_sptr self) → int

atsc_equalizer_sptr.pc_input_buffers_full_avg(atsc_equalizer_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_equalizer_sptr self) -> pmt_vector_float

atsc_equalizer_sptr.pc_noutput_items_avg(atsc_equalizer_sptr self) → float

atsc_equalizer_sptr.pc_nproduced_avg(atsc_equalizer_sptr self) → float

atsc_equalizer_sptr.pc_output_buffers_full_avg(atsc_equalizer_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_equalizer_sptr self) -> pmt_vector_float

atsc_equalizer_sptr.pc_work_time_avg(atsc_equalizer_sptr self) → float

atsc_equalizer_sptr.pc_work_time_total(atsc_equalizer_sptr self) → float

atsc_equalizer_sptr.reset(atsc_equalizer_sptr self)

atsc_equalizer_sptr.sample_delay(atsc_equalizer_sptr self, int which) → unsigned int

atsc_equalizer_sptr.set_min_noutput_items(atsc_equalizer_sptr self, int m)

atsc_equalizer_sptr.set_thread_priority(atsc_equalizer_sptr self, int priority) → int

atsc_equalizer_sptr.taps(atsc_equalizer_sptr self) → pmt_vector_double

atsc_equalizer_sptr.thread_priority(atsc_equalizer_sptr self) → int

gnuradio.atsc.field_sync_demux() → atsc_field_sync_demux_sptr

ATSC Field Sync Demux.

This class accepts 1 stream of floats (data), and 1 stream of tags (syminfo). * It outputs one stream of atsc_soft_data_segment packets

atsc_field_sync_demux_sptr.active_thread_priority(atsc_field_sync_demux_sptr self) → int

atsc_field_sync_demux_sptr.declare_sample_delay(atsc_field_sync_demux_sptr self, int which, int delay)

declare_sample_delay(atsc_field_sync_demux_sptr self, unsigned int delay)

atsc_field_sync_demux_sptr.message_subscribers(atsc_field_sync_demux_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_field_sync_demux_sptr.min_noutput_items(atsc_field_sync_demux_sptr self) → int

atsc_field_sync_demux_sptr.pc_input_buffers_full_avg(atsc_field_sync_demux_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_field_sync_demux_sptr self) -> pmt_vector_float

atsc_field_sync_demux_sptr.pc_noutput_items_avg(atsc_field_sync_demux_sptr self) → float

atsc_field_sync_demux_sptr.pc_nproduced_avg(atsc_field_sync_demux_sptr self) → float

atsc_field_sync_demux_sptr.pc_output_buffers_full_avg(atsc_field_sync_demux_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_field_sync_demux_sptr self) -> pmt_vector_float

atsc_field_sync_demux_sptr.pc_work_time_avg(atsc_field_sync_demux_sptr self) → float

atsc_field_sync_demux_sptr.pc_work_time_total(atsc_field_sync_demux_sptr self) → float

atsc_field_sync_demux_sptr.reset(atsc_field_sync_demux_sptr self)

atsc_field_sync_demux_sptr.sample_delay(atsc_field_sync_demux_sptr self, int which) → unsigned int

atsc_field_sync_demux_sptr.set_min_noutput_items(atsc_field_sync_demux_sptr self, int m)

atsc_field_sync_demux_sptr.set_thread_priority(atsc_field_sync_demux_sptr self, int priority) → int

atsc_field_sync_demux_sptr.thread_priority(atsc_field_sync_demux_sptr self) → int

gnuradio.atsc.field_sync_mux() → atsc_field_sync_mux_sptr

Insert ATSC Field Syncs as required (atsc_data_segment > atsc_data_segment)

input: atsc_data_segment; output: atsc_data_segment.

atsc_field_sync_mux_sptr.active_thread_priority(atsc_field_sync_mux_sptr self) → int

atsc_field_sync_mux_sptr.declare_sample_delay(atsc_field_sync_mux_sptr self, int which, int delay)

declare_sample_delay(atsc_field_sync_mux_sptr self, unsigned int delay)

atsc_field_sync_mux_sptr.message_subscribers(atsc_field_sync_mux_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_field_sync_mux_sptr.min_noutput_items(atsc_field_sync_mux_sptr self) → int

atsc_field_sync_mux_sptr.pc_input_buffers_full_avg(atsc_field_sync_mux_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_field_sync_mux_sptr self) -> pmt_vector_float

atsc_field_sync_mux_sptr.pc_noutput_items_avg(atsc_field_sync_mux_sptr self) → float

atsc_field_sync_mux_sptr.pc_nproduced_avg(atsc_field_sync_mux_sptr self) → float

atsc_field_sync_mux_sptr.pc_output_buffers_full_avg(atsc_field_sync_mux_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_field_sync_mux_sptr self) -> pmt_vector_float

atsc_field_sync_mux_sptr.pc_work_time_avg(atsc_field_sync_mux_sptr self) → float

atsc_field_sync_mux_sptr.pc_work_time_total(atsc_field_sync_mux_sptr self) → float

atsc_field_sync_mux_sptr.reset(atsc_field_sync_mux_sptr self)

atsc_field_sync_mux_sptr.sample_delay(atsc_field_sync_mux_sptr self, int which) → unsigned int

atsc_field_sync_mux_sptr.set_min_noutput_items(atsc_field_sync_mux_sptr self, int m)

atsc_field_sync_mux_sptr.set_thread_priority(atsc_field_sync_mux_sptr self, int priority) → int

atsc_field_sync_mux_sptr.thread_priority(atsc_field_sync_mux_sptr self) → int

gnuradio.atsc.fpll() → atsc_fpll_sptr

ATSC FPLL (2nd Version)

A/D > GrFIRfilterFFF -> GrAtscFPLL ->

We use GrFIRfilterFFF to bandpass filter the signal of interest.

This class accepts a single real input and produces a single real output

atsc_fpll_sptr.active_thread_priority(atsc_fpll_sptr self) → int

atsc_fpll_sptr.declare_sample_delay(atsc_fpll_sptr self, int which, int delay)

declare_sample_delay(atsc_fpll_sptr self, unsigned int delay)

atsc_fpll_sptr.message_subscribers(atsc_fpll_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_fpll_sptr.min_noutput_items(atsc_fpll_sptr self) → int

atsc_fpll_sptr.pc_input_buffers_full_avg(atsc_fpll_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_fpll_sptr self) -> pmt_vector_float

atsc_fpll_sptr.pc_noutput_items_avg(atsc_fpll_sptr self) → float

atsc_fpll_sptr.pc_nproduced_avg(atsc_fpll_sptr self) → float

atsc_fpll_sptr.pc_output_buffers_full_avg(atsc_fpll_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_fpll_sptr self) -> pmt_vector_float

atsc_fpll_sptr.pc_work_time_avg(atsc_fpll_sptr self) → float

atsc_fpll_sptr.pc_work_time_total(atsc_fpll_sptr self) → float

atsc_fpll_sptr.reset(atsc_fpll_sptr self)

atsc_fpll_sptr.sample_delay(atsc_fpll_sptr self, int which) → unsigned int

atsc_fpll_sptr.set_min_noutput_items(atsc_fpll_sptr self, int m)

atsc_fpll_sptr.set_thread_priority(atsc_fpll_sptr self, int priority) → int

atsc_fpll_sptr.thread_priority(atsc_fpll_sptr self) → int

gnuradio.atsc.fs_checker() → atsc_fs_checker_sptr

ATSC field sync checker (float,syminfo > float,syminfo)

first output is delayed version of input. second output is set of tags, one-for-one with first output.

atsc_fs_checker_sptr.active_thread_priority(atsc_fs_checker_sptr self) → int

atsc_fs_checker_sptr.declare_sample_delay(atsc_fs_checker_sptr self, int which, int delay)

declare_sample_delay(atsc_fs_checker_sptr self, unsigned int delay)

atsc_fs_checker_sptr.message_subscribers(atsc_fs_checker_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_fs_checker_sptr.min_noutput_items(atsc_fs_checker_sptr self) → int

atsc_fs_checker_sptr.pc_input_buffers_full_avg(atsc_fs_checker_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_fs_checker_sptr self) -> pmt_vector_float

atsc_fs_checker_sptr.pc_noutput_items_avg(atsc_fs_checker_sptr self) → float

atsc_fs_checker_sptr.pc_nproduced_avg(atsc_fs_checker_sptr self) → float

atsc_fs_checker_sptr.pc_output_buffers_full_avg(atsc_fs_checker_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_fs_checker_sptr self) -> pmt_vector_float

atsc_fs_checker_sptr.pc_work_time_avg(atsc_fs_checker_sptr self) → float

atsc_fs_checker_sptr.pc_work_time_total(atsc_fs_checker_sptr self) → float

atsc_fs_checker_sptr.reset(atsc_fs_checker_sptr self)

atsc_fs_checker_sptr.sample_delay(atsc_fs_checker_sptr self, int which) → unsigned int

atsc_fs_checker_sptr.set_min_noutput_items(atsc_fs_checker_sptr self, int m)

atsc_fs_checker_sptr.set_thread_priority(atsc_fs_checker_sptr self, int priority) → int

atsc_fs_checker_sptr.thread_priority(atsc_fs_checker_sptr self) → int

gnuradio.atsc.interleaver() → atsc_interleaver_sptr

Interleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded > atsc_mpeg_packet_rs_encoded)*

input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_rs_encoded.

atsc_interleaver_sptr.active_thread_priority(atsc_interleaver_sptr self) → int

atsc_interleaver_sptr.declare_sample_delay(atsc_interleaver_sptr self, int which, int delay)

declare_sample_delay(atsc_interleaver_sptr self, unsigned int delay)

atsc_interleaver_sptr.message_subscribers(atsc_interleaver_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_interleaver_sptr.min_noutput_items(atsc_interleaver_sptr self) → int

atsc_interleaver_sptr.pc_input_buffers_full_avg(atsc_interleaver_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_interleaver_sptr self) -> pmt_vector_float

atsc_interleaver_sptr.pc_noutput_items_avg(atsc_interleaver_sptr self) → float

atsc_interleaver_sptr.pc_nproduced_avg(atsc_interleaver_sptr self) → float

atsc_interleaver_sptr.pc_output_buffers_full_avg(atsc_interleaver_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_interleaver_sptr self) -> pmt_vector_float

atsc_interleaver_sptr.pc_work_time_avg(atsc_interleaver_sptr self) → float

atsc_interleaver_sptr.pc_work_time_total(atsc_interleaver_sptr self) → float

atsc_interleaver_sptr.reset(atsc_interleaver_sptr self)

atsc_interleaver_sptr.sample_delay(atsc_interleaver_sptr self, int which) → unsigned int

atsc_interleaver_sptr.set_min_noutput_items(atsc_interleaver_sptr self, int m)

atsc_interleaver_sptr.set_thread_priority(atsc_interleaver_sptr self, int priority) → int

atsc_interleaver_sptr.thread_priority(atsc_interleaver_sptr self) → int

gnuradio.atsc.pad() → atsc_pad_sptr

pad mpeg ts packets from 188 byte char to to 256 byte atsc_mpeg_packet

input: unsigned char; output: atsc_mpeg_packet

atsc_pad_sptr.active_thread_priority(atsc_pad_sptr self) → int

atsc_pad_sptr.declare_sample_delay(atsc_pad_sptr self, int which, int delay)

declare_sample_delay(atsc_pad_sptr self, unsigned int delay)

atsc_pad_sptr.message_subscribers(atsc_pad_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_pad_sptr.min_noutput_items(atsc_pad_sptr self) → int

atsc_pad_sptr.pc_input_buffers_full_avg(atsc_pad_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_pad_sptr self) -> pmt_vector_float

atsc_pad_sptr.pc_noutput_items_avg(atsc_pad_sptr self) → float

atsc_pad_sptr.pc_nproduced_avg(atsc_pad_sptr self) → float

atsc_pad_sptr.pc_output_buffers_full_avg(atsc_pad_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_pad_sptr self) -> pmt_vector_float

atsc_pad_sptr.pc_work_time_avg(atsc_pad_sptr self) → float

atsc_pad_sptr.pc_work_time_total(atsc_pad_sptr self) → float

atsc_pad_sptr.reset(atsc_pad_sptr self)

atsc_pad_sptr.sample_delay(atsc_pad_sptr self, int which) → unsigned int

atsc_pad_sptr.set_min_noutput_items(atsc_pad_sptr self, int m)

atsc_pad_sptr.set_thread_priority(atsc_pad_sptr self, int priority) → int

atsc_pad_sptr.thread_priority(atsc_pad_sptr self) → int

gnuradio.atsc.randomizer() → atsc_randomizer_sptr

“Whiten” incoming mpeg transport stream packets

input: atsc_mpeg_packet; output: atsc_mpeg_packet_no_sync

atsc_randomizer_sptr.active_thread_priority(atsc_randomizer_sptr self) → int

atsc_randomizer_sptr.declare_sample_delay(atsc_randomizer_sptr self, int which, int delay)

declare_sample_delay(atsc_randomizer_sptr self, unsigned int delay)

atsc_randomizer_sptr.message_subscribers(atsc_randomizer_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_randomizer_sptr.min_noutput_items(atsc_randomizer_sptr self) → int

atsc_randomizer_sptr.pc_input_buffers_full_avg(atsc_randomizer_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_randomizer_sptr self) -> pmt_vector_float

atsc_randomizer_sptr.pc_noutput_items_avg(atsc_randomizer_sptr self) → float

atsc_randomizer_sptr.pc_nproduced_avg(atsc_randomizer_sptr self) → float

atsc_randomizer_sptr.pc_output_buffers_full_avg(atsc_randomizer_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_randomizer_sptr self) -> pmt_vector_float

atsc_randomizer_sptr.pc_work_time_avg(atsc_randomizer_sptr self) → float

atsc_randomizer_sptr.pc_work_time_total(atsc_randomizer_sptr self) → float

atsc_randomizer_sptr.reset(atsc_randomizer_sptr self)

atsc_randomizer_sptr.sample_delay(atsc_randomizer_sptr self, int which) → unsigned int

atsc_randomizer_sptr.set_min_noutput_items(atsc_randomizer_sptr self, int m)

atsc_randomizer_sptr.set_thread_priority(atsc_randomizer_sptr self, int priority) → int

atsc_randomizer_sptr.thread_priority(atsc_randomizer_sptr self) → int

gnuradio.atsc.rs_decoder() → atsc_rs_decoder_sptr

Reed-Solomon decoder for ATSC

input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_no_sync.

atsc_rs_decoder_sptr.active_thread_priority(atsc_rs_decoder_sptr self) → int

atsc_rs_decoder_sptr.declare_sample_delay(atsc_rs_decoder_sptr self, int which, int delay)

declare_sample_delay(atsc_rs_decoder_sptr self, unsigned int delay)

atsc_rs_decoder_sptr.message_subscribers(atsc_rs_decoder_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_rs_decoder_sptr.min_noutput_items(atsc_rs_decoder_sptr self) → int

atsc_rs_decoder_sptr.pc_input_buffers_full_avg(atsc_rs_decoder_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_rs_decoder_sptr self) -> pmt_vector_float

atsc_rs_decoder_sptr.pc_noutput_items_avg(atsc_rs_decoder_sptr self) → float

atsc_rs_decoder_sptr.pc_nproduced_avg(atsc_rs_decoder_sptr self) → float

atsc_rs_decoder_sptr.pc_output_buffers_full_avg(atsc_rs_decoder_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_rs_decoder_sptr self) -> pmt_vector_float

atsc_rs_decoder_sptr.pc_work_time_avg(atsc_rs_decoder_sptr self) → float

atsc_rs_decoder_sptr.pc_work_time_total(atsc_rs_decoder_sptr self) → float

atsc_rs_decoder_sptr.reset(atsc_rs_decoder_sptr self)

atsc_rs_decoder_sptr.sample_delay(atsc_rs_decoder_sptr self, int which) → unsigned int

atsc_rs_decoder_sptr.set_min_noutput_items(atsc_rs_decoder_sptr self, int m)

atsc_rs_decoder_sptr.set_thread_priority(atsc_rs_decoder_sptr self, int priority) → int

atsc_rs_decoder_sptr.thread_priority(atsc_rs_decoder_sptr self) → int

gnuradio.atsc.rs_encoder() → atsc_rs_encoder_sptr

Reed-Solomon encoder for ATSC

input: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet_rs_encoded.

atsc_rs_encoder_sptr.active_thread_priority(atsc_rs_encoder_sptr self) → int

atsc_rs_encoder_sptr.declare_sample_delay(atsc_rs_encoder_sptr self, int which, int delay)

declare_sample_delay(atsc_rs_encoder_sptr self, unsigned int delay)

atsc_rs_encoder_sptr.message_subscribers(atsc_rs_encoder_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_rs_encoder_sptr.min_noutput_items(atsc_rs_encoder_sptr self) → int

atsc_rs_encoder_sptr.pc_input_buffers_full_avg(atsc_rs_encoder_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_rs_encoder_sptr self) -> pmt_vector_float

atsc_rs_encoder_sptr.pc_noutput_items_avg(atsc_rs_encoder_sptr self) → float

atsc_rs_encoder_sptr.pc_nproduced_avg(atsc_rs_encoder_sptr self) → float

atsc_rs_encoder_sptr.pc_output_buffers_full_avg(atsc_rs_encoder_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_rs_encoder_sptr self) -> pmt_vector_float

atsc_rs_encoder_sptr.pc_work_time_avg(atsc_rs_encoder_sptr self) → float

atsc_rs_encoder_sptr.pc_work_time_total(atsc_rs_encoder_sptr self) → float

atsc_rs_encoder_sptr.reset(atsc_rs_encoder_sptr self)

atsc_rs_encoder_sptr.sample_delay(atsc_rs_encoder_sptr self, int which) → unsigned int

atsc_rs_encoder_sptr.set_min_noutput_items(atsc_rs_encoder_sptr self, int m)

atsc_rs_encoder_sptr.set_thread_priority(atsc_rs_encoder_sptr self, int priority) → int

atsc_rs_encoder_sptr.thread_priority(atsc_rs_encoder_sptr self) → int

gnuradio.atsc.trellis_encoder() → atsc_trellis_encoder_sptr

ATSC 12-way interleaved trellis encoder (atsc_mpeg_packet_rs_encoded > atsc_data_segment)

input: atsc_mpeg_packet_rs_encoded; output: atsc_data_segment.

atsc_trellis_encoder_sptr.active_thread_priority(atsc_trellis_encoder_sptr self) → int

atsc_trellis_encoder_sptr.declare_sample_delay(atsc_trellis_encoder_sptr self, int which, int delay)

declare_sample_delay(atsc_trellis_encoder_sptr self, unsigned int delay)

atsc_trellis_encoder_sptr.message_subscribers(atsc_trellis_encoder_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_trellis_encoder_sptr.min_noutput_items(atsc_trellis_encoder_sptr self) → int

atsc_trellis_encoder_sptr.pc_input_buffers_full_avg(atsc_trellis_encoder_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_trellis_encoder_sptr self) -> pmt_vector_float

atsc_trellis_encoder_sptr.pc_noutput_items_avg(atsc_trellis_encoder_sptr self) → float

atsc_trellis_encoder_sptr.pc_nproduced_avg(atsc_trellis_encoder_sptr self) → float

atsc_trellis_encoder_sptr.pc_output_buffers_full_avg(atsc_trellis_encoder_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_trellis_encoder_sptr self) -> pmt_vector_float

atsc_trellis_encoder_sptr.pc_work_time_avg(atsc_trellis_encoder_sptr self) → float

atsc_trellis_encoder_sptr.pc_work_time_total(atsc_trellis_encoder_sptr self) → float

atsc_trellis_encoder_sptr.reset(atsc_trellis_encoder_sptr self)

atsc_trellis_encoder_sptr.sample_delay(atsc_trellis_encoder_sptr self, int which) → unsigned int

atsc_trellis_encoder_sptr.set_min_noutput_items(atsc_trellis_encoder_sptr self, int m)

atsc_trellis_encoder_sptr.set_thread_priority(atsc_trellis_encoder_sptr self, int priority) → int

atsc_trellis_encoder_sptr.thread_priority(atsc_trellis_encoder_sptr self) → int

gnuradio.atsc.viterbi_decoder() → atsc_viterbi_decoder_sptr

ATSC 12-way interleaved viterbi decoder (atsc_soft_data_segment > atsc_mpeg_packet_rs_encoded)

input: atsc_soft_data_segment; output: atsc_mpeg_packet_rs_encoded.

atsc_viterbi_decoder_sptr.active_thread_priority(atsc_viterbi_decoder_sptr self) → int

atsc_viterbi_decoder_sptr.declare_sample_delay(atsc_viterbi_decoder_sptr self, int which, int delay)

declare_sample_delay(atsc_viterbi_decoder_sptr self, unsigned int delay)

atsc_viterbi_decoder_sptr.message_subscribers(atsc_viterbi_decoder_sptr self, swig_int_ptr which_port) → swig_int_ptr

atsc_viterbi_decoder_sptr.min_noutput_items(atsc_viterbi_decoder_sptr self) → int

atsc_viterbi_decoder_sptr.pc_input_buffers_full_avg(atsc_viterbi_decoder_sptr self, int which) → float

pc_input_buffers_full_avg(atsc_viterbi_decoder_sptr self) -> pmt_vector_float

atsc_viterbi_decoder_sptr.pc_noutput_items_avg(atsc_viterbi_decoder_sptr self) → float

atsc_viterbi_decoder_sptr.pc_nproduced_avg(atsc_viterbi_decoder_sptr self) → float

atsc_viterbi_decoder_sptr.pc_output_buffers_full_avg(atsc_viterbi_decoder_sptr self, int which) → float

pc_output_buffers_full_avg(atsc_viterbi_decoder_sptr self) -> pmt_vector_float

atsc_viterbi_decoder_sptr.pc_work_time_avg(atsc_viterbi_decoder_sptr self) → float

atsc_viterbi_decoder_sptr.pc_work_time_total(atsc_viterbi_decoder_sptr self) → float

atsc_viterbi_decoder_sptr.reset(atsc_viterbi_decoder_sptr self)

atsc_viterbi_decoder_sptr.sample_delay(atsc_viterbi_decoder_sptr self, int which) → unsigned int

atsc_viterbi_decoder_sptr.set_min_noutput_items(atsc_viterbi_decoder_sptr self, int m)

atsc_viterbi_decoder_sptr.set_thread_priority(atsc_viterbi_decoder_sptr self, int priority) → int

atsc_viterbi_decoder_sptr.thread_priority(atsc_viterbi_decoder_sptr self) → int