Cgr::analog::kernel::agc2_cc | High performance Automatic Gain Control class |
Cgr::analog::kernel::agc2_ff | |
Cgr::analog::kernel::agc_cc | High performance Automatic Gain Control class for complex signals |
Cgr::analog::kernel::agc_ff | High performance Automatic Gain Control class for float signals |
Calist | |
Cgr::uhd::amsg_source | |
Catsc_data_segment | 832 3 bit symbols. The low 3 bits in the byte hold the symbol |
Catsc_mpeg_packet | |
Catsc_mpeg_packet_no_sync | |
Catsc_mpeg_packet_rs_encoded | |
Catsc_soft_data_segment | |
Catsci_basic_trellis_encoder | ATSC trellis encoder building block |
►Catsci_equalizer | Abstract base class for ATSC equalizer |
Catsci_equalizer_lms | |
Catsci_equalizer_lms2 | |
Catsci_equalizer_nop | |
Catsci_fake_single_viterbi | Single channel viterbi decoder |
►Catsci_fs_checker | Abstract base class for ATSC field sync checker |
Catsci_fs_checker_naive | Naive concrete implementation of field sync checker |
►Catsci_fs_correlator | Abstract base class for ATSC field sync correlator |
Catsci_fs_correlator_naive | Naive concrete implementation of field sync correlator |
Catsci_interpolator | Interpolator control for segment and symbol sync recovery |
Catsci_randomizer | ATSC data "whitener" |
Catsci_reed_solomon | ATSC Reed-Solomon encoder / decoder |
Catsci_single_viterbi | Single channel viterbi decoder |
Catsci_slicer_agc | Automatic Gain Control class for atsc slicer |
Catsci_sliding_correlator | Look for the PN 511 field sync pattern |
Catsci_sssr | ATSC Segment and Symbol Sync Recovery |
Catsci_trellis_encoder | Fancy, schmancy 12-way interleaved trellis encoder for ATSC |
Catsci_viterbi_decoder | Fancy, schmancy 12-way interleaved viterbi decoder for ATSC |
Cawgn_bp | |
Cgr::block_detail | Implementation details to support the signal processing abstractionThis class contains implementation detail that should be "out of
sight" of almost all users of GNU Radio. This decoupling also means that we can make changes to the guts without having to recompile everything |
Cgr::block_gw_message_type | |
Cgr::block_registry | |
Cgr::buffer | Single writer, multiple reader fifo |
Cgr::buffer_reader | How we keep track of the readers of a gr::buffer |
►Ccallbackregister_base::callback_base_t | |
Ccallbackregister_base::callback_t< T, Tsptr > | |
►Ccallbackregister_base | |
►Crpcserver_base | |
Crpcserver_aggregator | |
Crpcserver_thrift | |
Ccldpc | |
Cgr::vocoder::codec2 | |
Cpmt::comparator | Provide a comparator function object to allow pmt use in stl types |
Cpmt::comperator | |
►Cgr::blocks::control_loop | A second-order control loop implementation class |
Cgr::analog::pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier |
Cgr::analog::pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod |
Cgr::analog::pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrier |
Cgr::digital::costas_loop_cc | A Costas loop carrier recovery module |
Cgr::digital::fll_band_edge_cc | Frequency Lock Loop using band-edge filters |
Cgr::digital::mpsk_receiver_cc | This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization |
►CControlPortIf | |
Crpcserver_thrift | |
Cconvolutional_interleaver< symbol_type > | Template class for generic convolutional interleaver |
►Cconvolutional_interleaver< unsigned char > | |
Catsci_data_deinterleaver | Atsc convolutional data deinterleaver |
Catsci_data_interleaver | Atsc convolutional data interleaver |
Cgr::analog::cpm | Return the taps for an interpolating FIR filter (gr::filter::interp_fir_filter_fff) |
Cdecision_t | |
Csssr::digital_correlator | Digital correlator for 1001 and 0110 patterns |
Cgr::edge | Class representing a connection between to graph endpoints |
►Cenable_shared_from_this | |
►Cgr::basic_block | The abstract base class for all signal processing blocks.Basic blocks are the bare abstraction of an entity that has a name, a set of inputs and outputs, and a message queue. These are never instantiated directly; rather, this is the abstract parent class of both gr_hier_block, which is a recursive container, and block, which implements actual signal processing functions |
►Cgr::block | The abstract base class for all 'terminal' processing blocks.A signal processing flow is constructed by creating a tree of hierarchical blocks, which at any level may also contain terminal nodes that actually implement signal processing functions. This is the base class for all such leaf nodes |
Catsc_bit_timing_loop | ATSC BitTimingLoop3This class accepts a single real input and produces two outputs, the raw symbol (float) and the tag (atsc_syminfo) |
Catsc_field_sync_demux | ATSC Field Sync Demux |
Catsc_field_sync_mux | Insert ATSC Field Syncs as required (atsc_data_segment –> atsc_data_segment)input: atsc_data_segment; output: atsc_data_segment |
Cgr::analog::ctcss_squelch_ff | Gate or zero output if CTCSS tone not present |
Cgr::analog::pwr_squelch_cc | Gate or zero output when input power below threshold |
Cgr::analog::pwr_squelch_ff | Gate or zero output when input power below threshold |
►Cgr::analog::squelch_base_cc | Basic squelch block; to be subclassed for other squelches |
Cgr::analog::pwr_squelch_cc | Gate or zero output when input power below threshold |
►Cgr::analog::squelch_base_ff | Basic squelch block; to be subclassed for other squelches |
Cgr::analog::ctcss_squelch_ff | Gate or zero output if CTCSS tone not present |
Cgr::analog::pwr_squelch_ff | Gate or zero output when input power below threshold |
Cgr::block_gateway | |
Cgr::blocks::copy | Output[i] = input[i] |
Cgr::blocks::deinterleave | Deinterleave an input block of samples into N outputs |
Cgr::blocks::delay | Delay the input by a certain number of samplesPositive delays insert zero items at the beginning of the stream. Negative delays discard items from the stream |
Cgr::blocks::interleave | Interleave N inputs into a single output |
Cgr::blocks::keep_m_in_n | Decimate a stream, keeping m items out of every n |
Cgr::blocks::keep_one_in_n | Decimate a stream, keeping one item out of every n |
Cgr::blocks::message_debug | Debug block for the message passing system |
Cgr::blocks::message_strobe | Send message at defined interval |
Cgr::blocks::message_strobe_random | Send message at defined interval |
Cgr::blocks::nop | Does nothing. Used for testing only |
Cgr::blocks::packed_to_unpacked_bb | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
Cgr::blocks::packed_to_unpacked_ii | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
Cgr::blocks::packed_to_unpacked_ss | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
Cgr::blocks::patterned_interleaver | Interleave items based on the provided vector pattern |
Cgr::blocks::pdu_filter | Propagates only pdus containing k=>v in meta |
Cgr::blocks::pdu_remove | Remove key k in pdu's meta field and pass on |
Cgr::blocks::pdu_set | Set k=>v in pdu's meta field and pass on |
Cgr::blocks::plateau_detector_fb | Detects a plateau and marks the middle |
Cgr::blocks::random_pdu | Sends a random PDU at intervals |
Cgr::blocks::skiphead | Skips the first N items, from then on copies items to the output |
Cgr::blocks::socket_pdu | Creates socket interface and translates traffic to PDUs |
Cgr::blocks::stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
Cgr::blocks::tagged_stream_align | Align a stream to a tagged stream item |
Cgr::blocks::tagged_stream_multiply_length | Allows scaling of a tagged stream length tag |
Cgr::blocks::tuntap_pdu | Creates TUNTAP interface and translates traffic to PDUs |
Cgr::blocks::unpacked_to_packed_bb | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
Cgr::blocks::unpacked_to_packed_ii | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
Cgr::blocks::unpacked_to_packed_ss | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
Cgr::blocks::vector_insert_b | Source of unsigned char's that gets its data from a vector |
Cgr::blocks::vector_insert_c | Source of gr_complex's that gets its data from a vector |
Cgr::blocks::vector_insert_f | Source of float's that gets its data from a vector |
Cgr::blocks::vector_insert_i | Source of int's that gets its data from a vector |
Cgr::blocks::vector_insert_s | Source of short's that gets its data from a vector |
Cgr::channels::sro_model | Sample Rate Offset Model |
Cgr::digital::clock_recovery_mm_cc | Mueller and Müller (M&M) based clock recovery block with complex input, complex output |
Cgr::digital::clock_recovery_mm_ff | Mueller and Müller (M&M) based clock recovery block with float input, float output |
Cgr::digital::constellation_decoder_cb | Constellation Decoder |
Cgr::digital::constellation_receiver_cb | This block makes hard decisions about the received symbols (using a constellation object) and also fine tunes phase synchronization |
Cgr::digital::correlate_access_code_bb_ts | Examine input for specified access code, one bit at a time |
Cgr::digital::correlate_access_code_ff_ts | Examine input for specified access code, one bit at a time |
Cgr::digital::crc32_async_bb | Byte-stream CRC block for async messages |
Cgr::digital::header_payload_demux | Header/Payload demuxer |
Cgr::digital::mpsk_receiver_cc | This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization |
Cgr::digital::msk_timing_recovery_cc | MSK/GMSK timing recoveryThis block performs timing synchronization on CPM modulations using a fourth-order nonlinearity feedback method which is non-data-aided. The block does not require prior phase synchronization but is relatively sensitive to frequency offset (keep offset to 0.1x symbol rate) |
Cgr::digital::ofdm_chanest_vcvc | Estimate channel and coarse frequency offset for OFDM from preamblesInput: OFDM symbols (in frequency domain). The first one (or two) symbols are expected to be synchronisation symbols, which are used to estimate the coarse freq offset and the initial equalizer taps (these symbols are removed from the stream). The following n_data_symbols are passed through unmodified (the actual equalisation must be done elsewhere). Output: The data symbols, without the synchronisation symbols. The first data symbol passed through has two tags: 'ofdm_sync_carr_offset' (integer), the coarse frequency offset as number of carriers, and 'ofdm_sync_eq_taps' (complex vector). Any tags attached to the synchronisation symbols are attached to the first data symbol. All other tags are propagated as expected |
Cgr::digital::ofdm_frame_acquisition | Take a vector of complex constellation points in from an FFT and performs a correlation and equalization |
Cgr::digital::ofdm_insert_preamble | Insert "pre-modulated" preamble symbols before each payload |
Cgr::digital::ofdm_sampler | Does the rest of the OFDM stuff |
Cgr::digital::pfb_clock_sync_ccf | Timing synchronizer using polyphase filterbanks |
Cgr::digital::pfb_clock_sync_fff | Timing synchronizer using polyphase filterbanks |
Cgr::digital::simple_correlator | Inverse of simple_framer (more or less) |
Cgr::digital::simple_framer | Add sync field, seq number and command field to payload |
Cgr::dtv::atsc_equalizer | ATSC Receiver Equalizer |
Cgr::dtv::atsc_field_sync_mux | <+description of block+> |
Cgr::dtv::atsc_fs_checker | ATSC Receiver FS_CHECKER |
Cgr::dtv::atsc_sync | ATSC Receiver SYNC |
Cgr::dtv::dvb_bbheader_bb | Formats MPEG-2 Transport Stream packets into FEC baseband frames and adds a 10-byte header |
Cgr::dtv::dvb_bch_bb | Encodes a BCH ((Bose, Chaudhuri, Hocquenghem) FEC |
Cgr::dtv::dvb_ldpc_bb | Encodes a LDPC (Low-Density Parity-Check) FEC.Input: Variable length FEC baseband frames with appended BCH (BCHFEC). Output: Normal or short FEC baseband frames with appended LPDC (LDPCFEC) |
Cgr::dtv::dvbs2_interleaver_bb | Bit interleaves DVB-S2 FEC baseband frames.Input: Normal or short FEC baseband frames with appended LPDC (LDPCFEC). Output: Bit interleaved baseband frames |
Cgr::dtv::dvbs2_modulator_bc | Modulates DVB-S2 frames.Input: Bit interleaved baseband frames. Output: QPSK, 8PSK, 16APSK or 32APSK modulated complex IQ values (XFECFRAME) |
Cgr::dtv::dvbs2_physical_cc | Signals DVB-S2 physical layer frames.Input: QPSK, 8PSK, 16APSK or 32APSK modulated complex IQ values (XFECFRAME). Output: DVB-S2 PLFRAME |
Cgr::dtv::dvbt2_framemapper_cc | Maps T2 frames.Input: Cell and time interleaved QPSK, 16QAM, 64QAM or 256QAM modulated cells. Output: T2 frame |
Cgr::dtv::dvbt2_interleaver_bb | Bit interleaves DVB-T2 FEC baseband frames.Input: Normal or short FEC baseband frames with appended LPDC (LDPCFEC). Output: Bit interleaved (with column twist and bit to cell word de-multiplexed) cells |
Cgr::dtv::dvbt2_modulator_bc | Modulates DVB-T2 cells.Input: Bit interleaved (with column twist and bit to cell word de-multiplexing) cells. Output: QPSK, 16QAM, 64QAM or 256QAM modulated complex IQ values (cells) |
Cgr::dtv::dvbt2_p1insertion_cc | Inserts a P1 symbol.Input: OFDM T2 frame. Output: OFDM T2 frame with P1 symbol |
Cgr::dtv::dvbt2_pilotgenerator_cc | Adds pilots to T2 frames.Input: Frequency interleaved T2 frame. Output: T2 frame with pilots (in time domain) |
Cgr::dtv::dvbt_bit_inner_interleaver | Bit Inner interleaver.ETSI EN 300 744 Clause 4.3.4.1
Data Input format:
000000X0X1 - QPSK.
0000X0X1X2X3 - 16QAM.
00X0X1X2X3X4X5 - 64QAM.
Data Output format:
000000B0B1 - QPSK.
0000B0B1B2B3 - 16QAM.
00B0B1B2B3B4B5 - 64QAM.
bit interleaver block size is 126 |
Cgr::dtv::dvbt_energy_dispersal | Energy dispersal.ETSI EN 300 744 - Clause 4.3.1
Input - MPEG-2 transport packets (including sync - 0x47).
Output - Randomized MPEG-2 transport packets.
If first byte is not a SYNC then look for it.
First sync in a row of 8 packets is reversed - 0xB8.
Block size is 188 bytes |
Cgr::dtv::dvbt_inner_coder | Inner coder with Puncturing.ETSI EN 300 744 Clause 4.3.3
Mother convolutional code with rate 1/2.
k=1, n=2, K=6.
Generator polynomial G1=171(OCT), G2=133(OCT).
Punctured to obtain rates of 2/3, 3/4, 5/6, 7/8.
Data Input format: Packed bytes (each bit is data).
MSB - first, LSB last.
Data Output format:
000000X0X1 - QPSK.
0000X0X1X2X3 - 16QAM.
00X0X1X2X3X4X5 - 64QAM |
Cgr::dtv::dvbt_map | DVB-T mapper.ETSI EN 300 744 Clause 4.3.5.
Data input format:
000000Y0Y1 - QPSK.
0000Y0Y1Y2Y3 - 16QAM.
00Y0Y1Y2Y3Y4Y5 - 64QAM.
Data output format:
complex(real(float), imag(float)) |
Cgr::dtv::dvbt_reed_solomon_enc | Reed Solomon encoderETSI EN 300 744 Clause 4.3.2
RS(N=204,K=239,T=8) |
Cgr::dtv::dvbt_reference_signals | Reference signals generator.ETSI EN 300 744 Clause 4.5
Data input format:
complex(real(float), imag(float)).
Data output format:
complex(real(float), imag(float)) |
Cgr::dtv::dvbt_symbol_inner_interleaver | Symbol interleaver.ETSI EN 300 744 Clause 4.3.4.2
One block is 12 groups x 126 datawords = 1512 datawords |
Cgr::fec::async_decoder | Creates the decoder block for use in GNU Radio flowgraphs from a given FEC API object derived from the generic_decoder class |
Cgr::fec::async_encoder | Creates the encoder block for use in GNU Radio flowgraphs with async message from a given FEC API object derived from the generic_encoder class |
Cgr::fec::ber_bf | BER block in FECAPI |
Cgr::fec::conv_bit_corr_bb | Correlate block in FECAPI |
Cgr::fec::decoder | General FEC decoding block that takes in a decoder variable object (derived from gr::fec::general_decoder) for use in a flowgraph |
Cgr::fec::depuncture_bb | Depuncture a stream of samples |
Cgr::fec::encoder | Creates the encoder block for use in GNU Radio flowgraphs from a given FECAPI object derived from the generic_encoder class |
Cgr::fec::puncture_bb | Puncture a stream of unpacked bits |
Cgr::fec::puncture_ff | Puncture a stream of floats |
Cgr::filter::filterbank_vcvcf | Filterbank with vector of gr_complex input, vector of gr_complex output and float taps |
Cgr::filter::fractional_interpolator_cc | Interpolating MMSE filter with complex input, complex output |
Cgr::filter::fractional_interpolator_ff | Interpolating MMSE filter with float input, float output |
Cgr::filter::fractional_resampler_cc | Resampling MMSE filter with complex input, complex output |
Cgr::filter::fractional_resampler_ff | Resampling MMSE filter with float input, float output |
Cgr::filter::pfb_arb_resampler_ccc | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and gr_complex taps |
Cgr::filter::pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
Cgr::filter::pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
Cgr::filter::pfb_channelizer_ccf | Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps |
Cgr::noaa::hrpt_deframer | NOAA HRPT Deframer |
Cgr::pager::flex_sync | Flex sync description |
Cgr::qtgui::ber_sink_b | |
Cgr::qtgui::sink_c | A graphical sink to display freq, spec, time, and const plots |
Cgr::qtgui::sink_f | A graphical sink to display freq, spec, and time |
►Cgr::sync_block | Synchronous 1:1 input to output with historyOverride work to provide the signal processing implementation |
Catsc_deinterleaver | 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 |
Catsc_derandomizer | "dewhiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet; |
Catsc_ds_to_softds | Debug glue routine (atsc_data_segment –> atsc_soft_data_segment)input: atsc_data_segment; output: atsc_soft_data_segment |
Catsc_equalizer | 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 |
Catsc_fpll | ATSC FPLL (2nd Version)A/D –> GrFIRfilterFFF -—> GrAtscFPLL -—> |
Catsc_fs_checker | 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 |
Catsc_interleaver | 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 |
Catsc_randomizer | "Whiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet; output: atsc_mpeg_packet_no_sync |
Catsc_rs_decoder | Reed-Solomon decoder for ATSCinput: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_no_sync |
Catsc_rs_encoder | Reed-Solomon encoder for ATSCinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet_rs_encoded |
Catsc_trellis_encoder | ATSC 12-way interleaved trellis encoder (atsc_mpeg_packet_rs_encoded –> atsc_data_segment)input: atsc_mpeg_packet_rs_encoded; output: atsc_data_segment |
Catsc_viterbi_decoder | 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 |
Cgr::analog::agc2_cc | High performance Automatic Gain Control class with attack and decay rates |
Cgr::analog::agc2_ff | High performance Automatic Gain Control class with attack and decay rates |
Cgr::analog::agc3_cc | High performance Automatic Gain Control class with attack and decay rates |
Cgr::analog::agc_cc | High performance Automatic Gain Control class |
Cgr::analog::agc_ff | High performance Automatic Gain Control class |
Cgr::analog::dpll_bb | Detect the peak of a signal |
Cgr::analog::feedforward_agc_cc | Non-causal AGC which computes required gain based on max absolute value over nsamples |
Cgr::analog::fmdet_cf | Implements an IQ slope detector |
Cgr::analog::frequency_modulator_fc | Frequency modulator block |
Cgr::analog::phase_modulator_fc | Phase modulator block |
Cgr::analog::pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier |
Cgr::analog::pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod |
Cgr::analog::pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrier |
Cgr::analog::probe_avg_mag_sqrd_c | Compute avg magnitude squared |
Cgr::analog::probe_avg_mag_sqrd_cf | Compute avg magnitude squared |
Cgr::analog::probe_avg_mag_sqrd_f | Compute avg magnitude squared |
Cgr::analog::quadrature_demod_cf | Quadrature demodulator: complex in, float out |
Cgr::analog::rail_ff | Clips input values to min, max |
Cgr::analog::simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
Cgr::audio::sink | Creates a sink from an audio device |
Cgr::audio::source | Creates a source from an audio device |
Cgr::blocks::abs_ff | Output[m] = abs(input[m]) for all M streams |
Cgr::blocks::abs_ii | Output[m] = abs(input[m]) for all M streams |
Cgr::blocks::abs_ss | Output[m] = abs(input[m]) for all M streams |
Cgr::blocks::add_cc | Output = sum(input[0], input[1], ..., input[M-1]) |
Cgr::blocks::add_const_bb | Output = input + constant |
Cgr::blocks::add_const_cc | Output = input + constant |
Cgr::blocks::add_const_ff | Output = input + constant |
Cgr::blocks::add_const_ii | Output = input + constant |
Cgr::blocks::add_const_ss | Output = input + constant |
Cgr::blocks::add_const_vbb | Output[m] = input[m] + constant vector for all M streams |
Cgr::blocks::add_const_vcc | Output[m] = input[m] + constant vector for all M streams |
Cgr::blocks::add_const_vff | Output[m] = input[m] + constant vector for all M streams |
Cgr::blocks::add_const_vii | Output[m] = input[m] + constant vector for all M streams |
Cgr::blocks::add_const_vss | Output[m] = input[m] + constant vector for all M streams |
Cgr::blocks::add_ff | Output = sum (input_0, input_1, ...) |
Cgr::blocks::add_ii | Output = sum(input[0], input[1], ..., input[M-1]) |
Cgr::blocks::add_ss | Output = sum(input[0], input[1], ..., input[M-1]) |
Cgr::blocks::and_bb | Output = input[0] & input[1] & ... & input[M-1] |
Cgr::blocks::and_const_bb | Output[m] = input[m] & value for all M streams |
Cgr::blocks::and_const_ii | Output[m] = input[m] & value for all M streams |
Cgr::blocks::and_const_ss | Output[m] = input[m] & value for all M streams |
Cgr::blocks::and_ii | Output = input[0] & input[1] & ... & input[M-1] |
Cgr::blocks::and_ss | Output = input[0] & input[1] & ... & input[M-1] |
Cgr::blocks::annotator_1to1 | 1-to-1 stream annotator testing block. FOR TESTING PURPOSES ONLY |
Cgr::blocks::annotator_alltoall | All-to-all stream annotator testing block. FOR TESTING PURPOSES ONLY |
Cgr::blocks::annotator_raw | Raw stream annotator testing block |
Cgr::blocks::argmax_fs | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
Cgr::blocks::argmax_is | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
Cgr::blocks::argmax_ss | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
Cgr::blocks::bin_statistics_f | Control scanning and record frequency domain statistics |
Cgr::blocks::burst_tagger | Sets a burst on/off tag based on the value of the trigger input |
Cgr::blocks::char_to_float | Convert stream of chars to a stream of float |
Cgr::blocks::char_to_short | Convert stream of chars to a stream of shorts |
Cgr::blocks::check_lfsr_32k_s | Sink that checks if its input stream consists of a lfsr_32k sequence |
Cgr::blocks::complex_to_arg | Complex in, arg (arctan) out (float) |
Cgr::blocks::complex_to_float | Convert a stream of gr_complex to 1 or 2 streams of float |
Cgr::blocks::complex_to_imag | Produces the imaginary part (as a float0 of a complex stream |
Cgr::blocks::complex_to_mag | Complex in, magnitude out (float) |
Cgr::blocks::complex_to_mag_squared | Complex in, magnitude squared out (float) |
Cgr::blocks::complex_to_real | Produces the real part (as a float0 of a complex stream |
Cgr::blocks::conjugate_cc | Output = complex conjugate of input |
Cgr::blocks::ctrlport_probe2_b | A ControlPort probe to export vectors of signals |
Cgr::blocks::ctrlport_probe2_c | A ControlPort probe to export vectors of signals |
Cgr::blocks::ctrlport_probe2_f | A ControlPort probe to export vectors of signals |
Cgr::blocks::ctrlport_probe2_i | A ControlPort probe to export vectors of signals |
Cgr::blocks::ctrlport_probe2_s | A ControlPort probe to export vectors of signals |
Cgr::blocks::ctrlport_probe_c | A ControlPort probe to export vectors of signals |
Cgr::blocks::divide_cc | Output = input[0] / input[1] / ... / input[M-1] |
Cgr::blocks::divide_ff | Output = input[0] / input[1] / ... / input[M-1] |
Cgr::blocks::divide_ii | Output = input[0] / input[1] / ... / input[M-1] |
Cgr::blocks::divide_ss | Output = input[0] / input[1] / ... / input[M-1] |
Cgr::blocks::endian_swap | Convert stream of items into thier byte swapped version |
Cgr::blocks::file_descriptor_sink | Write stream to file descriptor |
Cgr::blocks::file_descriptor_source | Read stream from file descriptor |
Cgr::blocks::file_meta_sink | Write stream to file with meta-data headers |
Cgr::blocks::file_meta_source | Reads stream from file with meta-data headers. Headers are parsed into tags |
Cgr::blocks::file_sink | Write stream to file |
Cgr::blocks::file_source | Read stream from file |
Cgr::blocks::float_to_char | Convert stream of floats to a stream of char |
Cgr::blocks::float_to_complex | One or two floats in, complex out |
Cgr::blocks::float_to_int | Convert stream of floats to a stream of ints |
Cgr::blocks::float_to_short | Convert stream of floats to a stream of shorts |
Cgr::blocks::float_to_uchar | Convert stream of floats to a stream of unsigned chars |
Cgr::blocks::head | Copies the first N items to the output then signals done |
Cgr::blocks::int_to_float | Convert stream of ints to a stream of floats |
Cgr::blocks::lfsr_32k_source_s | LFSR pseudo-random source with period of 2^15 bits (2^11 shorts) |
Cgr::blocks::max_ff | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
Cgr::blocks::max_ii | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
Cgr::blocks::max_ss | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
Cgr::blocks::message_burst_source | Turn received messages into a stream and tag them for UHD to send |
Cgr::blocks::message_sink | Gather received items into messages and insert into msgq |
Cgr::blocks::message_source | Turn received messages into a stream |
Cgr::blocks::min_ff | Compares vectors from multiple streams and determines the minimum value from each vector over all streams |
Cgr::blocks::min_ii | Compares vectors from multiple streams and determines the minimum value from each vector over all streams |
Cgr::blocks::min_ss | Compares vectors from multiple streams and determines the minimum value from each vector over all streams |
Cgr::blocks::moving_average_cc | Output is the moving sum of the last N samples, scaled by the scale factor |
Cgr::blocks::moving_average_ff | Output is the moving sum of the last N samples, scaled by the scale factor |
Cgr::blocks::moving_average_ii | Output is the moving sum of the last N samples, scaled by the scale factor |
Cgr::blocks::moving_average_ss | Output is the moving sum of the last N samples, scaled by the scale factor |
Cgr::blocks::multiply_cc | Output = prod (input_0, input_1, ...) |
Cgr::blocks::multiply_conjugate_cc | Multiplies stream 0 by the complex conjugate of stream 1 |
Cgr::blocks::multiply_const_cc | Output = input * complex constant |
Cgr::blocks::multiply_const_ff | Output = input * real constant |
Cgr::blocks::multiply_const_ii | Output = input * constant |
Cgr::blocks::multiply_const_ss | Output = input * constant |
Cgr::blocks::multiply_const_vcc | Output = input * constant vector (element-wise) |
Cgr::blocks::multiply_const_vff | Output = input * constant vector (element-wise) |
Cgr::blocks::multiply_const_vii | Output = input * constant vector (element-wise) |
Cgr::blocks::multiply_const_vss | Output = input * constant vector (element-wise) |
Cgr::blocks::multiply_ff | Output = prod (input_0, input_1, ...) |
Cgr::blocks::multiply_ii | Output = prod (input_0, input_1, ...) |
Cgr::blocks::multiply_matrix_cc | Matrix multiplexer/multiplier: y(k) = A * x(k)This block is similar to gr::blocks::multiply_const_ff, the difference being it can handle several inputs and outputs, and the input-to-output relation can be described by the following mathematical equation:
and are column-vectors describing the elements on the input port at time step (this is a sync block with no memory) |
Cgr::blocks::multiply_matrix_ff | Matrix multiplexer/multiplier: y(k) = A * x(k)This block is similar to gr::blocks::multiply_const_ff, the difference being it can handle several inputs and outputs, and the input-to-output relation can be described by the following mathematical equation:
and are column-vectors describing the elements on the input port at time step (this is a sync block with no memory) |
Cgr::blocks::multiply_ss | Output = prod (input_0, input_1, ...) |
Cgr::blocks::mute_cc | Output = input or zero if muted |
Cgr::blocks::mute_ff | Output = input or zero if muted |
Cgr::blocks::mute_ii | Output = input or zero if muted |
Cgr::blocks::mute_ss | Output = input or zero if muted |
Cgr::blocks::nlog10_ff | Output = n*log10(input) + k |
Cgr::blocks::not_bb | Output = ~inputbitwise boolean not of input streams |
Cgr::blocks::not_ii | Output = ~inputbitwise boolean not of input streams |
Cgr::blocks::not_ss | Output = ~inputbitwise boolean not of input streams |
Cgr::blocks::null_sink | Bit bucket. Use as a termination point when a sink is required and we don't want to do anything real |
Cgr::blocks::null_source | A source of zeros used mainly for testing |
Cgr::blocks::or_bb | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
Cgr::blocks::or_ii | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
Cgr::blocks::or_ss | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
Cgr::blocks::peak_detector2_fb | Detect the peak of a signal |
Cgr::blocks::peak_detector_fb | Detect the peak of a signal |
Cgr::blocks::peak_detector_ib | Detect the peak of a signal |
Cgr::blocks::peak_detector_sb | Detect the peak of a signal |
Cgr::blocks::probe_rate | Throughput measurement |
Cgr::blocks::probe_signal_b | Sink that allows a sample to be grabbed from Python |
Cgr::blocks::probe_signal_c | Sink that allows a sample to be grabbed from Python |
Cgr::blocks::probe_signal_f | Sink that allows a sample to be grabbed from Python |
Cgr::blocks::probe_signal_i | Sink that allows a sample to be grabbed from Python |
Cgr::blocks::probe_signal_s | Sink that allows a sample to be grabbed from Python |
Cgr::blocks::probe_signal_vb | Sink that allows a vector of samples to be grabbed from Python |
Cgr::blocks::probe_signal_vc | Sink that allows a vector of samples to be grabbed from Python |
Cgr::blocks::probe_signal_vf | Sink that allows a vector of samples to be grabbed from Python |
Cgr::blocks::probe_signal_vi | Sink that allows a vector of samples to be grabbed from Python |
Cgr::blocks::probe_signal_vs | Sink that allows a vector of samples to be grabbed from Python |
Cgr::blocks::regenerate_bb | Detect the peak of a signal and repeat every period samples |
Cgr::blocks::rms_cf | RMS average power |
Cgr::blocks::rms_ff | RMS average power |
Cgr::blocks::rotator_cc | Complex rotator |
Cgr::blocks::sample_and_hold_bb | Sample and hold circuit |
Cgr::blocks::sample_and_hold_ff | Sample and hold circuit |
Cgr::blocks::sample_and_hold_ii | Sample and hold circuit |
Cgr::blocks::sample_and_hold_ss | Sample and hold circuit |
Cgr::blocks::short_to_char | Convert stream of shorts to a stream of chars |
Cgr::blocks::short_to_float | Convert stream of shorts to a stream of floats |
Cgr::blocks::stream_to_tagged_stream | Converts a regular stream into a tagged stream.All this block does is add length tags in regular intervals. It can be used to connect a regular stream to a gr::tagged_stream_block |
Cgr::blocks::streams_to_vector | Convert N streams of items to 1 stream of vector length N |
Cgr::blocks::stretch_ff | Adjust y-range of an input vector by mapping to range (max-of-input, stipulated-min). Primarily for spectral signature matching by normalizing spectrum dynamic ranges |
Cgr::blocks::sub_cc | Output = input_0 - input_1 - ...) |
Cgr::blocks::sub_ff | Output = input_0 - input_1 - ...) |
Cgr::blocks::sub_ii | Output = input_0 - input_1 - ...) |
Cgr::blocks::sub_ss | Output = input_0 - input_1 - ...) |
Cgr::blocks::tag_debug | Bit bucket that prints out any tag received |
Cgr::blocks::tag_gate | Control tag propagation.Use this block to stop tags from propagating |
Cgr::blocks::tagged_file_sink | A file sink that uses tags to save files |
Cgr::blocks::tags_strobe | Send tags at defined interval |
Cgr::blocks::threshold_ff | Output a 1 or zero based on a threshold value |
Cgr::blocks::throttle | Throttle flow of samples such that the average rate does not exceed samples_per_sec |
Cgr::blocks::transcendental | A block that performs various transcendental math operations |
Cgr::blocks::uchar_to_float | Convert stream of unsigned chars to a stream of floats |
Cgr::blocks::udp_sink | Write stream to an UDP socket |
Cgr::blocks::udp_source | Read stream from an UDP socket |
Cgr::blocks::vco_c | VCO - Voltage controlled oscillator |
Cgr::blocks::vco_f | VCO - Voltage controlled oscillator |
Cgr::blocks::vector_map | Maps elements from a set of input vectors to a set of output vectors |
Cgr::blocks::vector_sink_b | Unsigned char sink that writes to a vector |
Cgr::blocks::vector_sink_c | Gr_complex sink that writes to a vector |
Cgr::blocks::vector_sink_f | Float sink that writes to a vector |
Cgr::blocks::vector_sink_i | Int sink that writes to a vector |
Cgr::blocks::vector_sink_s | Short sink that writes to a vector |
Cgr::blocks::vector_source_b | Source that streams unsigned char items based on the input data vector |
Cgr::blocks::vector_source_c | Source that streams gr_complex items based on the input data vector |
Cgr::blocks::vector_source_f | Source that streams float items based on the input data vector |
Cgr::blocks::vector_source_i | Source that streams int items based on the input data vector |
Cgr::blocks::vector_source_s | Source that streams short items based on the input data vector |
Cgr::blocks::vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
Cgr::blocks::wavfile_sink | Write stream to a Microsoft PCM (.wav) file |
Cgr::blocks::wavfile_source | Read stream from a Microsoft PCM (.wav) file, output floats |
Cgr::blocks::xor_bb | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
Cgr::blocks::xor_ii | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
Cgr::blocks::xor_ss | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
Cgr::channels::cfo_model | Channel simulator |
Cgr::channels::fading_model | Fading simulator |
Cgr::channels::selective_fading_model | Fading simulator |
Cgr::comedi::sink_s | Sink using COMEDI |
Cgr::comedi::source_s | Source using COMEDI |
Cgr::digital::additive_scrambler_bb | Scramble an input stream using an LFSR |
Cgr::digital::binary_slicer_fb | Slice float binary symbol producing 1 bit output |
Cgr::digital::corr_est_cc | Correlate stream with a pre-defined sequence and estimate peak |
Cgr::digital::correlate_access_code_bb | Examine input for specified access code, one bit at a time |
Cgr::digital::correlate_access_code_tag_bb | Examine input for specified access code, one bit at a time |
Cgr::digital::correlate_and_sync_cc | Correlate to a preamble and send time/phase sync info |
Cgr::digital::costas_loop_cc | A Costas loop carrier recovery module |
Cgr::digital::descrambler_bb | Descramber an input stream using an LFSR |
Cgr::digital::diff_decoder_bb | Differential encoder: y[0] = (x[0] - x[-1]) % M |
Cgr::digital::diff_encoder_bb | Differential decoder: y[0] = (x[0] + y[-1]) % M |
Cgr::digital::diff_phasor_cc | Differential decoding based on phase change |
Cgr::digital::fll_band_edge_cc | Frequency Lock Loop using band-edge filters |
Cgr::digital::framer_sink_1 | Given a stream of bits and access_code flags, assemble packets |
Cgr::digital::glfsr_source_b | Galois LFSR pseudo-random source |
Cgr::digital::glfsr_source_f | Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0 |
Cgr::digital::hdlc_deframer_bp | HDLC deframer which takes in unpacked bits, and outputs PDU binary blobs. Frames which do not pass CRC are rejected |
Cgr::digital::hdlc_framer_pb | HDLC framer which takes in PMT binary blobs and outputs HDLC frames as unpacked bits, with CRC and bit stuffing added. The first sample of the frame is tagged with the tag frame_tag_name and includes a length field for tagged_stream use |
Cgr::digital::map_bb | Output[i] = map[input[i]] |
Cgr::digital::mpsk_snr_est_cc | A block for computing SNR of a signal |
Cgr::digital::ofdm_frame_sink | Takes an OFDM symbol in, demaps it into bits of 0's and 1's, packs them into packets, and sends to to a message queue sink |
Cgr::digital::ofdm_mapper_bcv | Take a stream of bytes in and map to a vector of complex constellation points suitable for IFFT input to be used in an ofdm modulator |
Cgr::digital::packet_headerparser_b | Post header metadata as a PMT |
Cgr::digital::packet_sink | Process received bits looking for packet sync, header, and process bits into packet |
Cgr::digital::probe_density_b | |
Cgr::digital::probe_mpsk_snr_est_c | A probe for computing SNR of a PSK signal |
Cgr::digital::scrambler_bb | Scramble an input stream using an LFSR |
Cgr::dtv::atsc_deinterleaver | ATSC 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 |
Cgr::dtv::atsc_derandomizer | ATSC "dewhiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet; |
Cgr::dtv::atsc_fpll | ATSC Receiver FPLL |
Cgr::dtv::atsc_interleaver | <+description of block+> |
Cgr::dtv::atsc_randomizer | <+description of block+> |
Cgr::dtv::atsc_rs_decoder | ATSC Receiver Reed-Solomon Decoder |
Cgr::dtv::atsc_rs_encoder | <+description of block+> |
Cgr::dtv::atsc_trellis_encoder | <+description of block+> |
Cgr::dtv::atsc_viterbi_decoder | ATSC Viterbi Decoder |
Cgr::dtv::dvb_bbscrambler_bb | Scrambles FEC baseband frames with a PRBS encoder |
Cgr::dtv::dvbt2_cellinterleaver_cc | Cell and time interleaves QPSK/QAM modulated cells.Input: QPSK, 16QAM, 64QAM or 256QAM modulated cells. Output: Cell and time interleaved QPSK, 16QAM, 64QAM or 256QAM modulated cells |
Cgr::dtv::dvbt2_freqinterleaver_cc | Frequency interleaves a T2 frame.Input: T2 frame. Output: Frequency interleaved T2 frame |
Cgr::dtv::dvbt2_miso_cc | Splits the stream for MISO (Multiple Input Single Output).Input: Frequency interleaved T2 frame. Output1: Frequency interleaved T2 frame (copy of input). Output2: Frequency interleaved T2 frame with modified Alamouti processing |
Cgr::dtv::dvbt2_paprtr_cc | Peak to Average Power Ratio (PAPR) reduction.Input: A T2 frame of OFDM symbols. Output: A T2 frame of PAPR reduced OFDM symbols |
Cgr::fft::ctrlport_probe_psd | A ControlPort probe to export vectors of signals |
Cgr::fft::fft_vcc | Compute forward or reverse FFT. complex vector in / complex vector out |
Cgr::fft::fft_vfc | Compute forward or reverse FFT. float vector in / complex vector out |
Cgr::filter::dc_blocker_cc | Computationally efficient controllable DC blocker |
Cgr::filter::dc_blocker_ff | Computationally efficient controllable DC blocker |
Cgr::filter::filter_delay_fc | Filter-Delay Combination Block |
Cgr::filter::hilbert_fc | Hilbert transformer |
Cgr::filter::iir_filter_ccc | IIR filter with complex input, complex output, and complex taps |
Cgr::filter::iir_filter_ccd | IIR filter with complex input, complex output, and double taps |
Cgr::filter::iir_filter_ccf | IIR filter with complex input, complex output, and float taps |
Cgr::filter::iir_filter_ccz | IIR filter with complex input, complex output, and complex (double) taps |
Cgr::filter::iir_filter_ffd | IIR filter with float input, float output and double taps |
Cgr::filter::pfb_decimator_ccf | Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps |
Cgr::filter::single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex output |
Cgr::filter::single_pole_iir_filter_ff | Single pole IIR filter with float input, float output |
Cgr::noaa::hrpt_decoder | NOAA HRPT Decoder |
Cgr::noaa::hrpt_pll_cf | NOAA HRPT PLL |
Cgr::pager::flex_parse | Flex parse description |
Cgr::pager::slicer_fb | Slicer description |
Cgr::qtgui::const_sink_c | A graphical sink to display the IQ constellation of multiple signals |
Cgr::qtgui::freq_sink_c | A graphical sink to display multiple signals in frequency |
Cgr::qtgui::freq_sink_f | A graphical sink to display multiple signals in frequency |
Cgr::qtgui::histogram_sink_f | A graphical sink to display a histogram |
Cgr::qtgui::number_sink | A graphical sink to display numerical values of input streams |
Cgr::qtgui::time_raster_sink_b | A graphical sink to display multiple signals on a time_raster plot |
Cgr::qtgui::time_raster_sink_f | A graphical sink to display multiple signals on a time_raster plot |
Cgr::qtgui::time_sink_c | A graphical sink to display multiple signals in time |
Cgr::qtgui::time_sink_f | A graphical sink to display multiple signals in time |
Cgr::qtgui::vector_sink_f | A graphical sink to display multiple vector-based signals |
Cgr::qtgui::waterfall_sink_c | A graphical sink to display multiple signals on a waterfall (spectrogram) plot |
Cgr::qtgui::waterfall_sink_f | A graphical sink to display multiple signals on a waterfall (spectrogram) plot |
►Cgr::sync_decimator | Synchronous N:1 input to output with historyOverride work to provide the signal processing implementation |
Catsc_pad | Pad mpeg ts packets from 188 byte char to to 256 byte atsc_mpeg_packetinput: unsigned char; output: atsc_mpeg_packet |
Cgr::blocks::integrate_cc | Integrate successive samples and decimate |
Cgr::blocks::integrate_ff | Integrate successive samples and decimate |
Cgr::blocks::integrate_ii | Integrate successive samples and decimate |
Cgr::blocks::integrate_ss | Integrate successive samples and decimate |
Cgr::blocks::interleaved_char_to_complex | Convert stream of interleaved chars to a stream of complex |
Cgr::blocks::interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
Cgr::blocks::pack_k_bits_bb | Converts a stream of bytes with 1 bit in the LSB to a byte with k relevent bits |
Cgr::blocks::stream_to_streams | Convert a stream of items into a N streams of items |
Cgr::blocks::stream_to_vector | Convert a stream of items into a stream of gnuradio/blocks containing nitems_per_block |
Cgr::digital::cma_equalizer_cc | Implements constant modulus adaptive filter on complex stream |
Cgr::digital::kurtotic_equalizer_cc | Implements a kurtosis-based adaptive equalizer on complex stream |
Cgr::digital::lms_dd_equalizer_cc | Least-Mean-Square Decision Directed Equalizer (complex in/out) |
Cgr::digital::pn_correlator_cc | PN code sequential search correlator |
Cgr::dtv::atsc_pad | <+description of block+> |
Cgr::fec::decode_ccsds_27_fb | A rate 1/2, k=7 convolutional decoder for the CCSDS standard |
Cgr::fft::goertzel_fc | Goertzel single-bin DFT calculation |
Cgr::filter::fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
Cgr::filter::fft_filter_ccf | Fast FFT filter with gr_complex input, gr_complex output and float taps |
Cgr::filter::fft_filter_fff | Fast FFT filter with float input, float output and float taps |
Cgr::pager::flex_deinterleave | Flex deinterleave description |
Cgr::vocoder::codec2_encode_sp | CODEC2 Vocoder EncoderInput: Speech (audio) signal as 16-bit shorts, sampling rate 8 kHz |
Cgr::vocoder::cvsd_encode_sb | This block performs CVSD audio encoding. Its design and implementation is modeled after the CVSD encoder/decoder specifications defined in the Bluetooth standard |
Cgr::vocoder::gsm_fr_encode_sp | GSM 06.10 Full Rate Vocoder EncoderInput: 16-bit shorts representing speech samples Output: Vector of 33 bytes per 160 input samples |
►Cgr::sync_interpolator | Synchronous 1:N input to output with historyOverride work to provide the signal processing implementation |
Catsc_depad | Depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte charinput: atsc_mpeg_packet; output: unsigned char |
Cgr::analog::cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
Cgr::blocks::complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
Cgr::blocks::repeat | Repeat each input repeat times |
Cgr::blocks::streams_to_stream | Convert N streams of 1 item into a 1 stream of N items |
Cgr::blocks::unpack_k_bits_bb | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
Cgr::blocks::vector_to_stream | Convert a stream of gnuradio/blocks of nitems_per_block items into a stream of items |
Cgr::digital::constellation_soft_decoder_cf | Constellation Decoder |
Cgr::dtv::atsc_depad | ATSC depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte charinput: atsc_mpeg_packet; output: unsigned char |
Cgr::dtv::dvbt_convolutional_interleaver | Convolutional interleaver.ETSI EN 300 744 Clause 4.3.1
Forney (Ramsey type III) convolutional interleaver.
Input: Blocks of I bytes size.
Output: Stream of 1 byte elements |
Cgr::fec::encode_ccsds_27_bb | A rate 1/2, k=7 convolutional encoder for the CCSDS standard |
Cgr::filter::pfb_interpolator_ccf | Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps |
Cgr::filter::pfb_synthesizer_ccf | Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps |
Cgr::vocoder::codec2_decode_ps | CODEC2 Vocoder DecoderInput: A vector of unpacked bits forming a Codec2 frame |
Cgr::vocoder::cvsd_decode_bs | This block performs CVSD audio decoding. Its design and implementation is modeled after the CVSD encoder/decoder specifications defined in the Bluetooth standard |
Cgr::vocoder::gsm_fr_decode_ps | GSM 06.10 Full Rate Vocoder DecoderInput: Vector of 33 bytes per 160 input samples Output: 16-bit shorts representing speech samples |
Cgr::trellis::permutation | Permutation |
►Cgr::uhd::usrp_block | |
Cgr::uhd::usrp_sink | |
Cgr::uhd::usrp_source | |
Cgr::video_sdl::sink_s | Video sink using SDL |
Cgr::video_sdl::sink_uc | Video sink using SDL |
Cgr::vocoder::alaw_decode_bs | This block performs alaw audio decoding |
Cgr::vocoder::alaw_encode_sb | This block performs g.711 alaw audio encoding |
Cgr::vocoder::g721_decode_bs | This block performs g721 audio decoding |
Cgr::vocoder::g721_encode_sb | This block performs g721 audio encoding |
Cgr::vocoder::g723_24_decode_bs | This block performs g723_24 audio decoding |
Cgr::vocoder::g723_24_encode_sb | This block performs g723_24 audio encoding |
Cgr::vocoder::g723_40_decode_bs | This block performs g723_40 audio decoding |
Cgr::vocoder::g723_40_encode_sb | This block performs g723_40 audio encoding |
Cgr::vocoder::ulaw_decode_bs | This block performs ulaw audio decoding |
Cgr::vocoder::ulaw_encode_sb | This block performs g.711 ulaw audio encoding |
Cgr::wavelet::squash_ff | Implements cheap resampling of spectrum directly from spectral points, using gsl interpolation |
Cgr::wavelet::wavelet_ff | Compute wavelet transform using gsl routines |
Cgr::wavelet::wvps_ff | Computes the Wavelet Power Spectrum from a set of wavelet coefficients |
Cgr::wxgui::histo_sink_f | Histogram module |
►Cgr::wxgui::oscope_sink_x | Abstract class for python oscilloscope module.Don't instantiate this. Use gr::blocks::oscope_sink_f instead |
Cgr::wxgui::oscope_sink_f | Building block for python oscilloscope module.Accepts multiple float streams |
Cgr::zeromq::pub_sink | Sink the contents of a stream to a ZMQ PUB socket |
Cgr::zeromq::pull_source | Receive messages on ZMQ PULL socket and source stream |
Cgr::zeromq::push_sink | Sink the contents of a stream to a ZMQ PUSH socket |
Cgr::zeromq::rep_sink | Sink the contents of a stream to a ZMQ REP socket |
Cgr::zeromq::req_source | Receive messages on ZMQ REQ socket and source stream |
Cgr::zeromq::sub_source | Receive messages on ZMQ SUB socket and source stream |
►Cgr::tagged_stream_block | Block that operates on PDUs in form of tagged streamsOverride work to provide the signal processing implementation |
Cgr::blocks::pdu_to_tagged_stream | Turns received PDUs into a tagged stream of items |
Cgr::blocks::repack_bits_bb | Repack k bits from the input stream onto l bits of the output stream |
Cgr::blocks::tagged_stream_mux | Combines tagged streams |
Cgr::blocks::tagged_stream_to_pdu | Turns received stream data and tags into PDUs and sends them through a message port.The sent message is a PMT-pair (created by pmt::cons()). The first element is a dictionary containing all the tags. The second is a vector containing the actual data |
Cgr::blocks::tsb_vector_sink_b | A vector sink for tagged streams |
Cgr::blocks::tsb_vector_sink_c | A vector sink for tagged streams |
Cgr::blocks::tsb_vector_sink_f | A vector sink for tagged streams |
Cgr::blocks::tsb_vector_sink_i | A vector sink for tagged streams |
Cgr::blocks::tsb_vector_sink_s | A vector sink for tagged streams |
Cgr::digital::crc32_bb | Byte-stream CRC block |
Cgr::digital::ofdm_carrier_allocator_cvc | Create frequency domain OFDM symbols from complex values, add pilots |
Cgr::digital::ofdm_cyclic_prefixer | Adds a cyclic prefix and performs pulse shaping on OFDM symbols |
Cgr::digital::ofdm_frame_equalizer_vcvc | OFDM frame equalizer |
Cgr::digital::ofdm_serializer_vcc | Serializes complex modulations symbols from OFDM sub-carriers |
Cgr::digital::packet_headergenerator_bb | Generates a header for a tagged, streamed packet |
Cgr::fec::tagged_decoder | General FEC decoding block that takes in a decoder variable object (derived from gr::fec::general_decoder) for use in a flowgraph |
Cgr::fec::tagged_encoder | Creates the encoder block for use in GNU Radio flowgraphs from a given FECAPI object derived from the generic_encoder class |
Cgr::trellis::constellation_metrics_cf | Evaluate metrics for use by the Viterbi algorithm |
Cgr::trellis::siso_combined_f | |
Cgr::trellis::siso_f | |
Cgr::zeromq::pub_msg_sink | Sink the contents of a msg port to a ZMQ PUB socket |
Cgr::zeromq::pull_msg_source | Receive messages on ZMQ PULL socket and output async messages |
Cgr::zeromq::push_msg_sink | Sink the contents of a msg port to a ZMQ PUSH socket |
Cgr::zeromq::rep_msg_sink | Sink the contents of a msg port to a ZMQ REP socket |
Cgr::zeromq::req_msg_source | Receive messages on ZMQ REQ socket output async messages |
Cgr::zeromq::sub_msg_source | Receive messages on ZMQ SUB socket and output async messages |
►Cgr::hier_block2 | Hierarchical container class for gr::block's and gr::hier_block2's |
Cgr::channels::channel_model | Basic channel simulator |
Cgr::channels::channel_model2 | Basic channel simulator allowing time-varying frequency and timing inputs |
Cgr::channels::dynamic_channel_model | Dynamic channel simulator |
Cgr::digital::cpmmod_bc | Generic CPM modulator |
Cgr::digital::ofdm_sync_sc_cfb | Schmidl & Cox synchronisation for OFDM |
Cgr::fcd::source_c | Funcube Dongle source block |
Cgr::top_block | Top-level hierarchical block representing a flowgraph |
►Cgr::digital::constellation | An abstracted constellation object |
Cgr::digital::constellation_16qam | Digital constellation for 16qam |
Cgr::digital::constellation_8psk | Digital constellation for 8PSK |
Cgr::digital::constellation_8psk_natural | Digital constellation for natually mapped 8PSK |
Cgr::digital::constellation_bpsk | Digital constellation for BPSK |
Cgr::digital::constellation_calcdist | Calculate Euclidian distance for any constellation |
Cgr::digital::constellation_dqpsk | Digital constellation for DQPSK |
Cgr::digital::constellation_qpsk | Digital constellation for QPSK |
►Cgr::digital::constellation_sector | Sectorized digital constellation |
Cgr::digital::constellation_psk | Constellation_pskConstellation space is divided into pie slices sectors |
►Cgr::digital::constellation_rect | Rectangular digital constellationOnly implemented for 1-(complex)dimensional constellation |
Cgr::digital::constellation_expl_rect | Rectangular digital constellation |
►Cgr::digital::ofdm_equalizer_base | |
►Cgr::digital::ofdm_equalizer_1d_pilots | |
Cgr::digital::ofdm_equalizer_simpledfe | |
Cgr::digital::ofdm_equalizer_static | |
►Cgr::digital::packet_header_default | Default header formatter for digital packet transmission |
Cgr::digital::packet_header_ofdm | Header utility for OFDM signals |
Cgr::endpoint | Class representing a specific input or output graph endpoint |
Censure_py_gil_state | |
►Cstd::exception | STL class |
►Cstd::logic_error | STL class |
►Cpmt::exception | |
Cpmt::notimplemented | |
Cpmt::out_of_range | |
Cpmt::wrong_type | |
►Cgr::feval | Base class for evaluating a function: void -> voidThis class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic |
Cgr::py_feval | |
►Cgr::feval_cc | Base class for evaluating a function: complex -> complexThis class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic |
Cgr::py_feval_cc | |
►Cgr::feval_dd | Base class for evaluating a function: double -> doubleThis class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic |
Cgr::py_feval_dd | |
►Cgr::feval_ll | Base class for evaluating a function: long -> longThis class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic |
Cgr::py_feval_ll | |
►Cgr::feval_p | Base class for evaluating a function: pmt -> voidThis class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic |
Cgr::py_feval_p | |
Cgr::fft::fft_complex | FFT: complex in, complex out |
Cgr::filter::kernel::fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
Cgr::filter::kernel::fft_filter_ccf | Fast FFT filter with gr_complex input, gr_complex output and float taps |
Cgr::filter::kernel::fft_filter_fff | Fast FFT filter with float input, float output and float taps |
Cgr::fft::fft_real_fwd | FFT: real in, complex out |
Cgr::fft::fft_real_rev | FFT: complex in, float out |
►Cgr::blocks::file_sink_base | Common base class for file sinks |
Cgr::blocks::file_sink | Write stream to file |
Cgr::filter::kernel::filterbank | A filter bank with generic taps |
Cgr::filter::kernel::fir_filter_ccc | |
Cgr::filter::kernel::fir_filter_ccf | |
Cgr::filter::kernel::fir_filter_fcc | |
Cgr::filter::kernel::fir_filter_fff | |
Cgr::filter::kernel::fir_filter_fsf | |
Cgr::filter::kernel::fir_filter_scc | |
Cgr::filter::kernel::fir_filter_with_buffer_ccc | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
Cgr::filter::kernel::fir_filter_with_buffer_ccf | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
Cgr::filter::kernel::fir_filter_with_buffer_fff | FIR with internal buffer for float input, float output and float taps |
Cgr::filter::firdes | Finite Impulse Response (FIR) filter design functions |
Cgr::pager::flex_frame | Flex_frame |
Cgr::flowgraph | Class representing a directed, acyclic graph of basic blocks |
►CFreqOffsetAndPrecisionClass | |
CFreqDisplayScaleDraw | |
Cgr::trellis::fsm | Finite State Machine Specification class |
Cgr::fxpt | Fixed point sine and cosine and friends.fixed pt radians
-2**31 -pi 0 0 2**31-1 pi - epsilon |
Cgr::fxpt_nco | Numerically Controlled Oscillator (NCO) |
Cgr::fxpt_vco | Voltage Controlled Oscillator (VCO) |
►Cgr::fec::generic_decoder | Parent class for FECAPI objects |
Cgr::fec::code::cc_decoder | Convolutional Code Decoding class |
Cgr::fec::code::dummy_decoder | Dummy Decoding class |
Cgr::fec::code::repetition_decoder | Repetition Decoding class |
Cgr::fec::ldpc_decoder | |
Cgr::fec::tpc_decoder | |
►Cgr::fec::generic_encoder | |
Cgr::fec::code::cc_encoder | Convolutional Code Encoding class |
Cgr::fec::code::ccsds_encoder | CCSDS Encoding class for convolutional encoding with rate 1/2, K=7, and polynomials [109, 79] |
Cgr::fec::code::dummy_encoder | Dummy Encoding class |
Cgr::fec::code::repetition_encoder | Repetition Encoding class |
Cgr::fec::ldpc_encoder | |
Cgr::fec::tpc_encoder | |
CGF2Mat | |
CGF2Vec | |
Cgr::digital::glfsr | Galois Linear Feedback Shift Register using specified polynomial mask |
Cgr::fft::goertzel | Implements Goertzel single-bin DFT calculation |
►Cgr_fir_builder | |
►Catsc_root_raised_cosine | |
Catsc_root_raised_cosine_bandpass | |
Catsc_vsbtx_lp | |
Catsci_exp2_lp | |
Cgr::filter::kernel::iir_filter< i_type, o_type, tap_type, acc_type > | Base class template for Infinite Impulse Response filter (IIR) |
Cgr::trellis::interleaver | INTERLEAVER class |
Cinterleaver_fifo< symbol_type > | Template class for interleaver fifo |
Cinterleaver_fifo< unsigned char > | |
Cgr::io_signature | I/o signature for input and output ports |
Cgr::digital::lfsr | Fibonacci Linear Feedback Shift Register using specified polynomial mask |
Cgr::blocks::lfsr_15_1_0 | Linear Feedback Shift Register using primitive polynomial x^15 + x + 1 |
Cgr::blocks::lfsr_32k | Generate pseudo-random sequence of length 32768 bits |
Cgr::logger | Logger class for referencing loggers in python. Not needed in C++ (use macros) Wraps and manipulates loggers for python as python has no macros |
Cgr::logger_config | Class to control configuration of logger. This is a singleton that cna launch a thread to wathc a config file for changes |
Cgr::message | Message class |
Cmetric_t | |
Cgr::filter::mmse_fir_interpolator_cc | Compute intermediate samples between signal samples x(k*Ts) |
Cgr::filter::mmse_fir_interpolator_ff | Compute intermediate samples between signal samples x(k*Ts) |
►Cgr::digital::mpsk_snr_est | A parent class for SNR estimators, specifically for M-PSK signals in AWGN channels |
Cgr::digital::mpsk_snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
Cgr::digital::mpsk_snr_est_simple | SNR Estimator using simple mean/variance estimates |
Cgr::digital::mpsk_snr_est_skew | SNR Estimator using skewness correction |
Cgr::digital::mpsk_snr_est_svr | Signal-to-Variation Ratio SNR Estimator |
Cgr::digital::snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
►Cgr::messages::msg_accepter | Virtual base class that accepts messages |
Cgr::messages::msg_accepter_msgq | Concrete class that accepts messages and inserts them into a message queue |
►Cgr::msg_accepter | Accepts messages and inserts them into a message queue, then notifies subclass gr::basic_block there is a message pending |
Cgr::basic_block | The abstract base class for all signal processing blocks.Basic blocks are the bare abstraction of an entity that has a name, a set of inputs and outputs, and a message queue. These are never instantiated directly; rather, this is the abstract parent class of both gr_hier_block, which is a recursive container, and block, which implements actual signal processing functions |
►Crpcextractor_base< T, Tto > | Base class for registering a ControlPort Extractor. Acts as a message acceptor |
Crpcbasic_extractor< T, Tto > | Templated parent class for registering a ControlPort Extractor |
►Crpcextractor_base< T, bool > | |
Crpcbasic_extractor< T, bool > | Specialized extractor class for bool data |
►Crpcextractor_base< T, char > | |
Crpcbasic_extractor< T, char > | Specialized extractor class for char data |
►Crpcextractor_base< T, double > | |
Crpcbasic_extractor< T, double > | Specialized extractor class for double data |
►Crpcextractor_base< T, float > | |
Crpcbasic_extractor< T, float > | Specialized extractor class for float data |
►Crpcextractor_base< T, int > | |
Crpcbasic_extractor< T, int > | Specialized extractor class for int data |
►Crpcextractor_base< T, long > | |
Crpcbasic_extractor< T, long > | Specialized extractor class for long data |
►Crpcextractor_base< T, short > | |
Crpcbasic_extractor< T, short > | Specialized extractor class for short data |
►Crpcextractor_base< T, std::complex< double > > | |
Crpcbasic_extractor< T, std::complex< double > > | Specialized extractor class for complex (double) data |
►Crpcextractor_base< T, std::complex< float > > | |
Crpcbasic_extractor< T, std::complex< float > > | Specialized extractor class for complex (float) data |
►Crpcextractor_base< T, std::string > | |
Crpcbasic_extractor< T, std::string > | Specialized extractor class for string data |
►Crpcextractor_base< T, void > | |
Crpcbasic_extractor< T, void > | Specialized extractor class to make calls to functions that do not take data (enable, reset, start, etc.) |
Cgr::msg_edge | Class representing a msg connection between to graph msg endpoints |
Cgr::msg_endpoint | |
►Cgr::msg_handler | Abstract class of message handlers |
Cgr::msg_queue | Thread-safe message queue |
►Cgr::messages::msg_producer | Virtual base class that produces messages |
►Crpcinserter_base< T, Tfrom > | Base class for registering a ControlPort Inserter. Produces a message |
Crpcbasic_inserter< T, Tfrom > | Templated parent class for registering a ControlPort Inserter |
►Crpcinserter_base< T, std::complex< double > > | |
Crpcbasic_inserter< T, std::complex< double > > | Specialized inserter class for complex (double) data |
►Crpcinserter_base< T, std::complex< float > > | |
Crpcbasic_inserter< T, std::complex< float > > | Specialized inserter class for complex (float) data |
►Crpcinserter_base< T, std::vector< float > > | |
Crpcbasic_inserter< T, std::vector< float > > | Specialized inserter class for vectors of float data |
►Crpcinserter_base< T, std::vector< int > > | |
Crpcbasic_inserter< T, std::vector< int > > | Specialized inserter class for vectors of int data |
►Crpcinserter_base< T, std::vector< short > > | |
Crpcbasic_inserter< T, std::vector< short > > | Specialized inserter class for vectors of short data |
►Crpcinserter_base< T, std::vector< signed char > > | |
Crpcbasic_inserter< T, std::vector< signed char > > | Specialized inserter class for vectors of signed char data |
►Crpcinserter_base< T, std::vector< std::complex< float > > > | |
Crpcbasic_inserter< T, std::vector< std::complex< float > > > | Specialized inserter class for vectors of complex (float) data |
►Crpcinserter_base< T, std::vector< uint8_t > > | |
Crpcbasic_inserter< T, std::vector< uint8_t > > | Specialized inserter class for vectors of uint8_t data |
►Crpcinserter_base< T, uint64_t > | |
Crpcbasic_inserter< T, uint64_t > | Specialized inserter class for uint64_t data |
Cgr::messages::msg_queue | Thread-safe message queue |
Cgr::nco< o_type, i_type > | Base class template for Numerically Controlled Oscillator (NCO) |
Cgr::nco< float, float > | |
►Cnoncopyable | |
Cgr::thread::thread_group | |
Crpcpmtconverter::To_PMT | |
Cgr::wxgui::oscope_guts | Guts of oscilloscope trigger and buffer module |
Cgr::blocks::kernel::pack_k_bits | Converts a vector of bytes with 1 bit in the LSB to a byte with k relevent bits |
Cgr::filter::kernel::pfb_arb_resampler_ccc | |
Cgr::filter::kernel::pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
Cgr::filter::kernel::pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
Cgr::fft::planner | Export reference to planner mutex for those apps that want to use FFTW w/o using the fft_impl_fftw* classes |
Cplinfo | Pipeline info that flows with data |
Cpmt_assist< myType > | |
Cpmt::pmt_pool | Very simple thread-safe fixed-size allocation pool |
Cgr::filter::kernel::polyphase_filterbank | Polyphase filterbank parent class |
Cgr::prefs | Base class for representing user preferences a la windows INI files.The real implementation is in Python, and is accessable from C++ via the magic of SWIG directors |
Cpycallback_object< myType > | |
►CQAction | |
CItemFloatAct | |
CLineTitleAction | |
CNPointsMenu | |
COtherAction | |
COtherDualAction | |
CPopupMenu | |
►CQEvent | |
CConstUpdateEvent | |
CFreqUpdateEvent | |
CHistogramUpdateEvent | |
CNumberUpdateEvent | |
CSetFreqEvent | |
CSpectrumFrequencyRangeEvent | |
CSpectrumUpdateEvent | |
CSpectrumWindowCaptionEvent | |
CSpectrumWindowResetEvent | |
CTimeRasterUpdateEvent | |
CTimeUpdateEvent | |
CWaterfallUpdateEvent | |
►CQMenu | |
►CAverageMenu | |
CFFTAverageMenu | |
CColorMapMenu | |
CFFTSizeMenu | |
CFFTWindowMenu | |
CLineColorMenu | |
CLineMarkerMenu | |
CLineStyleMenu | |
CLineWidthMenu | |
CMarkerAlphaMenu | |
CNumberColorMapMenu | |
CNumberLayoutMenu | |
CTriggerChannelMenu | |
CTriggerModeMenu | |
CTriggerSlopeMenu | |
Csssr::quad_filter | Quad filter (used to compute timing error) |
►CQVBoxLayout | |
CFreqControlPanel | |
CTimeControlPanel | |
►CQWidget | |
►CDisplayForm | Base class for setting up and managing QTGUI plot forms |
CConstellationDisplayForm | DisplayForm child for managing constellaton (I&Q) plots |
CFreqDisplayForm | DisplayForm child for managing frequency (PSD) plots |
CHistogramDisplayForm | DisplayForm child for managing histogram domain plots |
CTimeDisplayForm | DisplayForm child for managing time domain plots |
CTimeRasterDisplayForm | DisplayForm child for managing time raster plots |
CVectorDisplayForm | DisplayForm child for managing vector plots |
CWaterfallDisplayForm | DisplayForm child for managing waterfall (spectrogram) plots |
CNumberDisplayForm | DisplayForm child for managing number sink plots |
CSpectrumDisplayForm | |
►CQwtLinearColorMap | |
CColorMap_BlackHot | |
CColorMap_Cool | |
CColorMap_Incandescent | |
CColorMap_MultiColor | |
CColorMap_Sunset | |
CColorMap_UserDefined | |
CColorMap_WhiteHot | |
►CQwtPickerMachine | |
CQwtPickerDblClickPointMachine | |
►CQwtPlot | |
►CDisplayPlot | QWidget base plot to build QTGUI plotting tools |
CConstellationDisplayPlot | QWidget for displaying constellaton (I&Q) plots |
CFrequencyDisplayPlot | QWidget for displaying frequency domain (PSD) plots |
CHistogramDisplayPlot | QWidget for displaying time domain plots |
CTimeDomainDisplayPlot | QWidget for displaying time domain plots |
CTimeRasterDisplayPlot | QWidget for time raster (time vs. time) plots |
CVectorDisplayPlot | QWidget for displaying 1D-vector plots |
CWaterfallDisplayPlot | QWidget for displaying waterfall (spectrogram) plots |
►CQwtPlotPicker | |
CQwtDblClickPlotPicker | |
►CQwtPlotRasterItem | |
CPlotTimeRaster | A plot item, which displays a time raster |
CPlotWaterfall | A plot item, which displays a waterfall spectrogram |
►CQwtRasterData | |
CTimeRasterData | |
CWaterfallData | |
►CQwtScaleDraw | |
CFreqDisplayScaleDraw | |
Cgr::random | Pseudo random number generator |
Cgr::blocks::rotator | |
Crpc_register_base< T > | Base class for registering a ControlPort function |
►Crpcbasic_base | |
Crpcbasic_register_get< T, Tfrom > | Registers a 'get' function to get a parameter over ControlPort |
Crpcbasic_register_get< rpcbasic_register_variable< Tfrom >, Tfrom > | |
Crpcbasic_register_set< T, Tto > | Registers a 'set' function to set a parameter over ControlPort |
Crpcbasic_register_set< rpcbasic_register_variable_rw< Tfrom >, Tfrom > | |
Crpcbasic_register_trigger< T > | Registers a 'trigger' function to trigger an action over ControlPort |
►Crpcbasic_register_variable< Tfrom > | Registers a read-only function to get a parameter over ControlPort |
Crpcbasic_register_variable_rw< Tfrom > | Registers a read/write function to get and set a parameter over ControlPort |
Crpcbufferedget< TdataType > | |
►Crpcmanager_base | |
Crpcmanager | |
►Crpcserver_booter_base | |
Crpcserver_booter_aggregator | |
Crpcserver_booter_thrift | |
Crpcmanager::rpcserver_booter_register_helper< T > | |
Cgr::impl::rt_sched_param | |
Csssr::seg_sync_integrator | Segment sync integrator |
Cgr::filter::single_pole_iir< o_type, i_type, tap_type > | Class template for single pole IIR filter |
Cgr::filter::single_pole_iir< float, float, float > | |
Cgr::filter::single_pole_iir< gr_complex, i_type, double > | |
►CSpectrumDisplayForm | |
CSpectrumDisplayForm | |
CSpectrumGUIClass | QWidget class for controlling plotting |
Cgnuradio::detail::sptr_magic | |
Cuhd::stream_args_t | |
Catsc::syminfo | |
Cgr::sys_pri | |
Cgr::tag_checker | |
Cgr::tag_t | |
Cgr::thread::thread_body_wrapper< F > | |
Cthrift_application_base< TserverBase, TserverClass > | Base class for a Thrift application with a singleton with instance function thrift_application_base::i(). Lazy initialization is used to start the Thrift runtime, therefore the Thrift runtime is not started unless thrift_application_base::i() is called at least once. This typically means that at least one rpc variable must be registered by a block before the runtime will start |
►Cthrift_application_base< rpcserver_base, rpcserver_booter_thrift > | |
►Cthrift_server_template< rpcserver_base, rpcserver_thrift, rpcserver_booter_thrift > | |
Crpcserver_booter_thrift | |
►Cthrift_application_base< TserverBase, TImplClass > | |
Cthrift_server_template< TserverBase, TserverClass, TImplClass > | |
Cthrift_application_base_impl | Class to be statically initialized by thrift_application_base. Used to store state for thrift_application_base's singleton functions |
CTimeScaleData | |
►Crpcpmtconverter::to_pmt_f | |
Crpcpmtconverter::to_pmt_bool_f | |
Crpcpmtconverter::to_pmt_byte_f | |
Crpcpmtconverter::to_pmt_c32vect_f | |
Crpcpmtconverter::to_pmt_complex_f | |
Crpcpmtconverter::to_pmt_double_f | |
Crpcpmtconverter::to_pmt_f32vect_f | |
Crpcpmtconverter::to_pmt_f64vect_f | |
Crpcpmtconverter::to_pmt_int_f | |
Crpcpmtconverter::to_pmt_long_f | |
Crpcpmtconverter::to_pmt_s16vect_f | |
Crpcpmtconverter::to_pmt_s32vect_f | |
Crpcpmtconverter::to_pmt_s64vect_f | |
Crpcpmtconverter::to_pmt_s8vect_f | |
Crpcpmtconverter::to_pmt_short_f | |
Crpcpmtconverter::to_pmt_string_f | |
Crpcpmtconverter::to_pmt_reg< TO_PMT_F > | |
Cgr::tpb_detail | Used by thread-per-block scheduler |
Cgr::fec::tpc_common | |
Cgr::blocks::kernel::unpack_k_bits | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
Cv | |
Cviterbi_state | |
►CVrDecimatingSigProc | |
CGrAtscBitTimingLoop | ATSC BitTimingLoop |
CGrAtscBitTimingLoop2 | ATSC BitTimingLoop |
CGrAtscBitTimingLoop3 | ATSC BitTimingLoop3 |
CGrAtscConvert2xTo20 | |
CGrAtscFieldSyncDemux | ATSC Field Sync Demux |
►CGrAtscSegSymSync | ATSC SegSymSync |
CGrAtscSegSymSyncImpl | Concrete implementation of GrAtscSegSymSync |
►CVrHistoryProc | |
CGrAtscDataSegToSoftDataSeg | Debug glue routine (atsc_data_segment –> atsc_soft_data_segment) |
CGrAtscDeinterleaver | Deinterleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded –> atsc_mpeg_packet_rs_encoded) |
CGrAtscDerandomizer | Derandomize ATSC data (atsc_mpeg_packet_no_sync –> atsc_mpeg_packet) |
CGrAtscEqualizer | ATSC equalizer (float,syminfo –> float,syminfo) |
CGrAtscFieldSyncChecker | ATSC field sync checker (float,syminfo –> float,syminfo) |
CGrAtscFieldSyncCorrelator | ATSC field sync correlator (float –> float,float) |
CGrAtscFieldSyncMux | Insert ATSC Field Syncs as required (atsc_data_segment –> atsc_data_segment) |
CGrAtscInterleaver | Interleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded –> atsc_mpeg_packet_rs_encoded) |
CGrAtscRandomizer | Randomize ATSC data (atsc_mpeg_packet –> atsc_mpeg_packet_no_sync) |
CGrAtscRSDecoder | Pass ATSC data Reed-Solomon decoder( atsc_mpeg_packet_rs_encoded –> atsc_mpeg_rs_no_sync) |
CGrAtscRSEncoder | Encode using Reed Solomon ATSC data (atsc_mpeg_packet_no_sync –> atsc_mpeg_packet_rs_encoded) |
CGrAtscTrellisEncoder | ATSC 12-way interleaved trellis encoder (atsc_mpeg_packet_rs_encoded –> atsc_data_segment) |
CGrAtscViterbiDecoder | ATSC 12-way interleaved viterbi decoder (atsc_soft_data_segment –> atsc_mpeg_packet_rs_encoded) |
►CVrInterpolatingSigProcNoWork | |
CGrAtscSymbolMapper< oType > | Take atsc_data_segments and map them to symbols |
►CVrSigProc | |
CGrAtscFPLL | ATSC FPLL (2nd Version) |
Cgr::fft::window | |