| Aadvark | Models the mammal Aadvark |
| gr::filter::adaptive_fir_ccc | Adaptive FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::adaptive_fir_ccc_impl | |
| gr::filter::adaptive_fir_ccf | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
| gr::filter::adaptive_fir_ccf_impl | |
| gr::blocks::add_cc | Output = sum (input_0, input_1, ...) |
| gr::blocks::add_cc_impl | |
| gr::blocks::add_const_cc | Output = input + constant |
| gr::blocks::add_const_cc_impl | |
| gr::blocks::add_const_ff | Output = input + constant |
| gr::blocks::add_const_ff_impl | |
| gr::blocks::add_const_ii | Output = input + constant |
| gr::blocks::add_const_ii_impl | |
| gr::blocks::add_const_ss | Output = input + constant |
| gr::blocks::add_const_ss_impl | |
| gr::blocks::add_const_vcc | Output = input + constant vector |
| gr::blocks::add_const_vcc_impl | |
| gr::blocks::add_const_vff | Output = input + constant vector |
| gr::blocks::add_const_vff_impl | |
| gr::blocks::add_const_vii | Output = input + constant vector |
| gr::blocks::add_const_vii_impl | |
| gr::blocks::add_const_vss | Output = input + constant vector |
| gr::blocks::add_const_vss_impl | |
| gr::blocks::add_ff | Output = sum (input_0, input_1, ...) |
| gr::blocks::add_ff_impl | |
| gr::blocks::add_ii | Output = sum (input_0, input_1, ...) |
| gr::blocks::add_ii_impl | |
| gr::blocks::add_ss | Output = sum (input_0, input_1, ...) |
| gr::blocks::add_ss_impl | |
| gr::analog::kernel::agc2_cc | High performance Automatic Gain Control class |
| gr::analog::agc2_cc | High performance Automatic Gain Control class |
| gr::analog::agc2_cc_impl | |
| gr::analog::kernel::agc2_ff | |
| gr::analog::agc2_ff | High performance Automatic Gain Control class |
| gr::analog::agc2_ff_impl | |
| gr::analog::kernel::agc_cc | High performance Automatic Gain Control class for complex signals |
| gr::analog::agc_cc | High performance Automatic Gain Control class |
| gr::analog::agc_cc_impl | |
| gr::analog::kernel::agc_ff | High performance Automatic Gain Control class for float signals |
| gr::analog::agc_ff | High performance Automatic Gain Control class |
| gr::analog::agc_ff_impl | |
| gr::blocks::and_bb | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr::blocks::and_bb_impl | |
| gr::blocks::and_const_bb | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr::blocks::and_const_bb_impl | |
| gr::blocks::and_const_ii | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr::blocks::and_const_ii_impl | |
| gr::blocks::and_const_ss | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr::blocks::and_const_ss_impl | |
| gr::blocks::and_ii | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr::blocks::and_ii_impl | |
| gr::blocks::and_ss | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr::blocks::and_ss_impl | |
| gr::blocks::annotator_1to1 | 1-to-1 stream annotator testing block. FOR TESTING PURPOSES ONLY |
| gr::blocks::annotator_1to1_impl | |
| gr::blocks::annotator_alltoall | All-to-all stream annotator testing block. FOR TESTING PURPOSES ONLY |
| gr::blocks::annotator_alltoall_impl | |
| gr::blocks::annotator_raw | Raw stream annotator testing block |
| gr::blocks::annotator_raw_impl | |
| gr::blocks::argmax_fs | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
| gr::blocks::argmax_fs_impl | |
| gr::blocks::argmax_is | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
| gr::blocks::argmax_is_impl | |
| gr::blocks::argmax_ss | Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred |
| gr::blocks::argmax_ss_impl | |
| atsc_bit_timing_loop | ATSC BitTimingLoop3This class accepts a single real input and produces two outputs, the raw symbol (float) and the tag (atsc_syminfo) |
| atsc_data_segment | 832 3 bit symbols. The low 3 bits in the byte hold the symbol |
| atsc_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 |
| atsc_depad | Depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte charinput: atsc_mpeg_packet; output: unsigned char |
| atsc_derandomizer | "dewhiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet; |
| atsc_ds_to_softds | Debug glue routine (atsc_data_segment --> atsc_soft_data_segment)input: atsc_data_segment; output: atsc_soft_data_segment |
| atsc_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 |
| atsc_field_sync_demux | ATSC Field Sync Demux |
| atsc_field_sync_mux | Insert ATSC Field Syncs as required (atsc_data_segment --> atsc_data_segment)input: atsc_data_segment; output: atsc_data_segment |
| atsc_fpll | ATSC FPLL (2nd Version)A/D --> GrFIRfilterFFF ----> GrAtscFPLL ----> |
| atsc_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 |
| atsc_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 |
| atsc_mpeg_packet | |
| atsc_mpeg_packet_no_sync | |
| atsc_mpeg_packet_rs_encoded | |
| atsc_pad | Pad mpeg ts packets from 188 byte char to to 256 byte atsc_mpeg_packetinput: unsigned char; output: atsc_mpeg_packet |
| atsc_randomizer | "Whiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet; output: atsc_mpeg_packet_no_sync |
| atsc_root_raised_cosine | |
| atsc_root_raised_cosine_bandpass | |
| atsc_rs_decoder | Reed-Solomon decoder for ATSCinput: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_no_sync |
| atsc_rs_encoder | Reed-Solomon encoder for ATSCinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet_rs_encoded |
| atsc_soft_data_segment | |
| atsc_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 |
| atsc_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 |
| atsc_vsbtx_lp | |
| atsci_basic_trellis_encoder | ATSC trellis encoder building block |
| atsci_data_deinterleaver | Atsc convolutional data deinterleaver |
| atsci_data_interleaver | Atsc convolutional data interleaver |
| atsci_equalizer | Abstract base class for ATSC equalizer |
| atsci_equalizer_lms | |
| atsci_equalizer_lms2 | |
| atsci_equalizer_nop | |
| atsci_exp2_lp | |
| atsci_fake_single_viterbi | Single channel viterbi decoder |
| atsci_fs_checker | Abstract base class for ATSC field sync checker |
| atsci_fs_checker_naive | Naive concrete implementation of field sync checker |
| atsci_fs_correlator | Abstract base class for ATSC field sync correlator |
| atsci_fs_correlator_naive | Naive concrete implementation of field sync correlator |
| atsci_interpolator | Interpolator control for segment and symbol sync recovery |
| atsci_randomizer | ATSC data "whitener" |
| atsci_reed_solomon | ATSC Reed-Solomon encoder / decoder |
| atsci_single_viterbi | Single channel viterbi decoder |
| atsci_slicer_agc | Automatic Gain Control class for atsc slicer |
| atsci_sliding_correlator | Look for the PN 511 field sync pattern |
| atsci_sssr | ATSC Segment and Symbol Sync Recovery |
| atsci_trellis_encoder | Fancy, schmancy 12-way interleaved trellis encoder for ATSC |
| atsci_viterbi_decoder | Fancy, schmancy 12-way interleaved viterbi decoder for ATSC |
| audio_alsa_sink | Audio sink using ALSAThe sink has N input streams of floats, where N depends on the hardware characteristics of the selected device |
| audio_alsa_source | Audio source using ALSAThe source has between 1 and N input streams of floats, where N is depends on the hardware characteristics of the selected device |
| audio_jack_sink | Audio sink using JACKThe sink has one input stream of floats |
| audio_jack_source | Audio source using JACKThe source has one input stream of floats |
| audio_oss_sink | Audio sink using OSSinput signature is one or two streams of floats. Input samples must be in the range [-1,1] |
| audio_oss_source | Audio source using OSSOutput signature is one or two streams of floats. Output samples will be in the range [-1,1] |
| audio_osx_sink | Audio sink using OSXinput signature is one or two streams of floats. Input samples must be in the range [-1,1] |
| audio_osx_source | Audio source using OSXInput signature is one or two streams of floats. Samples must be in the range [-1,1] |
| audio_portaudio_sink | Audio sink using PORTAUDIOInput samples must be in the range [-1,1] |
| audio_portaudio_source | Audio source using PORTAUDIOInput samples must be in the range [-1,1] |
| audio_sink | Creates a sink from an audio device |
| audio_source | Creates a source from an audio device |
| audio_windows_sink | Audio sink using winmm mmsystem (win32 only)input signature is one or two streams of floats. Input samples must be in the range [-1,1] |
| audio_windows_source | Audio source using winmm mmsystem (win32 only)Output signature is one or two streams of floats. Output samples will be in the range [-1,1] |
| gr::blocks::bin_statistics_f | Control scanning and record frequency domain statistics |
| gr::blocks::bin_statistics_f_impl | |
| bit128 | |
| gr::blocks::burst_tagger | Sets a burst on/off tag based on the value of the trigger input |
| gr::blocks::burst_tagger_impl | |
| gr::filter::channel_model | Channel simulator |
| gr::filter::channel_model_impl | |
| gr::blocks::char_to_float | Convert stream of chars to a stream of float |
| gr::blocks::char_to_float_impl | |
| gr::blocks::char_to_short | Convert stream of chars to a stream of short |
| gr::blocks::char_to_short_impl | |
| gr::blocks::check_lfsr_32k_s | Sink that checks if its input stream consists of a lfsr_32k sequence |
| gr::blocks::check_lfsr_32k_s_impl | |
| circular_buffer< T > | |
| CODEC2 | |
| comedi_sink_s | Sink using COMEDI |
| comedi_source_s | Source using COMEDI |
| COMP | |
| gr::blocks::complex_to_arg | Complex in, arg out (float) |
| gr::blocks::complex_to_arg_impl | |
| gr::blocks::complex_to_float | Convert a stream of gr_complex to 1 or 2 streams of float |
| gr::blocks::complex_to_float_impl | |
| gr::blocks::complex_to_imag | Complex in, imag out (float) |
| gr::blocks::complex_to_imag_impl | |
| gr::blocks::complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
| gr::blocks::complex_to_interleaved_short_impl | |
| gr::blocks::complex_to_mag | Complex in, magnitude out (float) |
| gr::blocks::complex_to_mag_impl | |
| gr::blocks::complex_to_mag_squared | Complex in, magnitude squared out (float) |
| gr::blocks::complex_to_mag_squared_impl | |
| gr::blocks::complex_to_real | Complex in, real out (float) |
| gr::blocks::complex_to_real_impl | |
| gr::blocks::conjugate_cc | Output = complex conjugate of input |
| gr::blocks::conjugate_cc_impl | |
| gr::blocks::control_loop | |
| convolutional_interleaver< symbol_type > | Template class for generic convolutional interleaver |
| gr::blocks::copy | Output[i] = input[i] |
| gr::blocks::copy_impl | |
| gr::analog::cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
| gr::analog::cpfsk_bc_impl | |
| gr::analog::cpm | |
| gr::analog::ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
| gr::analog::ctcss_squelch_ff_impl | |
| gr::filter::dc_blocker_cc | Computationally efficient controllable DC blocker |
| gr::filter::dc_blocker_cc_impl | |
| gr::filter::dc_blocker_ff | Computationally efficient controllable DC blocker |
| gr::filter::dc_blocker_ff_impl | |
| gr::blocks::deinterleave | Deinterleave a single input into N outputs |
| gr::blocks::deinterleave_impl | |
| gr::blocks::delay | Delay the input by a certain number of samples |
| gr::blocks::delay_impl | |
| digital_additive_scrambler_bb | |
| digital_binary_slicer_fb | Slice float binary symbol outputting 1 bit output |
| digital_bytes_to_syms | Convert stream of bytes to stream of +/- 1 symbols |
| digital_chunks_to_symbols_bc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_chunks_to_symbols_bf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_chunks_to_symbols_ic | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_chunks_to_symbols_if | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_chunks_to_symbols_sc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_chunks_to_symbols_sf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) |
| digital_clock_recovery_mm_cc | Mueller and Müller (M&M) based clock recovery block with complex input, complex output |
| digital_clock_recovery_mm_ff | Mueller and Müller (M&M) based clock recovery block with float input, float output |
| digital_cma_equalizer_cc | Implements constant modulus adaptive filter on complex stream |
| digital_constellation | An abstracted constellation objectThe constellation objects hold the necessary information to pass around constellation information for modulators and demodulators. These objects contain the mapping between the bits and the constellation points used to represent them as well as methods for slicing the symbol space. Various implementations are possible for efficiency and ease of use |
| digital_constellation_8psk | Digital constellation for 8PSK |
| digital_constellation_bpsk | Digital constellation for BPSK |
| digital_constellation_calcdist | Calculate Euclidian distance for any constellationConstellation which calculates the distance to each point in the constellation for decision making. Inefficient for large constellations |
| digital_constellation_decoder_cb | Constellation Decoder |
| digital_constellation_dqpsk | Digital constellation for DQPSK |
| digital_constellation_expl_rect | |
| digital_constellation_psk | Digital_constellation_pskConstellation space is divided into pie slices sectors |
| digital_constellation_qpsk | Digital constellation for QPSK |
| digital_constellation_receiver_cb | This block does fine-phase and frequency locking and decision making |
| digital_constellation_rect | |
| digital_constellation_sector | Sectorized digital constellationConstellation space is divided into sectors. Each sector is associated with the nearest constellation point |
| digital_correlate_access_code_bb | Examine input for specified access code, one bit at a time |
| digital_correlate_access_code_tag_bb | Examine input for specified access code, one bit at a time.input: stream of bits, 1 bit per input byte (data in LSB) output: unaltered stream of bits (plus tags) |
| sssr::digital_correlator | Digital correlator for 1001 and 0110 patterns |
| digital_costas_loop_cc | A Costas loop carrier recovery module |
| digital_cpmmod_bc | Generic CPM modulator |
| digital_crc32_bb | Byte-stream CRC block |
| digital_descrambler_bb | |
| digital_diff_decoder_bb | Y[0] = (x[0] - x[-1]) % M |
| digital_diff_encoder_bb | Y[0] = (x[0] + y[-1]) % M |
| digital_diff_phasor_cc | Differential decoding based on phase change |
| digital_fll_band_edge_cc | Frequency Lock Loop using band-edge filters |
| digital_framer_sink_1 | Given a stream of bits and access_code flags, assemble packets |
| digital_glfsr_source_b | Galois LFSR pseudo-random source |
| digital_glfsr_source_f | Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0 |
| digital_gmskmod_bc | GMSK modulator |
| digital_impl_glfsr | Galois Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
| digital_impl_mpsk_snr_est | A parent class for SNR estimators, specifically for M-PSK signals in AWGN channels |
| digital_impl_mpsk_snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
| digital_impl_mpsk_snr_est_simple | SNR Estimator using simple mean/variance estimates |
| digital_impl_mpsk_snr_est_skew | SNR Estimator using skewness correction |
| digital_impl_mpsk_snr_est_svr | Signal-to-Variation Ratio SNR Estimator |
| digital_impl_snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
| digital_kurtotic_equalizer_cc | Implements a kurtosis-based adaptive equalizer on complex stream |
| digital_lms_dd_equalizer_cc | Least-Mean-Square Decision Directed Equalizer (complex in/out) |
| digital_map_bb | Output[i] = map[input[i]] |
| digital_mpsk_receiver_cc | This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization |
| digital_mpsk_snr_est_cc | A block for computing SNR of a signal |
| digital_ofdm_carrier_allocator_cvc | Create frequency domain OFDM symbols from complex values, add pilots.This block turns a stream of complex, scalar modulation symbols into vectors which are the input for an IFFT in an OFDM transmitter. It also supports the possibility of placing pilot symbols onto the carriers |
| 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 |
| digital_ofdm_cyclic_prefixer | Adds a cyclic prefix and performs pulse shaping on OFDM symbols.Input: OFDM symbols (in the time domain, i.e. after the IFFT). Optionally, entire frames can be processed. In this case, len_tag_key must be specified which holds the key of the tag that denotes how many OFDM symbols are in a frame. Output: A stream of (scalar) complex symbols, which include the cyclic prefix and the pulse shaping. Note: If complete frames are processed, and rolloff_len is greater than zero, the final OFDM symbol is followed by the delay line of the pulse shaping |
| digital_ofdm_equalizer_1d_pilots | |
| digital_ofdm_equalizer_base | |
| digital_ofdm_equalizer_simpledfe | |
| digital_ofdm_equalizer_static | |
| digital_ofdm_frame_acquisition | Take a vector of complex constellation points in from an FFT and performs a correlation and equalization.This block takes the output of an FFT of a received OFDM symbol and finds the start of a frame based on two known symbols. It also looks at the surrounding bins in the FFT output for the correlation in case there is a large frequency shift in the data. This block assumes that the fine frequency shift has already been corrected and that the samples fall in the middle of one FFT bin |
| 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.NOTE: The mod input parameter simply chooses a pre-defined demapper/slicer. Eventually, we want to be able to pass in a reference to an object to do the demapping and slicing for a given modulation type |
| digital_ofdm_insert_preamble | Insert "pre-modulated" preamble symbols before each payload |
| 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. Abstract class must be subclassed with specific mapping |
| digital_ofdm_sampler | Does the rest of the OFDM stuff |
| digital_ofdm_sync_sc_cfb | Schmidl & Cox synchronisation for OFDM |
| digital_packet_sink | Process received bits looking for packet sync, header, and process bits into packet |
| digital_pfb_clock_sync_ccf | Timing synchronizer using polyphase filterbanks |
| digital_pfb_clock_sync_fff | Timing synchronizer using polyphase filterbanks |
| digital_pn_correlator_cc | PN code sequential search correlatorReceives complex baseband signal, outputs complex correlation against reference PN code, one sample per PN code period. The PN sequence is generated using a GLFSR |
| digital_probe_density_b | |
| digital_probe_mpsk_snr_est_c | A probe for computing SNR of a signal |
| digital_scrambler_bb | |
| digital_simple_correlator | Inverse of simple_framer (more or less) |
| digital_simple_framer | Add sync field, seq number and command field to payload |
| gr::blocks::divide_cc | Output = input_0 / input_1 / input_x ...) |
| gr::blocks::divide_cc_impl | |
| gr::blocks::divide_ff | Output = input_0 / input_1 / input_x ...) |
| gr::blocks::divide_ff_impl | |
| gr::blocks::divide_ii | Output = input_0 / input_1 / input_x ...) |
| gr::blocks::divide_ii_impl | |
| gr::blocks::divide_ss | Output = input_0 / input_1 / input_x ...) |
| gr::blocks::divide_ss_impl | |
| gr::analog::dpll_bb | Detect the peak of a signal |
| gr::analog::dpll_bb_impl | |
| gr::blocks::endian_swap | Convert stream of items into thier byte swapped version |
| gr::blocks::endian_swap_impl | |
| FCD_CAPS_STRUCT | FCD capabilities that depend on both hardware and firmware |
| fcd_source_c | Funcube Dongle source block |
| fcd_source_c_impl | |
| gr::analog::feedforward_agc_cc | Non-causal AGC which computes required gain based on max absolute value over nsamples |
| gr::analog::feedforward_agc_cc_impl | |
| gr::fft::fft_complex | FFT: complex in, complex out |
| gr::filter::kernel::fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::fft_filter_ccc_impl | |
| gr::filter::kernel::fft_filter_fff | Fast FFT filter with float input, float output and float taps |
| gr::filter::fft_filter_fff | Fast FFT filter with float input, float output and float taps |
| gr::filter::fft_filter_fff_impl | |
| gr::fft::fft_real_fwd | FFT: real in, complex out |
| gr::fft::fft_real_rev | FFT: complex in, float out |
| gr::fft::fft_vcc | Compute forward or reverse FFT. complex vector in / complex vector out |
| gr::fft::fft_vcc_fftw | |
| gr::fft::fft_vfc | Compute forward or reverse FFT. float vector in / complex vector out |
| gr::fft::fft_vfc_fftw | |
| gr::blocks::file_descriptor_sink | Write stream to file descriptor |
| gr::blocks::file_descriptor_sink_impl | |
| gr::blocks::file_descriptor_source | Read stream from file descriptor |
| gr::blocks::file_descriptor_source_impl | |
| gr::blocks::file_meta_sink | Write stream to file with meta-data headers |
| gr::blocks::file_meta_sink_impl | |
| gr::blocks::file_meta_source | Reads stream from file with meta-data headers. Headers are parsed into tags |
| gr::blocks::file_meta_source_impl | |
| gr::blocks::file_sink | Write stream to file |
| gr::blocks::file_sink_base | Common base class for file sinks |
| gr::blocks::file_sink_impl | |
| gr::blocks::file_source | Read stream from file |
| gr::blocks::file_source_impl | |
| gr::filter::filter_delay_fc | Filter-Delay Combination Block |
| gr::filter::filter_delay_fc_impl | |
| gr::filter::fir_filter_ccc | FIR filter with gr_complex input, gr_complex output, and gr_complex taps |
| gr::filter::kernel::fir_filter_ccc | |
| gr::filter::fir_filter_ccc_impl | |
| gr::filter::fir_filter_ccf | FIR filter with gr_complex input, gr_complex output, and float taps |
| gr::filter::kernel::fir_filter_ccf | |
| gr::filter::fir_filter_ccf_impl | |
| gr::filter::fir_filter_fcc | FIR filter with float input, gr_complex output, and gr_complex taps |
| gr::filter::kernel::fir_filter_fcc | |
| gr::filter::fir_filter_fcc_impl | |
| gr::filter::fir_filter_fff | FIR filter with float input, float output, and float taps |
| gr::filter::kernel::fir_filter_fff | |
| gr::filter::fir_filter_fff_impl | |
| gr::filter::fir_filter_fsf | FIR filter with float input, short output, and float taps |
| gr::filter::kernel::fir_filter_fsf | |
| gr::filter::fir_filter_fsf_impl | |
| gr::filter::fir_filter_scc | FIR filter with short input, gr_complex output, and gr_complex taps |
| gr::filter::kernel::fir_filter_scc | |
| gr::filter::fir_filter_scc_impl | |
| gr::filter::kernel::fir_filter_with_buffer_ccc | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::kernel::fir_filter_with_buffer_ccf | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::kernel::fir_filter_with_buffer_fff | FIR with internal buffer for float input, float output and float taps |
| gr::filter::firdes | Finite Impulse Response (FIR) filter design functions |
| flex_mode | |
| gr::blocks::float_to_char | Convert stream of floats to a stream of char |
| gr::blocks::float_to_char_impl | |
| gr::blocks::float_to_complex | One or two floats in, complex out |
| gr::blocks::float_to_complex_impl | |
| gr::blocks::float_to_int | Convert stream of floats to a stream of ints |
| gr::blocks::float_to_int_impl | |
| gr::blocks::float_to_short | Convert stream of floats to a stream of shorts |
| gr::blocks::float_to_short_impl | |
| gr::blocks::float_to_uchar | Convert stream of floats to a stream of unsigned chars |
| gr::blocks::float_to_uchar_impl | |
| gr::analog::fmdet_cf | Implements an IQ slope detector |
| gr::analog::fmdet_cf_impl | |
| gr::filter::fractional_interpolator_cc | Interpolating MMSE filter with complex input, complex output |
| gr::filter::fractional_interpolator_cc_impl | |
| gr::filter::fractional_interpolator_ff | Interpolating MMSE filter with float input, float output |
| gr::filter::fractional_interpolator_ff_impl | |
| gr::filter::fractional_resampler_cc | Resampling MMSE filter with complex input, complex output |
| gr::filter::fractional_resampler_cc_impl | |
| gr::filter::fractional_resampler_ff | Resampling MMSE filter with float input, float output |
| gr::filter::fractional_resampler_ff_impl | |
| gr::filter::freq_xlating_fir_filter_ccc | FIR filter combined with frequency translation with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::freq_xlating_fir_filter_ccc_impl | |
| gr::filter::freq_xlating_fir_filter_ccf | FIR filter combined with frequency translation with gr_complex input, gr_complex output and float taps |
| gr::filter::freq_xlating_fir_filter_ccf_impl | |
| gr::filter::freq_xlating_fir_filter_fcc | FIR filter combined with frequency translation with float input, gr_complex output and gr_complex taps |
| gr::filter::freq_xlating_fir_filter_fcc_impl | |
| gr::filter::freq_xlating_fir_filter_fcf | FIR filter combined with frequency translation with float input, gr_complex output and float taps |
| gr::filter::freq_xlating_fir_filter_fcf_impl | |
| gr::filter::freq_xlating_fir_filter_scc | FIR filter combined with frequency translation with short input, gr_complex output and gr_complex taps |
| gr::filter::freq_xlating_fir_filter_scc_impl | |
| gr::filter::freq_xlating_fir_filter_scf | FIR filter combined with frequency translation with short input, gr_complex output and float taps |
| gr::filter::freq_xlating_fir_filter_scf_impl | |
| gr::analog::frequency_modulator_fc | Frequency modulator block |
| gr::analog::frequency_modulator_fc_impl | |
| fsm | Finite State Machine Specification class.An instance of this class represents a finite state machine specification (FSMS) rather than the FSM itself. It particular the state of the FSM is not stored within an instance of this class |
| g72x_state | |
| gr::fft::goertzel | Implements Goertzel single-bin DFT calculation |
| gr::fft::goertzel_fc | Goertzel single-bin DFT calculation |
| gr::fft::goertzel_fc_impl | |
| gr_adaptive_fir_ccc | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
| gr_adaptive_fir_ccf | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
| gr_add_cc | Output = sum (input_0, input_1, ...)Add across all input streams |
| gr_add_const_bb | Output = input + constant |
| gr_add_const_cc | Output = input + constant |
| gr_add_const_ff | Output = input + constant |
| gr_add_const_ii | Output = input + constant |
| gr_add_const_sf | Output = input + constant |
| gr_add_const_ss | Output = input + constant |
| gr_add_const_vcc | Output vector = input vector + constant vector |
| gr_add_const_vff | Output vector = input vector + constant vector |
| gr_add_const_vii | Output vector = input vector + constant vector |
| gr_add_const_vss | Output vector = input vector + constant vector |
| gr_add_ff | Add streams of complex values |
| gr_add_ii | Output = sum (input_0, input_1, ...)Add across all input streams |
| gr_add_ss | Output = sum (input_0, input_1, ...)Add across all input streams |
| gr_additive_scrambler_bb | |
| gr_agc2_cc | High performance Automatic Gain Control class |
| gr_agc2_ff | High performance Automatic Gain Control class |
| gr_agc_cc | High performance Automatic Gain Control class |
| gr_agc_ff | High performance Automatic Gain Control class |
| gr_align_on_samplenumbers_ss | |
| gr_and_bb | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr_and_const_bb | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr_and_const_ii | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr_and_const_ss | Output_N = input_N & valuebitwise boolean and of const to the data stream |
| gr_and_ii | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr_and_ss | Output = input_0 & input_1 & , ... & input_N)bitwise boolean and across all input streams |
| gr_annotator_1to1 | 1-to-1 stream annotator testing block. FOR TESTING PURPOSES ONLY |
| gr_annotator_alltoall | All-to-all stream annotator testing block. FOR TESTING PURPOSES ONLY |
| gr_annotator_raw | Raw stream annotator testing block |
| gr_argmax_fs | |
| gr_argmax_is | |
| gr_argmax_ss | |
| gr_base_error_handler | |
| gr_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 gr_block, which implements actual signal processing functions |
| gr_bin_statistics_f | Control scanning and record frequency domain statistics |
| gr_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 |
| gr_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 |
| gr_block_executor | Manage the execution of a single block |
| gr_block_gateway | |
| gr_block_gw_message_type | |
| gr_block_registry | |
| gr_buffer | Single writer, multiple reader fifo |
| gr_buffer_reader | How we keep track of the readers of a gr_buffer |
| gr_burst_tagger | Output[i] = input[i] |
| gr_bytes_to_syms | Convert stream of bytes to stream of +/- 1 symbols |
| gr_channel_model | Channel simulator |
| gr_char_to_float | Convert stream of chars to a stream of float |
| gr_char_to_short | Convert stream of chars to a stream of float |
| gr_check_counting_s | Sink that checks if its input stream consists of a counting sequence |
| gr_check_lfsr_32k_s | Sink that checks if its input stream consists of a lfsr_32k sequence |
| gr_chunks_to_symbols_bc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of unsigned char; output: stream of gr_complex |
| gr_chunks_to_symbols_bf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of unsigned char; output: stream of float |
| gr_chunks_to_symbols_ic | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of int; output: stream of gr_complex |
| gr_chunks_to_symbols_if | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of int; output: stream of float |
| gr_chunks_to_symbols_sc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of short; output: stream of gr_complex |
| gr_chunks_to_symbols_sf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of short; output: stream of float |
| gr_circular_file | |
| gr_complex_to_arg | Complex in, angle out (float) |
| gr_complex_to_float | Convert a stream of gr_complex to 1 or 2 streams of float |
| gr_complex_to_imag | Complex in, imaginary out (float) |
| gr_complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
| gr_complex_to_mag | Complex in, magnitude out (float) |
| gr_complex_to_mag_squared | Complex in, magnitude squared out (float) |
| gr_complex_to_real | Complex in, real out (float) |
| gr_conjugate_cc | Output = complex conjugate of input |
| gr_copy | Output[i] = input[i] |
| gr_correlate_access_code_tag_bb | Examine input for specified access code, one bit at a time |
| gr_cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
| gr_cpm | |
| gr_cpu | |
| gr_ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
| gr_dc_blocker_cc | Computationally efficient controllable DC blocker |
| gr_dc_blocker_ff | Computationally efficient controllable DC blocker |
| gr_decode_ccsds_27_fb | A rate 1/2, k=7 convolutional decoder for the CCSDS standard |
| gr_deinterleave | Deinterleave a single input into N outputs |
| gr_delay | Delay the input by a certain number of samples |
| gr_descrambler_bb | |
| gr_diff_decoder_bb | Y[0] = (x[0] - x[-1]) % M |
| gr_diff_encoder_bb | Y[0] = (x[0] + y[-1]) % M |
| gr_diff_phasor_cc | |
| gr_dispatcher | Invoke callbacks based on select |
| gr_divide_cc | Output = input_0 / input_1 / input_x ...)Divide across all input streams |
| gr_divide_ff | Output = input_0 / input_1 / input_x ...)Divide across all input streams |
| gr_divide_ii | Output = input_0 / input_1 / input_x ...)Divide across all input streams |
| gr_divide_ss | Output = input_0 / input_1 / input_x ...)Divide across all input streams |
| gr_dpll_bb | Detect the peak of a signal |
| gr_edge | Class representing a connection between to graph endpoints |
| gr_encode_ccsds_27_bb | A rate 1/2, k=7 convolutional encoder for the CCSDS standard |
| gr_endian_swap | Convert stream of items into thier byte swapped version |
| gr_endpoint | Class representing a specific input or output graph endpoint |
| gr_error_handler | Abstract error handler |
| gr_fake_channel_decoder_pp | Remove fake padding from packet |
| gr_fake_channel_encoder_pp | Pad packet with alternating 1,0 pattern |
| gr_fastnoise_source_c | Random number source |
| gr_fastnoise_source_f | Random number source |
| gr_fastnoise_source_i | Random number source |
| gr_fastnoise_source_s | Random number source |
| gr_feedforward_agc_cc | Non-causal AGC which computes required gain based on max absolute value over nsamples |
| gr_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. It's slow. Don't use it in a performance critical path |
| gr_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. It's slow. Don't use it in a performance critical path |
| gr_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. It's slow. Don't use it in a performance critical path |
| gr_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. It's slow. Don't use it in a performance critical path |
| gr_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. It's slow. Don't use it in a performance critical path |
| gr_fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_fft_filter_fff | Fast FFT filter with float input, float output and float taps |
| gr_fft_vcc | Compute forward or reverse FFT. complex vector in / complex vector out |
| gr_fft_vcc_fftw | Compute forward or reverse FFT. complex vector in / complex vector out |
| gr_fft_vfc | Compute forward FFT. float vector in / complex vector out |
| gr_file_descriptor_sink | Write stream to file descriptor |
| gr_file_descriptor_source | Read stream from file descriptor |
| gr_file_error_handler | |
| gr_file_sink | Write stream to file |
| gr_file_sink_base | Common base class for file sinks |
| gr_file_source | Read stream from file |
| gr_filter_delay_fc | Filter-Delay Combination Block |
| gr_fir_ccc | Abstract class for FIR with gr_complex input, gr_complex output and gr_complex tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_ccc_3dnow | 3DNow! version of gr_fir_ccc |
| gr_fir_ccc_3dnowext | |
| gr_fir_ccc_generic | Concrete class for generic implementation of FIR with gr_complex input, gr_complex output and gr_complex taps |
| gr_fir_ccc_info | |
| gr_fir_ccc_simd | Common base class for SIMD versions of gr_fir_cccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_ccc_sse | SSE version of gr_fir_ccc |
| gr_fir_ccf | Abstract class for FIR with gr_complex input, gr_complex output and float tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_ccf_3dnow | 3DNow! version of gr_fir_ccf |
| gr_fir_ccf_armv7_a | Armv7_a using NEON coprocessor version of gr_fir_ccf |
| gr_fir_ccf_generic | Concrete class for generic implementation of FIR with gr_complex input, gr_complex output and float taps |
| gr_fir_ccf_info | |
| gr_fir_ccf_simd | Common base class for SIMD versions of gr_fir_ccfThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_ccf_sse | SSE version of gr_fir_ccf |
| gr_fir_fcc | Abstract class for FIR with float input, gr_complex output and gr_complex tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_fcc_3dnow | 3DNow! version of gr_fir_fcc |
| gr_fir_fcc_generic | Concrete class for generic implementation of FIR with float input, gr_complex output and gr_complex taps |
| gr_fir_fcc_info | |
| gr_fir_fcc_simd | Common base class for SIMD versions of gr_fir_fccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fcc_sse | SSE version of gr_fir_fcc |
| gr_fir_fff | Abstract class for FIR with float input, float output and float tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_fff_3dnow | 3DNow! version of gr_fir_fff |
| gr_fir_fff_altivec | Altivec version of gr_fir_fff |
| gr_fir_fff_armv7_a | Armv7_a using NEON coprocessor version of gr_fir_fff |
| gr_fir_fff_generic | Concrete class for generic implementation of FIR with float input, float output and float taps |
| gr_fir_fff_info | |
| gr_fir_fff_simd | Common base class for SIMD versions of gr_fir_fffThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fff_sse | SSE version of gr_fir_fff |
| gr_fir_filter_ccc | FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_fir_filter_ccf | FIR filter with gr_complex input, gr_complex output and float taps |
| gr_fir_filter_fcc | FIR filter with float input, gr_complex output and gr_complex taps |
| gr_fir_filter_fff | FIR filter with float input, float output and float taps |
| gr_fir_filter_fsf | FIR filter with float input, short output and float taps |
| gr_fir_filter_scc | FIR filter with short input, gr_complex output and gr_complex taps |
| gr_fir_fsf | Abstract class for FIR with float input, short output and float tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_fsf_3dnow | 3DNow! version of gr_fir_fsf |
| gr_fir_fsf_generic | Concrete class for generic implementation of FIR with float input, short output and float taps |
| gr_fir_fsf_info | |
| gr_fir_fsf_simd | Common base class for SIMD versions of gr_fir_fsfThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fsf_sse | SSE version of gr_fir_fsf |
| gr_fir_scc | Abstract class for FIR with short input, gr_complex output and gr_complex tapsThis is the abstract class for a Finite Impulse Response filter |
| gr_fir_scc_3dnow | 3DNow! version of gr_fir_scc |
| gr_fir_scc_3dnowext | 3DNow! Ext version of gr_fir_scc |
| gr_fir_scc_generic | Concrete class for generic implementation of FIR with short input, gr_complex output and gr_complex taps |
| gr_fir_scc_info | |
| gr_fir_scc_simd | Common base class for SIMD versions of gr_fir_sccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_scc_sse | SSE version of gr_fir_scc |
| gr_fir_sysconfig | Abstract base class for configuring the automatic selection of the fastest gr_fir for your platform |
| gr_fir_sysconfig_armv7_a | |
| gr_fir_sysconfig_generic | |
| gr_fir_sysconfig_powerpc | |
| gr_fir_sysconfig_x86 | |
| gr_fir_util | |
| gr_firdes | Finite Impulse Response (FIR) filter design functions |
| gr_flat_flowgraph | Class specializing gr_flat_flowgraph that has all nodes as gr_blocks, with no hierarchy |
| gr_float_to_char | Convert stream of float to a stream of char |
| gr_float_to_complex | Convert 1 or 2 streams of float to a stream of gr_complex |
| gr_float_to_int | Convert stream of float to a stream of short |
| gr_float_to_short | Convert stream of float to a stream of short |
| gr_float_to_uchar | Convert stream of float to a stream of unsigned char |
| gr_flowgraph | Class representing a directed, acyclic graph of basic blocks |
| gr_fmdet_cf | Implements an IQ slope detector |
| gr_fractional_interpolator_cc | Interpolating mmse filter with gr_complex input, gr_complex output |
| gr_fractional_interpolator_ff | Interpolating mmse filter with float input, float output |
| gr_framer_sink_1 | Given a stream of bits and access_code flags, assemble packets |
| gr_freq_xlating_fir_filter_ccc | FIR filter combined with frequency translation with gr_complex input, gr_complex output and gr_complex taps |
| gr_freq_xlating_fir_filter_ccf | FIR filter combined with frequency translation with gr_complex input, gr_complex output and float taps |
| gr_freq_xlating_fir_filter_fcc | FIR filter combined with frequency translation with float input, gr_complex output and gr_complex taps |
| gr_freq_xlating_fir_filter_fcf | FIR filter combined with frequency translation with float input, gr_complex output and float taps |
| gr_freq_xlating_fir_filter_scc | FIR filter combined with frequency translation with short input, gr_complex output and gr_complex taps |
| gr_freq_xlating_fir_filter_scf | FIR filter combined with frequency translation with short input, gr_complex output and float taps |
| gr_frequency_modulator_fc | Frequency modulator block |
| gr_fxpt | Fixed point sine and cosine and friends.fixed pt radians --------- -------- -2**31 -pi 0 0 2**31-1 pi - epsilon |
| gr_fxpt_nco | Numerically Controlled Oscillator (NCO) |
| gr_fxpt_vco | Voltage Controlled Oscillator (VCO) |
| gr_glfsr_source_b | Galois LFSR pseudo-random source |
| gr_glfsr_source_f | Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0 |
| gr_goertzel_fc | Goertzel single-bin DFT calculation |
| gr_head | Copies the first N items to the output then signals done |
| gr_hier_block2 | Hierarchical container class for gr_block's and gr_hier_block2's |
| gr_hier_block2_detail | |
| gr_hilbert_fc | Hilbert transformer |
| gr_histo_sink_f | Histogram module |
| gr_iir_filter_ffd | IIR filter with float input, float output and double taps |
| gr_int_to_float | Convert stream of int to a stream of float |
| gr_integrate_cc | Output = sum(input[0]...input[n])Integrate successive samples in input stream and decimate |
| gr_integrate_ff | Output = sum(input[0]...input[n])Integrate successive samples in input stream and decimate |
| gr_integrate_ii | Output = sum(input[0]...input[n])Integrate successive samples in input stream and decimate |
| gr_integrate_ss | Output = sum(input[0]...input[n])Integrate successive samples in input stream and decimate |
| gr_interleave | Interleave N inputs to a single output |
| gr_interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
| gr_interp_fir_filter_ccc | Interpolating FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_interp_fir_filter_ccf | Interpolating FIR filter with gr_complex input, gr_complex output and float taps |
| gr_interp_fir_filter_fcc | Interpolating FIR filter with float input, gr_complex output and gr_complex taps |
| gr_interp_fir_filter_fff | Interpolating FIR filter with float input, float output and float taps |
| gr_interp_fir_filter_fsf | Interpolating FIR filter with float input, short output and float taps |
| gr_interp_fir_filter_scc | Interpolating FIR filter with short input, gr_complex output and gr_complex taps |
| gr_io_signature | I/o signature for input and output ports |
| gr_iqcomp_cc | |
| gr_keep_m_in_n | Decimate a stream, keeping one item out of every n |
| gr_keep_one_in_n | Decimate a stream, keeping one item out of every n |
| gr_kludge_copy | Output[i] = input[i] |
| gr_lfsr_32k_source_s | LFSR pseudo-random source with period of 2^15 bits (2^11 shorts) |
| gr_local_sighandler | Get and set signal handler |
| gr_map_bb | Output[i] = map[input[i]] |
| gr_max_ff | |
| gr_max_ii | |
| gr_max_ss | |
| gr_message | Message class |
| gr_message_burst_source | Turn received messages into a stream and tag them for UHD to send |
| gr_message_debug | Print received messages to stdout |
| gr_message_sink | Gather received items into messages and insert into msgq |
| gr_message_source | Turn received messages into a stream |
| gr_message_strobe | Send message at defined interval |
| gr_moving_average_cc | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr_moving_average_ff | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr_moving_average_ii | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr_moving_average_ss | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr_msg_accepter | Accepts messages and inserts them into a message queue, then notifies subclass gr_basic_block there is a message pending |
| gr_msg_edge | Class representing a msg connection between to graph msg endpoints |
| gr_msg_endpoint | |
| gr_msg_handler | Abstract class of message handlers |
| gr_msg_queue | Thread-safe message queue |
| gr_multiply_cc | Multiply streams of complex values |
| gr_multiply_conjugate_cc | Multiplies a stream by the conjugate of the second stream |
| gr_multiply_const_cc | Multiply stream of complex values with a constant k |
| gr_multiply_const_ff | Multiply stream of float values with a constant k |
| gr_multiply_const_ii | Output = input * constant |
| gr_multiply_const_ss | Output = input * constant |
| gr_multiply_const_vcc | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vff | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vii | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vss | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_ff | Multiply streams of complex values |
| gr_multiply_ii | Output = prod (input_0, input_1, ...)Multiply across all input streams |
| gr_multiply_ss | Output = prod (input_0, input_1, ...)Multiply across all input streams |
| gr_mute_cc | Output = input or zero if muted |
| gr_mute_ff | Output = input or zero if muted |
| gr_mute_ii | Output = input or zero if muted |
| gr_mute_ss | Output = input or zero if muted |
| gr_nco< o_type, i_type > | Base class template for Numerically Controlled Oscillator (NCO) |
| gr_nlog10_ff | Output = n*log10(input) + k |
| gr_noise_source_c | Random number source |
| gr_noise_source_f | Random number source |
| gr_noise_source_i | Random number source |
| gr_noise_source_s | Random number source |
| gr_nop | Does nothing. Used for testing only |
| gr_not_bb | Output = ~input_0bitwise boolean not across input stream |
| gr_not_ii | Output = ~input_0bitwise boolean not across input stream |
| gr_not_ss | Output = ~input_0bitwise boolean not across input stream |
| gr_null_sink | Bit bucket |
| gr_null_source | A source of zeros |
| gr_ofdm_bpsk_demapper | Take a vector of complex constellation points in from an FFT and demodulate to a stream of bits. Simple BPSK version |
| gr_ofdm_frame_sink2 | 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 |
| gr_or_bb | Output = input_0 | input_1 | , ... | input_N)bitwise boolean or across all input streams |
| gr_or_ii | Output = input_0 | input_1 | , ... | input_N)bitwise boolean or across all input streams |
| gr_or_ss | Output = input_0 | input_1 | , ... | input_N)bitwise boolean or across all input streams |
| gr_oscope_guts | Guts of oscilloscope trigger and buffer module |
| gr_oscope_sink_f | Building block for python oscilloscope module.Accepts multiple float streams |
| gr_oscope_sink_x | Abstract class for python oscilloscope module.Don't instantiate this. Use gr_oscope_sink_f or gr_oscope_sink_c instead |
| gr_pa_2x2_phase_combiner | Pa_2x2 phase combinerAnntenas are arranged like this: |
| gr_pack_k_bits_bb | Converts a stream of bytes with 1 bit in the LSB to a byte with k relevent bits |
| gr_packed_to_unpacked_bb | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts.input: stream of unsigned char; output: stream of unsigned char |
| gr_packed_to_unpacked_ii | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts.input: stream of int; output: stream of int |
| gr_packed_to_unpacked_ss | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts.input: stream of short; output: stream of short |
| gr_packet_sink | Process received bits looking for packet sync, header, and process bits into packet |
| gr_pdu_to_tagged_stream | Turn received messages into a stream |
| gr_peak_detector2_fb | Detect the peak of a signal |
| gr_peak_detector_fb | Detect the peak of a signalIf a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_peak_detector_ib | Detect the peak of a signalIf a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_peak_detector_sb | Detect the peak of a signalIf a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
| gr_pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
| gr_pfb_channelizer_ccf | Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps |
| gr_pfb_clock_sync_ccf | Timing synchronizer using polyphase filterbanks |
| gr_pfb_clock_sync_fff | Timing synchronizer using polyphase filterbanks |
| gr_pfb_decimator_ccf | Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps |
| gr_pfb_interpolator_ccf | Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps |
| gr_pfb_synthesizer_ccf | Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps |
| gr_phase_modulator_fc | Phase modulator block output=complex(cos(in*sensitivity),sin(in*sensitivity)) |
| gr_pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier |
| gr_pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod |
| gr_pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrier |
| gr_pn_correlator_cc | PN code sequential search correlator |
| gr_preferences | |
| gr_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 |
| gr_probe_avg_mag_sqrd_c | Compute avg magnitude squared |
| gr_probe_avg_mag_sqrd_cf | Compute avg magnitude squared |
| gr_probe_avg_mag_sqrd_f | Compute avg magnitude squared |
| gr_probe_density_b | |
| gr_probe_signal_b | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_c | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_f | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_i | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_s | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_vb | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_vc | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_vf | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_vi | Sink that allows a sample to be grabbed from Python |
| gr_probe_signal_vs | Sink that allows a sample to be grabbed from Python |
| gr_pwr_squelch_cc | Gate or zero output when input power below threshold |
| gr_pwr_squelch_ff | Gate or zero output when input power below threshold |
| gr_quadrature_demod_cf | Quadrature demodulator: complex in, float out |
| gr_rail_ff | |
| gr_random | Pseudo random number generator |
| gr_random_pdu | Send message at defined interval |
| gr_rational_resampler_base_ccc | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_rational_resampler_base_ccf | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and float taps |
| gr_rational_resampler_base_fcc | Rational Resampling Polyphase FIR filter with float input, gr_complex output and gr_complex taps |
| gr_rational_resampler_base_fff | Rational Resampling Polyphase FIR filter with float input, float output and float taps |
| gr_rational_resampler_base_fsf | Rational Resampling Polyphase FIR filter with float input, short output and float taps |
| gr_rational_resampler_base_scc | Rational Resampling Polyphase FIR filter with short input, gr_complex output and gr_complex taps |
| gr_regenerate_bb | Detect the peak of a signal and repeat every period samples |
| gr_repeat | Repeat a sample 'interp' times in output stream |
| gr_rms_cf | RMS average power |
| gr_rms_ff | RMS average power |
| gr_rotator | |
| gr_sample_and_hold_bb | Sample and hold circuitSamples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ff | Sample and hold circuitSamples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ii | Sample and hold circuitSamples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ss | Sample and hold circuitSamples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_scheduler | Abstract scheduler that takes a flattened flow graph and runs it |
| gr_scheduler_sts | Concrete scheduler that uses the single_threaded_scheduler |
| gr_scheduler_tpb | Concrete scheduler that uses a kernel thread-per-block |
| gr_scrambler_bb | |
| gr_select_handler | Abstract handler for select based notification |
| gr_short_to_char | Convert stream of short to a stream of float |
| gr_short_to_float | Convert stream of short to a stream of float |
| gr_sig_source_c | Signal generator with gr_complex output |
| gr_sig_source_f | Signal generator with float output |
| gr_sig_source_i | Signal generator with int output |
| gr_sig_source_s | Signal generator with short output |
| gr_signal | Representation of signal |
| gr_simple_correlator | Inverse of gr_simple_framer (more or less) |
| gr_simple_framer | Add sync field, seq number and command field to payload |
| gr_simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
| gr_single_pole_iir< o_type, i_type, tap_type > | Class template for single pole IIR filter |
| gr_single_pole_iir< gr_complex, i_type, double > | |
| gr_single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex output |
| gr_single_pole_iir_filter_ff | Single pole IIR filter with float input, float output |
| gr_single_threaded_scheduler | Simple scheduler for stream computations |
| gr_skiphead | Skips the first N items, from then on copies items to the output |
| gr_socket_pdu | Gather received items into messages and insert into msgq |
| gr_squelch_base_cc | |
| gr_squelch_base_ff | |
| gr_stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
| gr_stream_pdu_base | Gather received items into messages and insert into msgq |
| gr_stream_to_streams | Convert a stream of items into a N streams of items |
| gr_stream_to_vector | Convert a stream of items into a stream of blocks containing nitems_per_block |
| gr_streams_to_stream | Convert N streams of 1 item into a 1 stream of N items |
| gr_streams_to_vector | Convert N streams of items to 1 stream of vector length N |
| gr_stretch_ff | |
| gr_sub_cc | Output = input_0 - input_1 - ...)Subtract across all input streams |
| gr_sub_ff | Output = input_0 - input_1 - ...)Subtract across all input streams |
| gr_sub_ii | Output = input_0 - input_1 - ...)Subtract across all input streams |
| gr_sub_ss | Output = input_0 - input_1 - ...)Subtract across all input streams |
| gr_sync_block | Synchronous 1:1 input to output with historyOverride work to provide the signal processing implementation |
| gr_sync_decimator | Synchronous N:1 input to output with historyOverride work to provide the signal processing implementation |
| gr_sync_interpolator | Synchronous 1:N input to output with historyOverride work to provide the signal processing implementation |
| gr_tag_debug | Bit bucket that prints out any tag received |
| gr_tag_t | |
| gr_tagged_file_sink | Write stream to file descriptor |
| gr_tagged_stream_block | Block that operates on PDUs in form of tagged streamsOverride work to provide the signal processing implementation |
| gr_tagged_stream_to_pdu | Turn received messages into a stream |
| gr_test | Test class for testing runtime system (setting up buffers and such.)This block does not do any usefull actual data processing. It just exposes setting all standard block parameters using the contructor or public methods |
| gr_threshold_ff | Please fix my documentation |
| gr_throttle | Throttle flow of samples such that the average rate does not exceed samples_per_sec |
| gr_timer | Implement timeouts |
| gr_top_block | Top-level hierarchical block representing a flowgraph |
| gr_top_block_impl | Abstract implementation details of gr_top_blockThe actual implementation of gr_top_block. Separate class allows decoupling of changes from dependent classes |
| gr_tpb_detail | Used by thread-per-block scheduler |
| gr_tpb_thread_body | The body of each thread-per-block thread |
| gr_transcendental | A block that performs various transcendental math operations |
| gr_tuntap_pdu | |
| gr_uchar_to_float | Convert stream of unsigned chars to a stream of float |
| gr_udp_sink | Write stream to an UDP socket |
| gr_udp_source | Read stream from an UDP socket |
| gr_unpack_k_bits_bb | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
| gr_unpacked_to_packed_bb | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.input: stream of unsigned char; output: stream of unsigned char |
| gr_unpacked_to_packed_ii | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.input: stream of int; output: stream of int |
| gr_unpacked_to_packed_ss | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.input: stream of short; output: stream of short |
| gr_vco< o_type, i_type > | Base class template for Voltage Controlled Oscillator (VCO) |
| gr_vco_f | VCO - Voltage controlled oscillatorinput: float stream of control voltages; output: float oscillator output |
| gr_vector_insert_b | Source of unsigned char's that gets its data from a vector |
| gr_vector_map | Maps elements from a set of input vectors to a set of output vectors |
| gr_vector_sink_b | Unsigned char sink that writes to a vector |
| gr_vector_sink_c | Gr_complex sink that writes to a vector |
| gr_vector_sink_f | Float sink that writes to a vector |
| gr_vector_sink_i | Int sink that writes to a vector |
| gr_vector_sink_s | Short sink that writes to a vector |
| gr_vector_source_b | Source of unsigned char's that gets its data from a vector |
| gr_vector_source_c | Source of gr_complex's that gets its data from a vector |
| gr_vector_source_f | Source of float's that gets its data from a vector |
| gr_vector_source_i | Source of int's that gets its data from a vector |
| gr_vector_source_s | Source of short's that gets its data from a vector |
| gr_vector_to_stream | Convert a stream of blocks of nitems_per_block items into a stream of items |
| gr_vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
| gr_vmcircbuf | Abstract class to implement doubly mapped virtual memory circular buffers |
| gr_vmcircbuf_createfilemapping | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_createfilemapping_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_factory | Abstract factory for creating circular buffers |
| gr_vmcircbuf_mmap_shm_open | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_mmap_shm_open_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_mmap_tmpfile | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_mmap_tmpfile_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_sysconfig | |
| gr_vmcircbuf_sysv_shm | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_sysv_shm_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_wavfile_sink | Write stream to a Microsoft PCM (.wav) file |
| gr_wavfile_source | Read stream from a Microsoft PCM (.wav) file, output floats |
| gr_xor_bb | Output = input_0 ^ input_1 ^ , ... ^ input_N)bitwise boolean xor across all input streams |
| gr_xor_ii | Output = input_0 ^ input_1 ^ , ... ^ input_N)bitwise boolean xor across all input streams |
| gr_xor_ss | Output = input_0 ^ input_1 ^ , ... ^ input_N)bitwise boolean xor across all input streams |
| gri_agc2_cc | High performance Automatic Gain Control class |
| gri_agc2_ff | High performance Automatic Gain Control class with attack and decay rate |
| gri_agc_cc | High performance Automatic Gain Control class |
| gri_agc_ff | High performance Automatic Gain Control class |
| gri_control_loop | |
| gri_fft_complex | FFT: complex in, complex out |
| gri_fft_filter_ccc_generic | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gri_fft_filter_ccc_sse | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gri_fft_filter_fff_generic | |
| gri_fft_filter_fff_sse | |
| gri_fft_planner | Export reference to planner mutex for those apps that want to use FFTW w/o using the gri_fftw* classes |
| gri_fft_real_fwd | FFT: real in, complex out |
| gri_fft_real_rev | FFT: complex in, float out |
| gri_fir_filter_with_buffer_ccc | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
| gri_fir_filter_with_buffer_ccf | FIR with internal buffer for gr_complex input, gr_complex output and float taps |
| gri_fir_filter_with_buffer_fcc | FIR with internal buffer for float input, gr_complex output and gr_complex taps |
| gri_fir_filter_with_buffer_fff | FIR with internal buffer for float input, float output and float taps |
| gri_fir_filter_with_buffer_fsf | FIR with internal buffer for float input, short output and float taps |
| gri_fir_filter_with_buffer_scc | FIR with internal buffer for short input, gr_complex output and gr_complex taps |
| gri_glfsr | Galois Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
| gri_goertzel | Implements Goertzel single-bin DFT calculation |
| gri_iir< i_type, o_type, tap_type > | Base class template for Infinite Impulse Response filter (IIR) |
| gri_lfsr | Fibonacci Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
| gri_lfsr_15_1_0 | Linear Feedback Shift Register using primitive polynomial x^15 + x + 1Generates a maximal length pseudo-random sequence of length 2^15 - 1 bits |
| gri_lfsr_32k | Generate pseudo-random sequence of length 32768 bits.This is based on gri_lfsr_15_1_0 with an extra 0 added at the end of the sequence |
| gri_mmse_fir_interpolator | Compute intermediate samples between signal samples x(k*Ts)This implements a Mininum Mean Squared Error interpolator with 8 taps. It is suitable for signals where the bandwidth of interest B = 1/(4*Ts) Where Ts is the time between samples |
| gri_mmse_fir_interpolator_cc | Compute intermediate samples between signal samples x(k*Ts)This implements a Mininum Mean Squared Error interpolator with 8 taps. It is suitable for signals where the bandwidth of interest B = 1/(4*Ts) Where Ts is the time between samples |
| gsm_state | |
| gr::blocks::head | Copies the first N items to the output then signals done |
| gr::blocks::head_impl | |
| gr::digital::header_payload_demux | Header/Payload demuxer |
| gr::digital::header_payload_demux_impl | |
| hid_device_info | |
| gr::filter::hilbert_fc | Hilbert transformer |
| gr::filter::hilbert_fc_impl | |
| i2c | Abstract class for controlling i2c bus |
| i2c_bbio | Abstract class that implements bit banging i/o for i2c bus |
| i2c_bbio_pp | Concrete class that bit bangs eval board i2c bus using parallel port |
| i2c_bitbang | Class for controlling i2c bus |
| gr::filter::kernel::iir_filter< i_type, o_type, tap_type > | Base class template for Infinite Impulse Response filter (IIR) |
| gr::filter::iir_filter_ffd | IIR filter with float input, float output and double taps |
| gr::filter::iir_filter_ffd_impl | |
| imaxdiv_t | |
| gr::blocks::int_to_float | Convert stream of ints to a stream of floats |
| gr::blocks::int_to_float_impl | |
| gr::blocks::integrate_cc | Integrate successive samples and decimate |
| gr::blocks::integrate_cc_impl | |
| gr::blocks::integrate_ff | Integrate successive samples and decimate |
| gr::blocks::integrate_ff_impl | |
| gr::blocks::integrate_ii | Integrate successive samples and decimate |
| gr::blocks::integrate_ii_impl | |
| gr::blocks::integrate_ss | Integrate successive samples and decimate |
| gr::blocks::integrate_ss_impl | |
| gr::blocks::interleave | Interleave N inputs into a single output |
| gr::blocks::interleave_impl | |
| gr::blocks::interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
| gr::blocks::interleaved_short_to_complex_impl | |
| interleaver | INTERLEAVER class |
| interleaver_fifo< symbol_type > | Template class for interleaver fifo |
| gr::filter::interp_fir_filter_ccc | Interpolating FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::interp_fir_filter_ccc_impl | |
| gr::filter::interp_fir_filter_ccf | Interpolating FIR filter with gr_complex input, gr_complex output and float taps |
| gr::filter::interp_fir_filter_ccf_impl | |
| gr::filter::interp_fir_filter_fcc | Interpolating FIR filter with float input, gr_complex output and gr_complex taps |
| gr::filter::interp_fir_filter_fcc_impl | |
| gr::filter::interp_fir_filter_fff | Interpolating FIR filter with float input, float output and float taps |
| gr::filter::interp_fir_filter_fff_impl | |
| gr::filter::interp_fir_filter_fsf | Interpolating FIR filter with float input, short output and float taps |
| gr::filter::interp_fir_filter_fsf_impl | |
| gr::filter::interp_fir_filter_scc | Interpolating FIR filter with short input, gr_complex output and gr_complex taps |
| gr::filter::interp_fir_filter_scc_impl | |
| gr::blocks::keep_m_in_n | Decimate a stream, keeping m items out of every n |
| gr::blocks::keep_m_in_n_impl | |
| gr::blocks::keep_one_in_n | Decimate a stream, keeping one item out of every n |
| gr::blocks::keep_one_in_n_impl | |
| kiss_fft_cpx | |
| kiss_fft_state | |
| gr::analog::lfsr | Fibonacci Linear Feedback Shift Register using specified polynomial mask |
| gr::blocks::lfsr_15_1_0 | Linear Feedback Shift Register using primitive polynomial x^15 + x + 1 |
| gr::blocks::lfsr_32k | Generate pseudo-random sequence of length 32768 bits |
| gr::blocks::lfsr_32k_source_s | LFSR pseudo-random source with period of 2^15 bits (2^11 shorts) |
| gr::blocks::lfsr_32k_source_s_impl | |
| lsp_codebook | |
| gr::blocks::max_ff | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
| gr::blocks::max_ff_impl | |
| gr::blocks::max_ii | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
| gr::blocks::max_ii_impl | |
| gr::blocks::max_ss | Compares vectors from multiple streams and determines the maximum value from each vector over all streams |
| gr::blocks::max_ss_impl | |
| gr::blocks::message_burst_source | Turn received messages into a stream and tag them for UHD to send |
| gr::blocks::message_burst_source_impl | |
| gr::blocks::message_debug | Debug block for the message passing system |
| gr::blocks::message_debug_impl | |
| gr::blocks::message_sink | Gather received items into messages and insert into msgq |
| gr::blocks::message_sink_impl | |
| gr::blocks::message_source | Turn received messages into a stream |
| gr::blocks::message_source_impl | |
| gr::blocks::message_strobe | Send message at defined interval |
| gr::blocks::message_strobe_impl | |
| microtune_4702 | Class for controlling microtune 4702 tuner module |
| microtune_4702_eval_board | Control microtune 4702 eval board |
| microtune_4937 | Class for controlling microtune 4937 tuner module |
| microtune_4937_eval_board | Control microtune 4937 eval board |
| microtune_xxxx | Abstract class for controlling microtune {4937,4702} tuner modules |
| microtune_xxxx_eval_board | Abstract class for controlling microtune xxxx eval board |
| gr::filter::mmse_fir_interpolator_cc | Compute intermediate samples between signal samples x(k*Ts) |
| gr::filter::mmse_fir_interpolator_ff | Compute intermediate samples between signal samples x(k*Ts) |
| MODEL | |
| gr::blocks::moving_average_cc | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr::blocks::moving_average_cc_impl | |
| gr::blocks::moving_average_ff | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr::blocks::moving_average_ff_impl | |
| gr::blocks::moving_average_ii | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr::blocks::moving_average_ii_impl | |
| gr::blocks::moving_average_ss | Output is the moving sum of the last N samples, scaled by the scale factor |
| gr::blocks::moving_average_ss_impl | |
| moving_averager_c | |
| gr::filter::moving_averager_c | |
| moving_averager_f | |
| gr::filter::moving_averager_f | |
| gruel::msg_accepter | Virtual base class that accepts messages |
| gruel::msg_accepter_msgq | Concrete class that accepts messages and inserts them into a message queue |
| gruel::msg_queue | Thread-safe message queue |
| gr::blocks::multiply_cc | Output = prod (input_0, input_1, ...) |
| gr::blocks::multiply_cc_impl | |
| gr::blocks::multiply_conjugate_cc | Multiplies stream 0 by the complex conjugate of stream 1 |
| gr::blocks::multiply_conjugate_cc_impl | |
| gr::blocks::multiply_const_cc | Output = input * complex constant |
| gr::blocks::multiply_const_cc_impl | |
| gr::blocks::multiply_const_ff | Output = input * real constant |
| gr::blocks::multiply_const_ff_impl | |
| gr::blocks::multiply_const_ii | Output = input * constant |
| gr::blocks::multiply_const_ii_impl | |
| gr::blocks::multiply_const_ss | Output = input * constant |
| gr::blocks::multiply_const_ss_impl | |
| gr::blocks::multiply_const_vcc | Output = input * constant vector (element-wise) |
| gr::blocks::multiply_const_vcc_impl | |
| gr::blocks::multiply_const_vff | Output = input * constant vector (element-wise) |
| gr::blocks::multiply_const_vff_impl | |
| gr::blocks::multiply_const_vii | Output = input * constant vector (element-wise) |
| gr::blocks::multiply_const_vii_impl | |
| gr::blocks::multiply_const_vss | Output = input * constant vector (element-wise) |
| gr::blocks::multiply_const_vss_impl | |
| gr::blocks::multiply_ff | Output = prod (input_0, input_1, ...) |
| gr::blocks::multiply_ff_impl | |
| gr::blocks::multiply_ii | Output = prod (input_0, input_1, ...) |
| gr::blocks::multiply_ii_impl | |
| gr::blocks::multiply_ss | Output = prod (input_0, input_1, ...) |
| gr::blocks::multiply_ss_impl | |
| gr::blocks::mute_cc | Output = input or zero if muted |
| gr::blocks::mute_cc_impl | |
| gr::blocks::mute_ff | Output = input or zero if muted |
| gr::blocks::mute_ff_impl | |
| gr::blocks::mute_ii | Output = input or zero if muted |
| gr::blocks::mute_ii_impl | |
| gr::blocks::mute_ss | Output = input or zero if muted |
| gr::blocks::mute_ss_impl | |
| gr::blocks::nlog10_ff | Output = n*log10(input) + k |
| gr::blocks::nlog10_ff_impl | |
| noaa_hrpt_decoder | NOAA HRPT Decoder |
| noaa_hrpt_deframer | NOAA HRPT Deframer |
| noaa_hrpt_pll_cf | |
| gr::analog::noise_source_c | Random number source |
| gr::analog::noise_source_c_impl | |
| gr::analog::noise_source_f | Random number source |
| gr::analog::noise_source_f_impl | |
| gr::analog::noise_source_i | Random number source |
| gr::analog::noise_source_i_impl | |
| gr::analog::noise_source_s | Random number source |
| gr::analog::noise_source_s_impl | |
| gr::blocks::nop | Does nothing. Used for testing only |
| gr::blocks::nop_impl | |
| gr::blocks::not_bb | Output = ~inputbitwise boolean not of input streams |
| gr::blocks::not_bb_impl | |
| gr::blocks::not_ii | Output = ~inputbitwise boolean not of input streams |
| gr::blocks::not_ii_impl | |
| gr::blocks::not_ss | Output = ~inputbitwise boolean not of input streams |
| gr::blocks::not_ss_impl | |
| gr::blocks::null_sink | Bit bucket. Use as a termination point when a sink is required and we don't want to do anything real |
| gr::blocks::null_sink_impl | |
| gr::blocks::null_source | A source of zeros used mainly for testing |
| gr::blocks::null_source_impl | |
| gr::digital::ofdm_frame_equalizer_vcvc | OFDM frame equalizerThis does two things: First, it removes the coarse carrier offset. If a tag is found on the first item with the key 'ofdm_sync_carr_offset', this is interpreted as the coarse frequency offset in number of carriers. Next, it performs equalization in one or two dimensions on a tagged OFDM frame. The actual equalization is done by a ofdm_frame_equalizer object, outside of the block |
| gr::digital::ofdm_frame_equalizer_vcvc_impl | |
| gr::digital::ofdm_serializer_vcc | Serializes complex modulations symbols from OFDM sub-carriersThis is the inverse block to the carrier_allocator_cvc. It outputs the complex data symbols as a tagged stream, discarding the pilot symbols |
| gr::digital::ofdm_serializer_vcc_impl | |
| option | |
| gr::blocks::or_bb | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
| gr::blocks::or_bb_impl | |
| gr::blocks::or_ii | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
| gr::blocks::or_ii_impl | |
| gr::blocks::or_ss | Output = input_0 | input_1 | , ... | input_N)Bitwise boolean or across all input streams |
| gr::blocks::or_ss_impl | |
| gr::blocks::pack_k_bits_bb | Converts a stream of bytes with 1 bit in the LSB to a byte with k relevent bits |
| gr::blocks::pack_k_bits_bb_impl | |
| gr::blocks::packed_to_unpacked_bb | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
| gr::blocks::packed_to_unpacked_bb_impl | |
| gr::blocks::packed_to_unpacked_ii | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
| gr::blocks::packed_to_unpacked_ii_impl | |
| gr::blocks::packed_to_unpacked_ss | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts |
| gr::blocks::packed_to_unpacked_ss_impl | |
| gr::digital::packet_header_default | Default header formatter for digital packet transmission |
| gr::digital::packet_header_ofdm | Header utility for OFDM signals |
| gr::digital::packet_headergenerator_bb | Generates a header for a tagged, streamed packet |
| gr::digital::packet_headergenerator_bb_impl | |
| gr::digital::packet_headerparser_b | Post header metadata as a PMT |
| gr::digital::packet_headerparser_b_impl | |
| pager_flex_deinterleave | Flex deinterleave description |
| pager_flex_frame | Flex_frame |
| pager_flex_parse | Flex parse description |
| pager_flex_sync | Flex sync description |
| pager_slicer_fb | Slicer description |
| gr::blocks::patterned_interleaver | Interleave items based on the provided vector pattern |
| gr::blocks::patterned_interleaver_impl | |
| gr::blocks::pdu_to_tagged_stream | Turns received PDUs into a tagged stream of items |
| gr::blocks::pdu_to_tagged_stream_impl | |
| gr::blocks::peak_detector2_fb | Detect the peak of a signal |
| gr::blocks::peak_detector2_fb_impl | |
| gr::blocks::peak_detector_fb | Detect the peak of a signal |
| gr::blocks::peak_detector_fb_impl | |
| gr::blocks::peak_detector_ib | Detect the peak of a signal |
| gr::blocks::peak_detector_ib_impl | |
| gr::blocks::peak_detector_sb | Detect the peak of a signal |
| gr::blocks::peak_detector_sb_impl | |
| gr::filter::pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
| gr::filter::pfb_arb_resampler_ccf_impl | |
| gr::filter::pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
| gr::filter::pfb_arb_resampler_fff_impl | |
| gr::filter::pfb_channelizer_ccf | Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps |
| gr::filter::pfb_channelizer_ccf_impl | |
| gr::filter::pfb_decimator_ccf | Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps |
| gr::filter::pfb_decimator_ccf_impl | |
| gr::filter::pfb_interpolator_ccf | Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps |
| gr::filter::pfb_interpolator_ccf_impl | |
| gr::filter::pfb_synthesizer_ccf | Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps |
| gr::filter::pfb_synthesizer_ccf_impl | |
| gr::analog::phase_modulator_fc | Phase modulator block |
| gr::analog::phase_modulator_fc_impl | |
| gr::fft::planner | Export reference to planner mutex for those apps that want to use FFTW w/o using the fft_impl_fftw* classes |
| gr::analog::plateau_detector_fb | Detects a plateau and marks the middle |
| gr::blocks::plateau_detector_fb | Detects a plateau and marks the middle |
| gr::blocks::plateau_detector_fb_impl | |
| gr::analog::plateau_detector_fb_impl | |
| plinfo | Pipeline info that flows with data |
| gr::analog::pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier |
| gr::analog::pll_carriertracking_cc_impl | |
| gr::analog::pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod |
| gr::analog::pll_freqdet_cf_impl | |
| gr::analog::pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrier |
| gr::analog::pll_refout_cc_impl | |
| pmt::pmt_any | |
| pmt::pmt_base | |
| pmt::pmt_bool | |
| pmt_c32vector | |
| pmt::pmt_c32vector | |
| pmt_c64vector | |
| pmt::pmt_c64vector | |
| pmt::pmt_comperator | Provide a comparator function object to allow pmt use in stl types |
| pmt::pmt_complex | |
| pmt::pmt_exception | |
| pmt_f32vector | |
| pmt::pmt_f32vector | |
| pmt_f64vector | |
| pmt::pmt_f64vector | |
| pmt::pmt_integer | |
| pmt::pmt_notimplemented | |
| pmt::pmt_null | |
| pmt::pmt_out_of_range | |
| pmt::pmt_pair | |
| pmt::pmt_pool | Very simple thread-safe fixed-size allocation pool |
| pmt::pmt_real | |
| pmt_s16vector | |
| pmt::pmt_s16vector | |
| pmt_s32vector | |
| pmt::pmt_s32vector | |
| pmt_s64vector | |
| pmt::pmt_s64vector | |
| pmt_s8vector | |
| pmt::pmt_s8vector | |
| pmt::pmt_symbol | |
| pmt::pmt_tuple | |
| pmt::pmt_u16vector | |
| pmt_u16vector | |
| pmt_u32vector | |
| pmt::pmt_u32vector | |
| pmt::pmt_u64vector | |
| pmt_u64vector | |
| pmt_u8vector | |
| pmt::pmt_u8vector | |
| pmt::pmt_uint64 | |
| pmt::pmt_uniform_vector | |
| pmt::pmt_vector | |
| pmt::pmt_wrong_type | |
| gr::filter::kernel::polyphase_filterbank | Polyphase filterbank parent class |
| ppio | Abstract class that provides low level access to parallel port bits |
| ppio_ppdev | Access to parallel port bits using the linux ppdev interface |
| gr::analog::probe_avg_mag_sqrd_c | Compute avg magnitude squared |
| gr::analog::probe_avg_mag_sqrd_c_impl | |
| gr::analog::probe_avg_mag_sqrd_cf | Compute avg magnitude squared |
| gr::analog::probe_avg_mag_sqrd_cf_impl | |
| gr::analog::probe_avg_mag_sqrd_f | Compute avg magnitude squared |
| gr::analog::probe_avg_mag_sqrd_f_impl | |
| gr::blocks::probe_rate | Throughput measurement |
| gr::blocks::probe_rate_impl | |
| gr::blocks::probe_signal_b | Sink that allows a sample to be grabbed from Python |
| gr::blocks::probe_signal_b_impl | |
| gr::blocks::probe_signal_c | Sink that allows a sample to be grabbed from Python |
| gr::blocks::probe_signal_c_impl | |
| gr::blocks::probe_signal_f | Sink that allows a sample to be grabbed from Python |
| gr::blocks::probe_signal_f_impl | |
| gr::blocks::probe_signal_i | Sink that allows a sample to be grabbed from Python |
| gr::blocks::probe_signal_i_impl | |
| gr::blocks::probe_signal_s | Sink that allows a sample to be grabbed from Python |
| gr::blocks::probe_signal_s_impl | |
| gr::blocks::probe_signal_vb | Sink that allows a vector of samples to be grabbed from Python |
| gr::blocks::probe_signal_vb_impl | |
| gr::blocks::probe_signal_vc | Sink that allows a vector of samples to be grabbed from Python |
| gr::blocks::probe_signal_vc_impl | |
| gr::blocks::probe_signal_vf | Sink that allows a vector of samples to be grabbed from Python |
| gr::blocks::probe_signal_vf_impl | |
| gr::blocks::probe_signal_vi | Sink that allows a vector of samples to be grabbed from Python |
| gr::blocks::probe_signal_vi_impl | |
| gr::blocks::probe_signal_vs | Sink that allows a vector of samples to be grabbed from Python |
| gr::blocks::probe_signal_vs_impl | |
| gr::analog::pwr_squelch_cc | Gate or zero output when input power below threshold |
| gr::analog::pwr_squelch_cc_impl | |
| gr::analog::pwr_squelch_ff | Gate or zero output when input power below threshold |
| gr::analog::pwr_squelch_ff_impl | |
| qtgui_sink_c | A graphical sink to display freq, spec, time, and const plots |
| qtgui_sink_f | A graphical sink to display freq, spec, and time |
| qtgui_time_sink_c | A graphical sink to display multiple signals in time |
| qtgui_time_sink_f | A graphical sink to display multiple signals in time |
| sssr::quad_filter | Quad filter (used to compute timing error) |
| gr::analog::quadrature_demod_cf | Quadrature demodulator: complex in, float out |
| gr::analog::quadrature_demod_cf_impl | |
| QwtDblClickPlotPicker | |
| QwtPickerDblClickPointMachine | |
| gr::analog::rail_ff | Clips input values to min, max |
| gr::analog::rail_ff_impl | |
| gr::filter::rational_resampler_base_ccc | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr::filter::rational_resampler_base_ccc_impl | |
| gr::filter::rational_resampler_base_ccf | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and float taps |
| gr::filter::rational_resampler_base_ccf_impl | |
| gr::filter::rational_resampler_base_fcc | Rational Resampling Polyphase FIR filter with float input, gr_complex output and gr_complex taps |
| gr::filter::rational_resampler_base_fcc_impl | |
| gr::filter::rational_resampler_base_fff | Rational Resampling Polyphase FIR filter with float input, float output and float taps |
| gr::filter::rational_resampler_base_fff_impl | |
| gr::filter::rational_resampler_base_fsf | Rational Resampling Polyphase FIR filter with float input, short output and float taps |
| gr::filter::rational_resampler_base_fsf_impl | |
| gr::filter::rational_resampler_base_scc | Rational Resampling Polyphase FIR filter with short input, gr_complex output and gr_complex taps |
| gr::filter::rational_resampler_base_scc_impl | |
| gr::blocks::regenerate_bb | Detect the peak of a signal and repeat every period samples |
| gr::blocks::regenerate_bb_impl | |
| gr::blocks::repack_bits_bb | Pack k bits from the input stream onto l bits of the output stream |
| gr::blocks::repack_bits_bb_impl | |
| gr::blocks::repeat | Repeat each input repeat times |
| gr::blocks::repeat_impl | |
| gr::blocks::rms_cf | RMS average power |
| gr::blocks::rms_cf_impl | RMS average power |
| gr::blocks::rms_ff | RMS average power |
| gr::blocks::rms_ff_impl | RMS average power |
| gr::blocks::rotator | |
| gr::analog::rotator | |
| rs | |
| gruel::rt_sched_param | |
| gr::blocks::sample_and_hold_bb | Sample and hold circuit |
| gr::blocks::sample_and_hold_bb_impl | |
| gr::blocks::sample_and_hold_ff | Sample and hold circuit |
| gr::blocks::sample_and_hold_ff_impl | |
| gr::blocks::sample_and_hold_ii | Sample and hold circuit |
| gr::blocks::sample_and_hold_ii_impl | |
| gr::blocks::sample_and_hold_ss | Sample and hold circuit |
| gr::blocks::sample_and_hold_ss_impl | |
| sdr_1000_base | Very low level interface to SDR 1000 xcvr hardware |
| sssr::seg_sync_integrator | Segment sync integrator |
| boost::shared_ptr< T > | Shared_ptr documentation stub |
| shd_smini_sink | |
| shd_smini_source | |
| gr::blocks::short_to_char | Convert stream of shorts to a stream of chars |
| gr::blocks::short_to_char_impl | |
| gr::blocks::short_to_float | Convert stream of shorts to a stream of floats |
| gr::blocks::short_to_float_impl | |
| gr::analog::sig_source_c | Signal generator with gr_complex output |
| gr::analog::sig_source_c_impl | |
| gr::analog::sig_source_f | Signal generator with float output |
| gr::analog::sig_source_f_impl | |
| gr::analog::sig_source_i | Signal generator with int output |
| gr::analog::sig_source_i_impl | |
| gr::analog::sig_source_s | Signal generator with short output |
| gr::analog::sig_source_s_impl | |
| gr::analog::simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
| gr::analog::simple_squelch_cc_impl | |
| gr::filter::single_pole_iir< o_type, i_type, tap_type > | Class template for single pole IIR filter |
| gr::filter::single_pole_iir< gr_complex, i_type, double > | |
| gr::filter::single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex output |
| gr::filter::single_pole_iir_filter_cc_impl | |
| gr::filter::single_pole_iir_filter_ff | Single pole IIR filter with float input, float output |
| gr::filter::single_pole_iir_filter_ff_impl | |
| gr::blocks::skiphead | Skips the first N items, from then on copies items to the output |
| gr::blocks::skiphead_impl | |
| gr::blocks::socket_pdu | Creates socket interface and translates traffic to PDUs |
| gr::blocks::socket_pdu_impl | |
| Ui::SpectrumDisplayForm | |
| gnuradio::detail::sptr_magic | |
| gr::analog::squelch_base_cc | Basic squelch block; to be subclassed for other squelches |
| gr::analog::squelch_base_cc_impl | |
| gr::analog::squelch_base_ff | Basic squelch block; to be subclassed for other squelches |
| gr::analog::squelch_base_ff_impl | |
| uhd::stream_args_t | |
| gr::blocks::stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
| gr::blocks::stream_mux_impl | |
| gr::blocks::stream_pdu_base | |
| gr::blocks::stream_to_streams | Convert a stream of items into a N streams of items |
| gr::blocks::stream_to_streams_impl | |
| gr::blocks::stream_to_vector | Convert a stream of items into a stream of blocks containing nitems_per_block |
| gr::blocks::stream_to_vector_impl | |
| gr::blocks::streams_to_stream | Convert N streams of 1 item into a 1 stream of N items |
| gr::blocks::streams_to_stream_impl | |
| gr::blocks::streams_to_vector | Convert N streams of items to 1 stream of vector length N |
| gr::blocks::streams_to_vector_impl | |
| gr::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 |
| gr::blocks::stretch_ff_impl | |
| gr::blocks::sub_cc | Output = input_0 - input_1 - ...) |
| gr::blocks::sub_cc_impl | |
| gr::blocks::sub_ff | Output = input_0 - input_1 - ...) |
| gr::blocks::sub_ff_impl | |
| gr::blocks::sub_ii | Output = input_0 - input_1 - ...) |
| gr::blocks::sub_ii_impl | |
| gr::blocks::sub_ss | Output = input_0 - input_1 - ...) |
| gr::blocks::sub_ss_impl | |
| atsc::syminfo | |
| gruel::sys_pri | |
| gr::blocks::tag_debug | Bit bucket that prints out any tag received |
| gr::blocks::tag_debug_impl | |
| gr::blocks::tag_gate | Control tag propagation.Use this block to stop tags from propagating |
| gr::blocks::tag_gate_impl | |
| tag_sink_demo | |
| tag_source_demo | |
| gr::blocks::tagged_file_sink | A file sink that uses tags to save files |
| gr::blocks::tagged_file_sink_impl | |
| gr::blocks::tagged_stream_mux | Combines tagged streams |
| gr::blocks::tagged_stream_mux_impl | |
| gr::blocks::tagged_stream_to_pdu | Turns received stream data and tags into PDUs |
| gr::blocks::tagged_stream_to_pdu_impl | |
| gr::blocks::tcp_connection | |
| tcp_connection | |
| gruel::thread_body_wrapper< F > | |
| gruel::thread_group | |
| gr::blocks::threshold_ff | Output a 1 or zero based on a threshold value |
| gr::blocks::threshold_ff_impl | |
| gr::blocks::throttle | Throttle flow of samples such that the average rate does not exceed samples_per_sec |
| gr::blocks::throttle_impl | |
| gr::blocks::transcendental | A block that performs various transcendental math operations |
| gr::blocks::transcendental_impl | |
| trellis_constellation_metrics_cf | Evaluate metrics for use by the Viterbi algorithm |
| trellis_encoder_bb | Convolutional encoder |
| trellis_encoder_bi | Convolutional encoder |
| trellis_encoder_bs | Convolutional encoder |
| trellis_encoder_ii | Convolutional encoder |
| trellis_encoder_si | Convolutional encoder |
| trellis_encoder_ss | Convolutional encoder |
| trellis_metrics_c | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_f | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_i | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_s | Evaluate metrics for use by the Viterbi algorithm |
| trellis_pccc_decoder_b | |
| trellis_pccc_decoder_combined_cb | |
| trellis_pccc_decoder_combined_ci | |
| trellis_pccc_decoder_combined_cs | |
| trellis_pccc_decoder_combined_fb | |
| trellis_pccc_decoder_combined_fi | |
| trellis_pccc_decoder_combined_fs | |
| trellis_pccc_decoder_i | |
| trellis_pccc_decoder_s | |
| trellis_pccc_encoder_bb | SCCC encoder |
| trellis_pccc_encoder_bi | SCCC encoder |
| trellis_pccc_encoder_bs | SCCC encoder |
| trellis_pccc_encoder_ii | SCCC encoder |
| trellis_pccc_encoder_si | SCCC encoder |
| trellis_pccc_encoder_ss | SCCC encoder |
| trellis_permutation | Permutation |
| trellis_sccc_decoder_b | |
| trellis_sccc_decoder_combined_cb | |
| trellis_sccc_decoder_combined_ci | |
| trellis_sccc_decoder_combined_cs | |
| trellis_sccc_decoder_combined_fb | |
| trellis_sccc_decoder_combined_fi | |
| trellis_sccc_decoder_combined_fs | |
| trellis_sccc_decoder_i | |
| trellis_sccc_decoder_s | |
| trellis_sccc_encoder_bb | SCCC encoder |
| trellis_sccc_encoder_bi | SCCC encoder |
| trellis_sccc_encoder_bs | SCCC encoder |
| trellis_sccc_encoder_ii | SCCC encoder |
| trellis_sccc_encoder_si | SCCC encoder |
| trellis_sccc_encoder_ss | SCCC encoder |
| trellis_siso_combined_f | |
| trellis_siso_f | |
| trellis_viterbi_b | |
| trellis_viterbi_combined_cb | |
| trellis_viterbi_combined_ci | |
| trellis_viterbi_combined_cs | |
| trellis_viterbi_combined_fb | |
| trellis_viterbi_combined_fi | |
| trellis_viterbi_combined_fs | |
| trellis_viterbi_combined_ib | |
| trellis_viterbi_combined_ii | |
| trellis_viterbi_combined_is | |
| trellis_viterbi_combined_sb | |
| trellis_viterbi_combined_si | |
| trellis_viterbi_combined_ss | |
| trellis_viterbi_i | |
| trellis_viterbi_s | |
| gr::blocks::tuntap_pdu | Creates TUNTAP interface and translates traffic to PDUs |
| gr::blocks::tuntap_pdu_impl | |
| gr::blocks::uchar_to_float | Convert stream of unsigned chars to a stream of floats |
| gr::blocks::uchar_to_float_impl | |
| gr::blocks::udp_sink | Write stream to an UDP socket |
| gr::blocks::udp_sink_impl | |
| gr::blocks::udp_source | Read stream from an UDP socket |
| gr::blocks::udp_source_impl | |
| uhd_amsg_source | |
| uhd_usrp_sink | |
| uhd_usrp_source | |
| Ui_SpectrumDisplayForm | |
| gr::blocks::unpack_k_bits_bb | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
| gr::blocks::unpack_k_bits_bb_impl | |
| gr::blocks::unpacked_to_packed_bb | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
| gr::blocks::unpacked_to_packed_bb_impl | |
| gr::blocks::unpacked_to_packed_ii | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
| gr::blocks::unpacked_to_packed_ii_impl | |
| gr::blocks::unpacked_to_packed_ss | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts |
| gr::blocks::unpacked_to_packed_ss_impl | |
| v_float_u | |
| gr::blocks::vco_f | VCO - Voltage controlled oscillator |
| gr::blocks::vco_f_impl | |
| std::vector< T > | Vector documentation stub |
| gr::blocks::vector_insert_b | Source of unsigned char's that gets its data from a vector |
| gr::blocks::vector_insert_b_impl | |
| gr::blocks::vector_insert_c | Source of gr_complex's that gets its data from a vector |
| gr::blocks::vector_insert_c_impl | |
| gr::blocks::vector_insert_f | Source of float's that gets its data from a vector |
| gr::blocks::vector_insert_f_impl | |
| gr::blocks::vector_insert_i | Source of int's that gets its data from a vector |
| gr::blocks::vector_insert_i_impl | |
| gr::blocks::vector_insert_s | Source of short's that gets its data from a vector |
| gr::blocks::vector_insert_s_impl | |
| gr::blocks::vector_map | Maps elements from a set of input vectors to a set of output vectors |
| gr::blocks::vector_map_impl | |
| gr::blocks::vector_sink_b | Unsigned char sink that writes to a vector |
| gr::blocks::vector_sink_b_impl | |
| gr::blocks::vector_sink_c | Gr_complex sink that writes to a vector |
| gr::blocks::vector_sink_c_impl | |
| gr::blocks::vector_sink_f | Float sink that writes to a vector |
| gr::blocks::vector_sink_f_impl | |
| gr::blocks::vector_sink_i | Int sink that writes to a vector |
| gr::blocks::vector_sink_i_impl | |
| gr::blocks::vector_sink_s | Short sink that writes to a vector |
| gr::blocks::vector_sink_s_impl | |
| gr::blocks::vector_source_b | Source of unsigned char's that gets its data from a vector |
| gr::blocks::vector_source_b_impl | |
| gr::blocks::vector_source_c | Source of gr_complex's that gets its data from a vector |
| gr::blocks::vector_source_c_impl | |
| gr::blocks::vector_source_f | Source of float's that gets its data from a vector |
| gr::blocks::vector_source_f_impl | |
| gr::blocks::vector_source_i | Source of int's that gets its data from a vector |
| gr::blocks::vector_source_i_impl | |
| gr::blocks::vector_source_s | Source of short's that gets its data from a vector |
| gr::blocks::vector_source_s_impl | |
| gr::blocks::vector_to_stream | Convert a stream of blocks of nitems_per_block items into a stream of items |
| gr::blocks::vector_to_stream_impl | |
| gr::blocks::vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
| gr::blocks::vector_to_streams_impl | |
| video_sdl_sink_s | Video sink using SDL |
| video_sdl_sink_uc | Video sink using SDL |
| viterbi_state | |
| vocoder_alaw_decode_bs | This block performs alaw audio decoding |
| vocoder_alaw_encode_sb | This block performs g.711 alaw audio encoding |
| vocoder_codec2_decode_ps | CODEC2 Vocoder Decoder |
| vocoder_codec2_encode_sp | CODEC2 Vocoder Encoder |
| 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 |
| 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 |
| vocoder_g721_decode_bs | This block performs g721 audio decoding |
| vocoder_g721_encode_sb | This block performs g721 audio encoding |
| vocoder_g723_24_decode_bs | This block performs g723_24 audio decoding |
| vocoder_g723_24_encode_sb | This block performs g723_24 audio encoding |
| vocoder_g723_40_decode_bs | This block performs g723_40 audio decoding |
| vocoder_g723_40_encode_sb | This block performs g723_40 audio encoding |
| vocoder_gsm_fr_decode_ps | GSM 06.10 Full Rate Vocoder Decoder |
| vocoder_gsm_fr_encode_sp | GSM 06.10 Full Rate Vocoder Encodershorts in; 33 byte packets out |
| vocoder_ulaw_decode_bs | This block performs ulaw audio decoding |
| vocoder_ulaw_encode_sb | This block performs g.711 ulaw audio encoding |
| volk_arch_pref | |
| VOLK_CPU | |
| volk_func_desc | |
| volk_machine | |
| wavelet_squash_ff | |
| wavelet_squash_ff_impl | |
| wavelet_wavelet_ff | Compute wavelet transform using gsl routines |
| wavelet_wavelet_ff_impl | |
| wavelet_wvps_ff | Computes the Wavelet Power Spectrum from a set of wavelet coefficients |
| wavelet_wvps_ff_impl | |
| gr::blocks::wavfile_sink | Write stream to a Microsoft PCM (.wav) file |
| gr::blocks::wavfile_sink_impl | |
| gr::blocks::wavfile_source | Read stream from a Microsoft PCM (.wav) file, output floats |
| gr::blocks::wavfile_source_impl | |
| xmm_register | |
| xmm_regs | |
| gr::blocks::xor_bb | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
| gr::blocks::xor_bb_impl | |
| gr::blocks::xor_ii | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
| gr::blocks::xor_ii_impl | |
| gr::blocks::xor_ss | Output = input_0 ^ input_1 ^ , ... ^ input_N)Bitwise boolean xor across all input streams |
| gr::blocks::xor_ss_impl | |
1.7.3