diff options
| author |   Thomas Habets <thomas@habets.se> | 2020-07-02 09:45:59 +0100 |
|---|---|---|
| committer |   Marcus Müller <marcus@hostalia.de> | 2020-07-05 21:26:32 +0200 |
| commit | d20a7732eee77f56d61e2c77db36cbbe408e2fb1 (patch) | |
| tree | 87c12c23a41916a1af77b64e8f6c4b95b02459c5 /gr-filter/lib | |
| parent | uhd: remove import from uhd (diff) | |
| download | gnuradio-d20a7732eee77f56d61e2c77db36cbbe408e2fb1.tar.xz gnuradio-d20a7732eee77f56d61e2c77db36cbbe408e2fb1.zip | |
filter: Remove manual memory management
Mostly manual work, followed by updating checksums.
Note that there were (and still remain) a lot of default copy
constructors and copy assignment operators in the codebase that are
not safe. And they're even exported to Python (some removed in this
commit).
While it's perfectly possible to allow safe copies once raw pointers
are removed, it seems like a performance trap waiting to happen. Hence
I removed the fir_filter copy cons/assignment.
Short script I used to update the header file hashes for pybind11:
```
a=polyphase_filterbank
S=$(md5sum $(find -name "${a}.h") | awk '{print $1}')
sed -i -r "s/(BINDTOOL_HEADER_FILE_HASH)[(].*[)]/\1($S)/" $(find -name "${a}_python.cc")
```
Diffstat (limited to 'gr-filter/lib')
57 files changed, 375 insertions, 474 deletions
diff --git a/gr-filter/lib/dc_blocker_cc_impl.cc b/gr-filter/lib/dc_blocker_cc_impl.cc index 25fbb2728a..0b1ffd2570 100644 --- a/gr-filter/lib/dc_blocker_cc_impl.cc +++ b/gr-filter/lib/dc_blocker_cc_impl.cc @@ -14,15 +14,19 @@ #include "dc_blocker_cc_impl.h" #include <gnuradio/io_signature.h> +#include <boost/make_unique.hpp> #include <cstdio> namespace gr { namespace filter { moving_averager_c::moving_averager_c(int D) - : d_length(D), d_out(0), d_out_d1(0), d_out_d2(0) + : d_length(D), + d_out(0), + d_out_d1(0), + d_out_d2(0), + d_delay_line(d_length - 1, gr_complex(0, 0)) { - d_delay_line = std::deque<gr_complex>(d_length - 1, gr_complex(0, 0)); } moving_averager_c::~moving_averager_c() {} @@ -52,34 +56,18 @@ dc_blocker_cc_impl::dc_blocker_cc_impl(int D, bool long_form) io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), d_length(D), - d_long_form(long_form) + d_long_form(long_form), + d_ma_0(D), + d_ma_1(D) { if (d_long_form) { - d_ma_0 = new moving_averager_c(D); - d_ma_1 = new moving_averager_c(D); - d_ma_2 = new moving_averager_c(D); - d_ma_3 = new moving_averager_c(D); + d_ma_2 = boost::make_unique<moving_averager_c>(D); + d_ma_3 = boost::make_unique<moving_averager_c>(D); d_delay_line = std::deque<gr_complex>(d_length - 1, gr_complex(0, 0)); - } else { - d_ma_0 = new moving_averager_c(D); - d_ma_1 = new moving_averager_c(D); - d_ma_2 = NULL; - d_ma_3 = NULL; } } -dc_blocker_cc_impl::~dc_blocker_cc_impl() -{ - if (d_long_form) { - delete d_ma_0; - delete d_ma_1; - delete d_ma_2; - delete d_ma_3; - } else { - delete d_ma_0; - delete d_ma_1; - } -} +dc_blocker_cc_impl::~dc_blocker_cc_impl() {} int dc_blocker_cc_impl::group_delay() { @@ -99,12 +87,12 @@ int dc_blocker_cc_impl::work(int noutput_items, if (d_long_form) { gr_complex y1, y2, y3, y4, d; for (int i = 0; i < noutput_items; i++) { - y1 = d_ma_0->filter(in[i]); - y2 = d_ma_1->filter(y1); + y1 = d_ma_0.filter(in[i]); + y2 = d_ma_1.filter(y1); y3 = d_ma_2->filter(y2); y4 = d_ma_3->filter(y3); - d_delay_line.push_back(d_ma_0->delayed_sig()); + d_delay_line.push_back(d_ma_0.delayed_sig()); d = d_delay_line[0]; d_delay_line.pop_front(); @@ -113,9 +101,9 @@ int dc_blocker_cc_impl::work(int noutput_items, } else { gr_complex y1, y2; for (int i = 0; i < noutput_items; i++) { - y1 = d_ma_0->filter(in[i]); - y2 = d_ma_1->filter(y1); - out[i] = d_ma_0->delayed_sig() - y2; + y1 = d_ma_0.filter(in[i]); + y2 = d_ma_1.filter(y1); + out[i] = d_ma_0.delayed_sig() - y2; } } diff --git a/gr-filter/lib/dc_blocker_cc_impl.h b/gr-filter/lib/dc_blocker_cc_impl.h index 3b5f5f19db..b2d772561c 100644 --- a/gr-filter/lib/dc_blocker_cc_impl.h +++ b/gr-filter/lib/dc_blocker_cc_impl.h @@ -28,7 +28,7 @@ public: gr_complex delayed_sig() { return d_out; } private: - int d_length; + const int d_length; gr_complex d_out, d_out_d1, d_out_d2; std::deque<gr_complex> d_delay_line; }; @@ -38,10 +38,10 @@ class FILTER_API dc_blocker_cc_impl : public dc_blocker_cc private: int d_length; bool d_long_form; - moving_averager_c* d_ma_0; - moving_averager_c* d_ma_1; - moving_averager_c* d_ma_2; - moving_averager_c* d_ma_3; + moving_averager_c d_ma_0; + moving_averager_c d_ma_1; + std::unique_ptr<moving_averager_c> d_ma_2; + std::unique_ptr<moving_averager_c> d_ma_3; std::deque<gr_complex> d_delay_line; public: diff --git a/gr-filter/lib/dc_blocker_ff_impl.cc b/gr-filter/lib/dc_blocker_ff_impl.cc index d83a399068..b8cd55aeaf 100644 --- a/gr-filter/lib/dc_blocker_ff_impl.cc +++ b/gr-filter/lib/dc_blocker_ff_impl.cc @@ -14,15 +14,15 @@ #include "dc_blocker_ff_impl.h" #include <gnuradio/io_signature.h> +#include <boost/make_unique.hpp> #include <cstdio> namespace gr { namespace filter { moving_averager_f::moving_averager_f(int D) - : d_length(D), d_out(0), d_out_d1(0), d_out_d2(0) + : d_length(D), d_out(0), d_out_d1(0), d_out_d2(0), d_delay_line(d_length - 1, 0) { - d_delay_line = std::deque<float>(d_length - 1, 0); } moving_averager_f::~moving_averager_f() {} @@ -51,34 +51,18 @@ dc_blocker_ff_impl::dc_blocker_ff_impl(int D, bool long_form) io_signature::make(1, 1, sizeof(float)), io_signature::make(1, 1, sizeof(float))), d_length(D), - d_long_form(long_form) + d_long_form(long_form), + d_ma_0(D), + d_ma_1(D) { if (d_long_form) { - d_ma_0 = new moving_averager_f(D); - d_ma_1 = new moving_averager_f(D); - d_ma_2 = new moving_averager_f(D); - d_ma_3 = new moving_averager_f(D); + d_ma_2 = boost::make_unique<moving_averager_f>(D); + d_ma_3 = boost::make_unique<moving_averager_f>(D); d_delay_line = std::deque<float>(d_length - 1, 0); - } else { - d_ma_0 = new moving_averager_f(D); - d_ma_1 = new moving_averager_f(D); - d_ma_2 = NULL; - d_ma_3 = NULL; } } -dc_blocker_ff_impl::~dc_blocker_ff_impl() -{ - if (d_long_form) { - delete d_ma_0; - delete d_ma_1; - delete d_ma_2; - delete d_ma_3; - } else { - delete d_ma_0; - delete d_ma_1; - } -} +dc_blocker_ff_impl::~dc_blocker_ff_impl() {} int dc_blocker_ff_impl::group_delay() { @@ -98,12 +82,12 @@ int dc_blocker_ff_impl::work(int noutput_items, if (d_long_form) { float y1, y2, y3, y4, d; for (int i = 0; i < noutput_items; i++) { - y1 = d_ma_0->filter(in[i]); - y2 = d_ma_1->filter(y1); + y1 = d_ma_0.filter(in[i]); + y2 = d_ma_1.filter(y1); y3 = d_ma_2->filter(y2); y4 = d_ma_3->filter(y3); - d_delay_line.push_back(d_ma_0->delayed_sig()); + d_delay_line.push_back(d_ma_0.delayed_sig()); d = d_delay_line[0]; d_delay_line.pop_front(); @@ -112,9 +96,9 @@ int dc_blocker_ff_impl::work(int noutput_items, } else { float y1, y2; for (int i = 0; i < noutput_items; i++) { - y1 = d_ma_0->filter(in[i]); - y2 = d_ma_1->filter(y1); - out[i] = d_ma_0->delayed_sig() - y2; + y1 = d_ma_0.filter(in[i]); + y2 = d_ma_1.filter(y1); + out[i] = d_ma_0.delayed_sig() - y2; } } diff --git a/gr-filter/lib/dc_blocker_ff_impl.h b/gr-filter/lib/dc_blocker_ff_impl.h index 2925b2f193..8192fb3f87 100644 --- a/gr-filter/lib/dc_blocker_ff_impl.h +++ b/gr-filter/lib/dc_blocker_ff_impl.h @@ -38,10 +38,10 @@ class FILTER_API dc_blocker_ff_impl : public dc_blocker_ff private: int d_length; bool d_long_form; - moving_averager_f* d_ma_0; - moving_averager_f* d_ma_1; - moving_averager_f* d_ma_2; - moving_averager_f* d_ma_3; + moving_averager_f d_ma_0; + moving_averager_f d_ma_1; + std::unique_ptr<moving_averager_f> d_ma_2; + std::unique_ptr<moving_averager_f> d_ma_3; std::deque<float> d_delay_line; public: diff --git a/gr-filter/lib/filter_delay_fc_impl.cc b/gr-filter/lib/filter_delay_fc_impl.cc index 09ddc0840b..32d317c882 100644 --- a/gr-filter/lib/filter_delay_fc_impl.cc +++ b/gr-filter/lib/filter_delay_fc_impl.cc @@ -27,20 +27,20 @@ filter_delay_fc_impl::filter_delay_fc_impl(const std::vector<float>& taps) : sync_block("filter_delay_fc", io_signature::make(1, 2, sizeof(float)), io_signature::make(1, 1, sizeof(gr_complex))), + d_taps(taps), + d_fir(1, taps), + d_delay(d_fir.ntaps() / 2), d_update(false) { - d_taps = taps; - d_fir = new kernel::fir_filter_fff(1, taps); - d_delay = d_fir->ntaps() / 2; - set_history(d_fir->ntaps()); + set_history(d_fir.ntaps()); const int alignment_multiple = volk_get_alignment() / sizeof(float); set_alignment(std::max(1, alignment_multiple)); } -filter_delay_fc_impl::~filter_delay_fc_impl() { delete d_fir; } +filter_delay_fc_impl::~filter_delay_fc_impl() {} -std::vector<float> filter_delay_fc_impl::taps() { return d_fir->taps(); } +std::vector<float> filter_delay_fc_impl::taps() { return d_fir.taps(); } void filter_delay_fc_impl::set_taps(const std::vector<float>& taps) { @@ -58,23 +58,23 @@ int filter_delay_fc_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; if (d_update) { - d_fir->set_taps(d_taps); - d_delay = d_fir->ntaps() / 2; - set_history(d_fir->ntaps()); + d_fir.set_taps(d_taps); + d_delay = d_fir.ntaps() / 2; + set_history(d_fir.ntaps()); return 0; } switch (input_items.size()) { case 1: for (int i = 0; i < noutput_items; i++) { - out[i] = gr_complex(in0[i + d_delay], d_fir->filter(&in0[i])); + out[i] = gr_complex(in0[i + d_delay], d_fir.filter(&in0[i])); } break; case 2: in1 = (float*)input_items[1]; for (int j = 0; j < noutput_items; j++) { - out[j] = gr_complex(in0[j + d_delay], d_fir->filter(&in1[j])); + out[j] = gr_complex(in0[j + d_delay], d_fir.filter(&in1[j])); } break; diff --git a/gr-filter/lib/filter_delay_fc_impl.h b/gr-filter/lib/filter_delay_fc_impl.h index f9da481ff8..ae75304298 100644 --- a/gr-filter/lib/filter_delay_fc_impl.h +++ b/gr-filter/lib/filter_delay_fc_impl.h @@ -21,9 +21,9 @@ namespace filter { class FILTER_API filter_delay_fc_impl : public filter_delay_fc { private: - unsigned int d_delay; - kernel::fir_filter_fff* d_fir; std::vector<float> d_taps; + kernel::fir_filter_fff d_fir; + unsigned int d_delay; bool d_update; public: diff --git a/gr-filter/lib/filterbank.cc b/gr-filter/lib/filterbank.cc index addfff1d2e..7e2dff5338 100644 --- a/gr-filter/lib/filterbank.cc +++ b/gr-filter/lib/filterbank.cc @@ -21,37 +21,32 @@ namespace gr { namespace filter { namespace kernel { -filterbank::filterbank(const std::vector<std::vector<float>>& taps) : d_taps(taps) +filterbank::filterbank(const std::vector<std::vector<float>>& taps) + : d_taps(taps), d_nfilts(d_taps.size()) { - d_nfilts = d_taps.size(); - d_fir_filters = std::vector<kernel::fir_filter_ccf*>(d_nfilts); if (d_nfilts == 0) { throw std::invalid_argument("The taps vector may not be empty."); } d_active.resize(d_nfilts); // Create an FIR filter for each channel and zero out the taps std::vector<float> vtaps(1, 0.0f); + d_fir_filters.reserve(d_nfilts); for (unsigned int i = 0; i < d_nfilts; i++) { - d_fir_filters[i] = new kernel::fir_filter_ccf(1, vtaps); + d_fir_filters.emplace_back(1, vtaps); } // Now, actually set the filters' taps set_taps(d_taps); } -filterbank::~filterbank() -{ - for (unsigned int i = 0; i < d_nfilts; i++) { - delete d_fir_filters[i]; - } -} +filterbank::~filterbank() {} void filterbank::set_taps(const std::vector<std::vector<float>>& taps) { - d_taps = taps; // Check that the number of filters is correct. - if (d_nfilts != d_taps.size()) { + if (d_nfilts != taps.size()) { throw std::runtime_error("The number of filters is incorrect."); } + d_taps = taps; // Check that taps contains vectors of taps, where each vector // is the same length. d_ntaps = d_taps[0].size(); @@ -70,7 +65,7 @@ void filterbank::set_taps(const std::vector<std::vector<float>>& taps) } } - d_fir_filters[i]->set_taps(d_taps[i]); + d_fir_filters[i].set_taps(d_taps[i]); } } diff --git a/gr-filter/lib/filterbank_vcvcf_impl.cc b/gr-filter/lib/filterbank_vcvcf_impl.cc index 84942eca22..db1c06db66 100644 --- a/gr-filter/lib/filterbank_vcvcf_impl.cc +++ b/gr-filter/lib/filterbank_vcvcf_impl.cc @@ -66,9 +66,7 @@ int filterbank_vcvcf_impl::general_work(int noutput_items, return 0; // history requirements may have changed. } - gr_complex* working; - - working = new gr_complex[noutput_items + d_ntaps]; + std::vector<gr_complex> working(noutput_items + d_ntaps); for (unsigned int i = 0; i < d_nfilts; i++) { // Only call the filter method on active filters. @@ -79,7 +77,7 @@ int filterbank_vcvcf_impl::general_work(int noutput_items, } for (unsigned int j = 0; j < (unsigned int)(noutput_items); j++) { unsigned int p = i + j * d_nfilts; - out[p] = d_fir_filters[i]->filter(working + j); + out[p] = d_fir_filters[i].filter(&working[j]); } } else { // Otherwise just output 0s. @@ -90,7 +88,6 @@ int filterbank_vcvcf_impl::general_work(int noutput_items, } } - delete[] working; consume_each(noutput_items); return noutput_items; } diff --git a/gr-filter/lib/fir_filter.cc b/gr-filter/lib/fir_filter.cc index 8e21cb61c5..5f5e06604c 100644 --- a/gr-filter/lib/fir_filter.cc +++ b/gr-filter/lib/fir_filter.cc @@ -20,55 +20,29 @@ namespace kernel { template <class IN_T, class OUT_T, class TAP_T> fir_filter<IN_T, OUT_T, TAP_T>::fir_filter(int decimation, const std::vector<TAP_T>& taps) + : d_output(1) { d_align = volk_get_alignment(); d_naligned = std::max((size_t)1, d_align / sizeof(IN_T)); - - d_aligned_taps = NULL; set_taps(taps); - - // Make sure the output sample is always aligned, too. - d_output = (OUT_T*)volk_malloc(1 * sizeof(OUT_T), d_align); } template <class IN_T, class OUT_T, class TAP_T> fir_filter<IN_T, OUT_T, TAP_T>::~fir_filter() { - // Free all aligned taps - if (d_aligned_taps != NULL) { - for (int i = 0; i < d_naligned; i++) { - volk_free(d_aligned_taps[i]); - } - ::free(d_aligned_taps); - d_aligned_taps = NULL; - } - - // Free output sample - volk_free(d_output); } template <class IN_T, class OUT_T, class TAP_T> void fir_filter<IN_T, OUT_T, TAP_T>::set_taps(const std::vector<TAP_T>& taps) { - // Free the taps if already allocated - if (d_aligned_taps != NULL) { - for (int i = 0; i < d_naligned; i++) { - volk_free(d_aligned_taps[i]); - } - ::free(d_aligned_taps); - d_aligned_taps = NULL; - } - d_ntaps = (int)taps.size(); d_taps = taps; std::reverse(d_taps.begin(), d_taps.end()); - // Make a set of taps at all possible arch alignments - d_aligned_taps = (TAP_T**)malloc(d_naligned * sizeof(TAP_T*)); + d_aligned_taps.clear(); + d_aligned_taps = std::vector<volk::vector<TAP_T>>( + d_naligned, volk::vector<TAP_T>((d_ntaps + d_naligned - 1), 0)); for (int i = 0; i < d_naligned; i++) { - d_aligned_taps[i] = - (TAP_T*)volk_malloc((d_ntaps + d_naligned - 1) * sizeof(TAP_T), d_align); - std::fill_n(d_aligned_taps[i], d_ntaps + d_naligned - 1, 0); for (unsigned int j = 0; j < d_ntaps; j++) d_aligned_taps[i][i + j] = d_taps[j]; } @@ -121,67 +95,84 @@ void fir_filter<IN_T, OUT_T, TAP_T>::filterNdec(OUT_T output[], } template <> -float fir_filter<float, float, float>::filter(const float input[]) +float fir_filter<float, float, float>::filter(const float input[]) const { const float* ar = (float*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_32f_x2_dot_prod_32f_a(d_output, ar, d_aligned_taps[al], d_ntaps + al); - return *d_output; + volk_32f_x2_dot_prod_32f_a( + const_cast<float*>(d_output.data()), ar, d_aligned_taps[al].data(), d_ntaps + al); + return d_output[0]; } template <> -gr_complex fir_filter<gr_complex, gr_complex, float>::filter(const gr_complex input[]) +gr_complex +fir_filter<gr_complex, gr_complex, float>::filter(const gr_complex input[]) const { const gr_complex* ar = (gr_complex*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_32fc_32f_dot_prod_32fc_a(d_output, ar, d_aligned_taps[al], (d_ntaps + al)); - return *d_output; + volk_32fc_32f_dot_prod_32fc_a(const_cast<gr_complex*>(d_output.data()), + ar, + d_aligned_taps[al].data(), + (d_ntaps + al)); + return d_output[0]; } template <> -gr_complex fir_filter<float, gr_complex, gr_complex>::filter(const float input[]) +gr_complex fir_filter<float, gr_complex, gr_complex>::filter(const float input[]) const { const float* ar = (float*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_32fc_32f_dot_prod_32fc_a(d_output, d_aligned_taps[al], ar, (d_ntaps + al)); - return *d_output; + volk_32fc_32f_dot_prod_32fc_a(const_cast<gr_complex*>(d_output.data()), + d_aligned_taps[al].data(), + ar, + (d_ntaps + al)); + return d_output[0]; } template <> gr_complex -fir_filter<gr_complex, gr_complex, gr_complex>::filter(const gr_complex input[]) +fir_filter<gr_complex, gr_complex, gr_complex>::filter(const gr_complex input[]) const { const gr_complex* ar = (gr_complex*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_32fc_x2_dot_prod_32fc_a(d_output, ar, d_aligned_taps[al], (d_ntaps + al)); - return *d_output; + volk_32fc_x2_dot_prod_32fc_a(const_cast<gr_complex*>(d_output.data()), + ar, + d_aligned_taps[al].data(), + (d_ntaps + al)); + return d_output[0]; } template <> gr_complex -fir_filter<std::int16_t, gr_complex, gr_complex>::filter(const std::int16_t input[]) +fir_filter<std::int16_t, gr_complex, gr_complex>::filter(const std::int16_t input[]) const { const std::int16_t* ar = (std::int16_t*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_16i_32fc_dot_prod_32fc_a(d_output, ar, d_aligned_taps[al], (d_ntaps + al)); + volk_16i_32fc_dot_prod_32fc_a(const_cast<gr_complex*>(d_output.data()), + ar, + d_aligned_taps[al].data(), + (d_ntaps + al)); - return *d_output; + return d_output[0]; } template <> -short fir_filter<float, std::int16_t, float>::filter(const float input[]) +short fir_filter<float, std::int16_t, float>::filter(const float input[]) const { const float* ar = (float*)((size_t)input & ~(d_align - 1)); unsigned al = input - ar; - volk_32f_x2_dot_prod_16i_a(d_output, ar, d_aligned_taps[al], (d_ntaps + al)); + volk_32f_x2_dot_prod_16i_a(const_cast<std::int16_t*>(d_output.data()), + ar, + d_aligned_taps[al].data(), + (d_ntaps + al)); - return *d_output; + return d_output[0]; } template class fir_filter<float, float, float>; template class fir_filter<gr_complex, gr_complex, float>; diff --git a/gr-filter/lib/fir_filter_blk_impl.cc b/gr-filter/lib/fir_filter_blk_impl.cc index e0fae714ff..da41d46b0f 100644 --- a/gr-filter/lib/fir_filter_blk_impl.cc +++ b/gr-filter/lib/fir_filter_blk_impl.cc @@ -34,11 +34,11 @@ fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::fir_filter_blk_impl( : sync_decimator("fir_filter_blk<IN_T,OUT_T,TAP_T>", io_signature::make(1, 1, sizeof(IN_T)), io_signature::make(1, 1, sizeof(OUT_T)), - decimation) + decimation), + d_fir(decimation, taps), + d_updated(false) { - d_fir = new kernel::fir_filter<IN_T, OUT_T, TAP_T>(decimation, taps); - d_updated = false; - this->set_history(d_fir->ntaps()); + this->set_history(d_fir.ntaps()); const int alignment_multiple = volk_get_alignment() / sizeof(float); this->set_alignment(std::max(1, alignment_multiple)); @@ -47,21 +47,20 @@ fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::fir_filter_blk_impl( template <class IN_T, class OUT_T, class TAP_T> fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::~fir_filter_blk_impl() { - delete d_fir; } template <class IN_T, class OUT_T, class TAP_T> void fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::set_taps(const std::vector<TAP_T>& taps) { gr::thread::scoped_lock l(this->d_setlock); - d_fir->set_taps(taps); + d_fir.set_taps(taps); d_updated = true; } template <class IN_T, class OUT_T, class TAP_T> std::vector<TAP_T> fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::taps() const { - return d_fir->taps(); + return d_fir.taps(); } template <class IN_T, class OUT_T, class TAP_T> @@ -75,15 +74,15 @@ int fir_filter_blk_impl<IN_T, OUT_T, TAP_T>::work(int noutput_items, OUT_T* out = (OUT_T*)output_items[0]; if (d_updated) { - this->set_history(d_fir->ntaps()); + this->set_history(d_fir.ntaps()); d_updated = false; return 0; // history requirements may have changed. } if (this->decimation() == 1) { - d_fir->filterN(out, in, noutput_items); + d_fir.filterN(out, in, noutput_items); } else { - d_fir->filterNdec(out, in, noutput_items, this->decimation()); + d_fir.filterNdec(out, in, noutput_items, this->decimation()); } return noutput_items; diff --git a/gr-filter/lib/fir_filter_blk_impl.h b/gr-filter/lib/fir_filter_blk_impl.h index 764ae54641..94d414f171 100644 --- a/gr-filter/lib/fir_filter_blk_impl.h +++ b/gr-filter/lib/fir_filter_blk_impl.h @@ -21,7 +21,7 @@ template <class IN_T, class OUT_T, class TAP_T> class FILTER_API fir_filter_blk_impl : public fir_filter_blk<IN_T, OUT_T, TAP_T> { private: - kernel::fir_filter<IN_T, OUT_T, TAP_T>* d_fir; + kernel::fir_filter<IN_T, OUT_T, TAP_T> d_fir; bool d_updated; public: diff --git a/gr-filter/lib/freq_xlating_fir_filter_impl.cc b/gr-filter/lib/freq_xlating_fir_filter_impl.cc index 6bf9937f4e..dfbfb319d0 100644 --- a/gr-filter/lib/freq_xlating_fir_filter_impl.cc +++ b/gr-filter/lib/freq_xlating_fir_filter_impl.cc @@ -43,15 +43,12 @@ freq_xlating_fir_filter_impl<IN_T, OUT_T, TAP_T>::freq_xlating_fir_filter_impl( io_signature::make(1, 1, sizeof(OUT_T)), decimation), d_proto_taps(taps), + d_composite_fir(decimation, {}), d_center_freq(center_freq), d_sampling_freq(sampling_freq), d_updated(false), d_decim(decimation) { - std::vector<gr_complex> dummy_taps; - d_composite_fir = - new kernel::fir_filter<IN_T, OUT_T, gr_complex>(decimation, dummy_taps); - this->set_history(this->d_proto_taps.size()); this->build_composite_fir(); @@ -63,7 +60,6 @@ freq_xlating_fir_filter_impl<IN_T, OUT_T, TAP_T>::freq_xlating_fir_filter_impl( template <class IN_T, class OUT_T, class TAP_T> freq_xlating_fir_filter_impl<IN_T, OUT_T, TAP_T>::~freq_xlating_fir_filter_impl() { - delete d_composite_fir; } template <class IN_T, class OUT_T, class TAP_T> @@ -84,7 +80,7 @@ void freq_xlating_fir_filter_impl<IN_T, OUT_T, TAP_T>::build_composite_fir() ctaps[i] = d_proto_taps[i] * exp(gr_complex(0, i * fwT0)); } - d_composite_fir->set_taps(ctaps); + d_composite_fir.set_taps(ctaps); d_r.set_phase_incr(exp(gr_complex(0, -fwT0 * this->decimation()))); } @@ -160,7 +156,7 @@ int freq_xlating_fir_filter_impl<IN_T, OUT_T, TAP_T>::work( unsigned j = 0; for (int i = 0; i < noutput_items; i++) { - out[i] = d_composite_fir->filter(&in[j]); + out[i] = d_composite_fir.filter(&in[j]); j += d_decim; } diff --git a/gr-filter/lib/freq_xlating_fir_filter_impl.h b/gr-filter/lib/freq_xlating_fir_filter_impl.h index e0bc2a5462..e355ad6341 100644 --- a/gr-filter/lib/freq_xlating_fir_filter_impl.h +++ b/gr-filter/lib/freq_xlating_fir_filter_impl.h @@ -25,7 +25,7 @@ class FILTER_API freq_xlating_fir_filter_impl { protected: std::vector<TAP_T> d_proto_taps; - kernel::fir_filter<IN_T, OUT_T, gr_complex>* d_composite_fir; + kernel::fir_filter<IN_T, OUT_T, gr_complex> d_composite_fir; blocks::rotator d_r; double d_center_freq; double d_sampling_freq; diff --git a/gr-filter/lib/hilbert_fc_impl.cc b/gr-filter/lib/hilbert_fc_impl.cc index 4f1386157c..73e4b2e51f 100644 --- a/gr-filter/lib/hilbert_fc_impl.cc +++ b/gr-filter/lib/hilbert_fc_impl.cc @@ -29,16 +29,16 @@ hilbert_fc_impl::hilbert_fc_impl(unsigned int ntaps, firdes::win_type window, do : sync_block("hilbert_fc", io_signature::make(1, 1, sizeof(float)), io_signature::make(1, 1, sizeof(gr_complex))), - d_ntaps(ntaps | 0x1) // ensure ntaps is odd + d_ntaps(ntaps | 0x1), // ensure ntaps is odd + d_hilb(1, firdes::hilbert(d_ntaps, window, beta)) { - d_hilb = new kernel::fir_filter_fff(1, firdes::hilbert(d_ntaps, window, beta)); set_history(d_ntaps); const int alignment_multiple = volk_get_alignment() / sizeof(float); set_alignment(std::max(1, alignment_multiple)); } -hilbert_fc_impl::~hilbert_fc_impl() { delete d_hilb; } +hilbert_fc_impl::~hilbert_fc_impl() {} int hilbert_fc_impl::work(int noutput_items, gr_vector_const_void_star& input_items, @@ -48,7 +48,7 @@ int hilbert_fc_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; for (int i = 0; i < noutput_items; i++) { - out[i] = gr_complex(in[i + d_ntaps / 2], d_hilb->filter(&in[i])); + out[i] = gr_complex(in[i + d_ntaps / 2], d_hilb.filter(&in[i])); } return noutput_items; diff --git a/gr-filter/lib/hilbert_fc_impl.h b/gr-filter/lib/hilbert_fc_impl.h index 47a93ce583..80adc982f8 100644 --- a/gr-filter/lib/hilbert_fc_impl.h +++ b/gr-filter/lib/hilbert_fc_impl.h @@ -22,7 +22,7 @@ class FILTER_API hilbert_fc_impl : public hilbert_fc { private: unsigned int d_ntaps; - kernel::fir_filter_fff* d_hilb; + kernel::fir_filter_fff d_hilb; public: hilbert_fc_impl(unsigned int ntaps, diff --git a/gr-filter/lib/iir_filter_ccc_impl.cc b/gr-filter/lib/iir_filter_ccc_impl.cc index 457483a9c2..204b782d96 100644 --- a/gr-filter/lib/iir_filter_ccc_impl.cc +++ b/gr-filter/lib/iir_filter_ccc_impl.cc @@ -32,13 +32,12 @@ iir_filter_ccc_impl::iir_filter_ccc_impl(const std::vector<gr_complex>& fftaps, : sync_block("iir_filter_ccc", io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), - d_updated(false) + d_updated(false), + d_iir(fftaps, fbtaps, oldstyle) { - d_iir = new kernel::iir_filter<gr_complex, gr_complex, gr_complex, gr_complex>( - fftaps, fbtaps, oldstyle); } -iir_filter_ccc_impl::~iir_filter_ccc_impl() { delete d_iir; } +iir_filter_ccc_impl::~iir_filter_ccc_impl() {} void iir_filter_ccc_impl::set_taps(const std::vector<gr_complex>& fftaps, const std::vector<gr_complex>& fbtaps) @@ -56,11 +55,11 @@ int iir_filter_ccc_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; if (d_updated) { - d_iir->set_taps(d_new_fftaps, d_new_fbtaps); + d_iir.set_taps(d_new_fftaps, d_new_fbtaps); d_updated = false; } - d_iir->filter_n(out, in, noutput_items); + d_iir.filter_n(out, in, noutput_items); return noutput_items; }; diff --git a/gr-filter/lib/iir_filter_ccc_impl.h b/gr-filter/lib/iir_filter_ccc_impl.h index 658cb4068f..1316b5bf53 100644 --- a/gr-filter/lib/iir_filter_ccc_impl.h +++ b/gr-filter/lib/iir_filter_ccc_impl.h @@ -21,7 +21,7 @@ class FILTER_API iir_filter_ccc_impl : public iir_filter_ccc { private: bool d_updated; - kernel::iir_filter<gr_complex, gr_complex, gr_complex, gr_complex>* d_iir; + kernel::iir_filter<gr_complex, gr_complex, gr_complex, gr_complex> d_iir; std::vector<gr_complex> d_new_fftaps; std::vector<gr_complex> d_new_fbtaps; diff --git a/gr-filter/lib/iir_filter_ccd_impl.cc b/gr-filter/lib/iir_filter_ccd_impl.cc index c708f49df7..30b6211a9a 100644 --- a/gr-filter/lib/iir_filter_ccd_impl.cc +++ b/gr-filter/lib/iir_filter_ccd_impl.cc @@ -32,13 +32,12 @@ iir_filter_ccd_impl::iir_filter_ccd_impl(const std::vector<double>& fftaps, : sync_block("iir_filter_ccd", io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), - d_updated(false) + d_updated(false), + d_iir(fftaps, fbtaps, oldstyle) { - d_iir = new kernel::iir_filter<gr_complex, gr_complex, double, gr_complexd>( - fftaps, fbtaps, oldstyle); } -iir_filter_ccd_impl::~iir_filter_ccd_impl() { delete d_iir; } +iir_filter_ccd_impl::~iir_filter_ccd_impl() {} void iir_filter_ccd_impl::set_taps(const std::vector<double>& fftaps, const std::vector<double>& fbtaps) @@ -56,11 +55,11 @@ int iir_filter_ccd_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; if (d_updated) { - d_iir->set_taps(d_new_fftaps, d_new_fbtaps); + d_iir.set_taps(d_new_fftaps, d_new_fbtaps); d_updated = false; } - d_iir->filter_n(out, in, noutput_items); + d_iir.filter_n(out, in, noutput_items); return noutput_items; }; diff --git a/gr-filter/lib/iir_filter_ccd_impl.h b/gr-filter/lib/iir_filter_ccd_impl.h index d3ced26fec..cdbc210d72 100644 --- a/gr-filter/lib/iir_filter_ccd_impl.h +++ b/gr-filter/lib/iir_filter_ccd_impl.h @@ -21,7 +21,7 @@ class FILTER_API iir_filter_ccd_impl : public iir_filter_ccd { private: bool d_updated; - kernel::iir_filter<gr_complex, gr_complex, double, gr_complexd>* d_iir; + kernel::iir_filter<gr_complex, gr_complex, double, gr_complexd> d_iir; std::vector<double> d_new_fftaps; std::vector<double> d_new_fbtaps; diff --git a/gr-filter/lib/iir_filter_ccf_impl.cc b/gr-filter/lib/iir_filter_ccf_impl.cc index 9fba72618c..d3125148c7 100644 --- a/gr-filter/lib/iir_filter_ccf_impl.cc +++ b/gr-filter/lib/iir_filter_ccf_impl.cc @@ -32,13 +32,12 @@ iir_filter_ccf_impl::iir_filter_ccf_impl(const std::vector<float>& fftaps, : sync_block("iir_filter_ccf", io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), - d_updated(false) + d_updated(false), + d_iir(fftaps, fbtaps, oldstyle) { - d_iir = new kernel::iir_filter<gr_complex, gr_complex, float, gr_complex>( - fftaps, fbtaps, oldstyle); } -iir_filter_ccf_impl::~iir_filter_ccf_impl() { delete d_iir; } +iir_filter_ccf_impl::~iir_filter_ccf_impl() {} void iir_filter_ccf_impl::set_taps(const std::vector<float>& fftaps, const std::vector<float>& fbtaps) @@ -56,11 +55,11 @@ int iir_filter_ccf_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; if (d_updated) { - d_iir->set_taps(d_new_fftaps, d_new_fbtaps); + d_iir.set_taps(d_new_fftaps, d_new_fbtaps); d_updated = false; } - d_iir->filter_n(out, in, noutput_items); + d_iir.filter_n(out, in, noutput_items); return noutput_items; }; diff --git a/gr-filter/lib/iir_filter_ccf_impl.h b/gr-filter/lib/iir_filter_ccf_impl.h index 43feab52a0..b60a329d49 100644 --- a/gr-filter/lib/iir_filter_ccf_impl.h +++ b/gr-filter/lib/iir_filter_ccf_impl.h @@ -21,7 +21,7 @@ class FILTER_API iir_filter_ccf_impl : public iir_filter_ccf { private: bool d_updated; - kernel::iir_filter<gr_complex, gr_complex, float, gr_complex>* d_iir; + kernel::iir_filter<gr_complex, gr_complex, float, gr_complex> d_iir; std::vector<float> d_new_fftaps; std::vector<float> d_new_fbtaps; diff --git a/gr-filter/lib/iir_filter_ccz_impl.cc b/gr-filter/lib/iir_filter_ccz_impl.cc index e0c5e1ec1e..9423990822 100644 --- a/gr-filter/lib/iir_filter_ccz_impl.cc +++ b/gr-filter/lib/iir_filter_ccz_impl.cc @@ -32,13 +32,12 @@ iir_filter_ccz_impl::iir_filter_ccz_impl(const std::vector<gr_complexd>& fftaps, : sync_block("iir_filter_ccz", io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), - d_updated(false) + d_updated(false), + d_iir(fftaps, fbtaps, oldstyle) { - d_iir = new kernel::iir_filter<gr_complex, gr_complex, gr_complexd, gr_complexd>( - fftaps, fbtaps, oldstyle); } -iir_filter_ccz_impl::~iir_filter_ccz_impl() { delete d_iir; } +iir_filter_ccz_impl::~iir_filter_ccz_impl() {} void iir_filter_ccz_impl::set_taps(const std::vector<gr_complexd>& fftaps, const std::vector<gr_complexd>& fbtaps) @@ -56,11 +55,11 @@ int iir_filter_ccz_impl::work(int noutput_items, gr_complex* out = (gr_complex*)output_items[0]; if (d_updated) { - d_iir->set_taps(d_new_fftaps, d_new_fbtaps); + d_iir.set_taps(d_new_fftaps, d_new_fbtaps); d_updated = false; } - d_iir->filter_n(out, in, noutput_items); + d_iir.filter_n(out, in, noutput_items); return noutput_items; }; diff --git a/gr-filter/lib/iir_filter_ccz_impl.h b/gr-filter/lib/iir_filter_ccz_impl.h index 8d4525b188..2180c0ece4 100644 --- a/gr-filter/lib/iir_filter_ccz_impl.h +++ b/gr-filter/lib/iir_filter_ccz_impl.h @@ -21,7 +21,7 @@ class FILTER_API iir_filter_ccz_impl : public iir_filter_ccz { private: bool d_updated; - kernel::iir_filter<gr_complex, gr_complex, gr_complexd, gr_complexd>* d_iir; + kernel::iir_filter<gr_complex, gr_complex, gr_complexd, gr_complexd> d_iir; std::vector<gr_complexd> d_new_fftaps; std::vector<gr_complexd> d_new_fbtaps; diff --git a/gr-filter/lib/iir_filter_ffd_impl.cc b/gr-filter/lib/iir_filter_ffd_impl.cc index dcfb564a46..99d8eb8c76 100644 --- a/gr-filter/lib/iir_filter_ffd_impl.cc +++ b/gr-filter/lib/iir_filter_ffd_impl.cc @@ -32,13 +32,12 @@ iir_filter_ffd_impl::iir_filter_ffd_impl(const std::vector<double>& fftaps, : sync_block("iir_filter_ffd", io_signature::make(1, 1, sizeof(float)), io_signature::make(1, 1, sizeof(float))), - d_updated(false) + d_updated(false), + d_iir(fftaps, fbtaps, oldstyle) { - d_iir = - new kernel::iir_filter<float, float, double, double>(fftaps, fbtaps, oldstyle); } -iir_filter_ffd_impl::~iir_filter_ffd_impl() { delete d_iir; } +iir_filter_ffd_impl::~iir_filter_ffd_impl() {} void iir_filter_ffd_impl::set_taps(const std::vector<double>& fftaps, const std::vector<double>& fbtaps) @@ -56,11 +55,11 @@ int iir_filter_ffd_impl::work(int noutput_items, float* out = (float*)output_items[0]; if (d_updated) { - d_iir->set_taps(d_new_fftaps, d_new_fbtaps); + d_iir.set_taps(d_new_fftaps, d_new_fbtaps); d_updated = false; } - d_iir->filter_n(out, in, noutput_items); + d_iir.filter_n(out, in, noutput_items); return noutput_items; } diff --git a/gr-filter/lib/iir_filter_ffd_impl.h b/gr-filter/lib/iir_filter_ffd_impl.h index 36aa0fe66a..ff67ebbd4b 100644 --- a/gr-filter/lib/iir_filter_ffd_impl.h +++ b/gr-filter/lib/iir_filter_ffd_impl.h @@ -21,7 +21,7 @@ class FILTER_API iir_filter_ffd_impl : public iir_filter_ffd { private: bool d_updated; - kernel::iir_filter<float, float, double, double>* d_iir; + kernel::iir_filter<float, float, double, double> d_iir; std::vector<double> d_new_fftaps; std::vector<double> d_new_fbtaps; diff --git a/gr-filter/lib/interp_fir_filter_impl.cc b/gr-filter/lib/interp_fir_filter_impl.cc index 85efa9a801..9a54ab3667 100644 --- a/gr-filter/lib/interp_fir_filter_impl.cc +++ b/gr-filter/lib/interp_fir_filter_impl.cc @@ -36,8 +36,7 @@ interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::interp_fir_filter_impl( io_signature::make(1, 1, sizeof(IN_T)), io_signature::make(1, 1, sizeof(OUT_T)), interpolation), - d_updated(false), - d_firs(interpolation) + d_updated(false) { if (interpolation == 0) { throw std::out_of_range("interp_fir_filter_impl: interpolation must be > 0"); @@ -49,8 +48,9 @@ interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::interp_fir_filter_impl( std::vector<TAP_T> dummy_taps; + d_firs.reserve(interpolation); for (unsigned i = 0; i < interpolation; i++) { - d_firs[i] = new kernel::fir_filter<IN_T, OUT_T, TAP_T>(1, dummy_taps); + d_firs.emplace_back(1, dummy_taps); } set_taps(taps); @@ -60,9 +60,6 @@ interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::interp_fir_filter_impl( template <class IN_T, class OUT_T, class TAP_T> interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::~interp_fir_filter_impl() { - for (unsigned i = 0; i < this->interpolation(); i++) { - delete d_firs[i]; - } } template <class IN_T, class OUT_T, class TAP_T> @@ -104,7 +101,7 @@ void interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::install_taps( } for (unsigned n = 0; n < nfilters; n++) { - d_firs[n]->set_taps(xtaps[n]); + d_firs[n].set_taps(xtaps[n]); } this->set_history(nt); @@ -136,7 +133,7 @@ int interp_fir_filter_impl<IN_T, OUT_T, TAP_T>::work( for (int i = 0; i < ni; i++) { for (int nf = 0; nf < nfilters; nf++) { - out[nf] = d_firs[nf]->filter(&in[i]); + out[nf] = d_firs[nf].filter(&in[i]); } out += nfilters; } diff --git a/gr-filter/lib/interp_fir_filter_impl.h b/gr-filter/lib/interp_fir_filter_impl.h index 618ae67d01..cbf3a3ef30 100644 --- a/gr-filter/lib/interp_fir_filter_impl.h +++ b/gr-filter/lib/interp_fir_filter_impl.h @@ -24,7 +24,7 @@ class FILTER_API interp_fir_filter_impl : public interp_fir_filter<IN_T, OUT_T, { private: bool d_updated; - std::vector<kernel::fir_filter<IN_T, OUT_T, TAP_T>*> d_firs; + std::vector<kernel::fir_filter<IN_T, OUT_T, TAP_T>> d_firs; std::vector<TAP_T> d_new_taps; void install_taps(const std::vector<TAP_T>& taps); diff --git a/gr-filter/lib/mmse_fir_interpolator_cc.cc b/gr-filter/lib/mmse_fir_interpolator_cc.cc index 8006599622..f81b452988 100644 --- a/gr-filter/lib/mmse_fir_interpolator_cc.cc +++ b/gr-filter/lib/mmse_fir_interpolator_cc.cc @@ -19,21 +19,22 @@ namespace gr { namespace filter { -mmse_fir_interpolator_cc::mmse_fir_interpolator_cc() +namespace { +std::vector<kernel::fir_filter_ccf> build_filters() { - filters.resize(NSTEPS + 1); - + std::vector<kernel::fir_filter_ccf> filters; + filters.reserve(NSTEPS + 1); for (int i = 0; i < NSTEPS + 1; i++) { std::vector<float> t(&taps[i][0], &taps[i][NTAPS]); - filters[i] = new kernel::fir_filter_ccf(1, t); + filters.emplace_back(1, t); } + return filters; } +} // namespace -mmse_fir_interpolator_cc::~mmse_fir_interpolator_cc() -{ - for (int i = 0; i < NSTEPS + 1; i++) - delete filters[i]; -} +mmse_fir_interpolator_cc::mmse_fir_interpolator_cc() : filters(build_filters()) {} + +mmse_fir_interpolator_cc::~mmse_fir_interpolator_cc() {} unsigned mmse_fir_interpolator_cc::ntaps() const { return NTAPS; } @@ -47,7 +48,7 @@ gr_complex mmse_fir_interpolator_cc::interpolate(const gr_complex input[], float throw std::runtime_error("mmse_fir_interpolator_cc: imu out of bounds."); } - gr_complex r = filters[imu]->filter(input); + gr_complex r = filters[imu].filter(input); return r; } diff --git a/gr-filter/lib/mmse_fir_interpolator_ff.cc b/gr-filter/lib/mmse_fir_interpolator_ff.cc index 29870f2db4..53130ddff0 100644 --- a/gr-filter/lib/mmse_fir_interpolator_ff.cc +++ b/gr-filter/lib/mmse_fir_interpolator_ff.cc @@ -19,21 +19,22 @@ namespace gr { namespace filter { -mmse_fir_interpolator_ff::mmse_fir_interpolator_ff() +namespace { +std::vector<kernel::fir_filter_fff> build_filters() { - filters.resize(NSTEPS + 1); - + std::vector<kernel::fir_filter_fff> filters; + filters.reserve(NSTEPS + 1); for (int i = 0; i < NSTEPS + 1; i++) { std::vector<float> t(&taps[i][0], &taps[i][NTAPS]); - filters[i] = new kernel::fir_filter_fff(1, t); + filters.emplace_back(1, t); } + return filters; } +} // namespace -mmse_fir_interpolator_ff::~mmse_fir_interpolator_ff() -{ - for (int i = 0; i < NSTEPS + 1; i++) - delete filters[i]; -} +mmse_fir_interpolator_ff::mmse_fir_interpolator_ff() : filters(build_filters()) {} + +mmse_fir_interpolator_ff::~mmse_fir_interpolator_ff() {} unsigned mmse_fir_interpolator_ff::ntaps() const { return NTAPS; } @@ -47,7 +48,7 @@ float mmse_fir_interpolator_ff::interpolate(const float input[], float mu) const throw std::runtime_error("mmse_fir_interpolator_ff: imu out of bounds."); } - float r = filters[imu]->filter(input); + float r = filters[imu].filter(input); return r; } diff --git a/gr-filter/lib/mmse_interp_differentiator_cc.cc b/gr-filter/lib/mmse_interp_differentiator_cc.cc index f880108502..952604135a 100644 --- a/gr-filter/lib/mmse_interp_differentiator_cc.cc +++ b/gr-filter/lib/mmse_interp_differentiator_cc.cc @@ -19,22 +19,26 @@ namespace gr { namespace filter { -mmse_interp_differentiator_cc::mmse_interp_differentiator_cc() +namespace { +std::vector<kernel::fir_filter_ccf> build_filters() { - filters.resize(DNSTEPS + 1); - + std::vector<kernel::fir_filter_ccf> filters; + filters.reserve(DNSTEPS + 1); for (int i = 0; i < DNSTEPS + 1; i++) { std::vector<float> t(&Dtaps[i][0], &Dtaps[i][DNTAPS]); - filters[i] = new kernel::fir_filter_ccf(1, t); + filters.emplace_back(1, t); } + return filters; } +} // namespace + -mmse_interp_differentiator_cc::~mmse_interp_differentiator_cc() +mmse_interp_differentiator_cc::mmse_interp_differentiator_cc() : filters(build_filters()) { - for (int i = 0; i < DNSTEPS + 1; i++) - delete filters[i]; } +mmse_interp_differentiator_cc::~mmse_interp_differentiator_cc() {} + unsigned mmse_interp_differentiator_cc::ntaps() const { return DNTAPS; } unsigned mmse_interp_differentiator_cc::nsteps() const { return DNSTEPS; } @@ -48,7 +52,7 @@ gr_complex mmse_interp_differentiator_cc::differentiate(const gr_complex input[] throw std::runtime_error("mmse_interp_differentiator_cc: imu out of bounds."); } - gr_complex r = filters[imu]->filter(input); + gr_complex r = filters[imu].filter(input); return r; } diff --git a/gr-filter/lib/mmse_interp_differentiator_ff.cc b/gr-filter/lib/mmse_interp_differentiator_ff.cc index 89137717a9..3a925149f9 100644 --- a/gr-filter/lib/mmse_interp_differentiator_ff.cc +++ b/gr-filter/lib/mmse_interp_differentiator_ff.cc @@ -19,22 +19,25 @@ namespace gr { namespace filter { -mmse_interp_differentiator_ff::mmse_interp_differentiator_ff() +namespace { +std::vector<kernel::fir_filter_fff> build_filters() { - filters.resize(DNSTEPS + 1); - + std::vector<kernel::fir_filter_fff> filters; + filters.reserve(DNSTEPS + 1); for (int i = 0; i < DNSTEPS + 1; i++) { std::vector<float> t(&Dtaps[i][0], &Dtaps[i][DNTAPS]); - filters[i] = new kernel::fir_filter_fff(1, t); + filters.emplace_back(1, t); } + return filters; } +} // namespace -mmse_interp_differentiator_ff::~mmse_interp_differentiator_ff() +mmse_interp_differentiator_ff::mmse_interp_differentiator_ff() : filters(build_filters()) { - for (int i = 0; i < DNSTEPS + 1; i++) - delete filters[i]; } +mmse_interp_differentiator_ff::~mmse_interp_differentiator_ff() {} + unsigned mmse_interp_differentiator_ff::ntaps() const { return DNTAPS; } unsigned mmse_interp_differentiator_ff::nsteps() const { return DNSTEPS; } @@ -47,7 +50,7 @@ float mmse_interp_differentiator_ff::differentiate(const float input[], float mu throw std::runtime_error("mmse_interp_differentiator_ff: imu out of bounds."); } - float r = filters[imu]->filter(input); + float r = filters[imu].filter(input); return r; } diff --git a/gr-filter/lib/mmse_interpolator_cc_impl.cc b/gr-filter/lib/mmse_interpolator_cc_impl.cc index f95c7d3e80..94074af2d3 100644 --- a/gr-filter/lib/mmse_interpolator_cc_impl.cc +++ b/gr-filter/lib/mmse_interpolator_cc_impl.cc @@ -32,8 +32,7 @@ mmse_interpolator_cc_impl::mmse_interpolator_cc_impl(float phase_shift, io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(1, 1, sizeof(gr_complex))), d_mu(phase_shift), - d_mu_inc(interp_ratio), - d_interp(new mmse_fir_interpolator_cc()) + d_mu_inc(interp_ratio) { GR_LOG_WARN(d_logger, "mmse_interpolator is deprecated. Please use mmse_resampler instead."); @@ -46,7 +45,7 @@ mmse_interpolator_cc_impl::mmse_interpolator_cc_impl(float phase_shift, set_inverse_relative_rate(d_mu_inc); } -mmse_interpolator_cc_impl::~mmse_interpolator_cc_impl() { delete d_interp; } +mmse_interpolator_cc_impl::~mmse_interpolator_cc_impl() {} void mmse_interpolator_cc_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) @@ -54,7 +53,7 @@ void mmse_interpolator_cc_impl::forecast(int noutput_items, unsigned ninputs = ninput_items_required.size(); for (unsigned i = 0; i < ninputs; i++) { ninput_items_required[i] = - (int)ceil((noutput_items * d_mu_inc) + d_interp->ntaps()); + (int)ceil((noutput_items * d_mu_inc) + d_interp.ntaps()); } } @@ -70,7 +69,7 @@ int mmse_interpolator_cc_impl::general_work(int noutput_items, int oo = 0; // output index while (oo < noutput_items) { - out[oo++] = d_interp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_interp.interpolate(&in[ii], static_cast<float>(d_mu)); double s = d_mu + d_mu_inc; double f = floor(s); diff --git a/gr-filter/lib/mmse_interpolator_cc_impl.h b/gr-filter/lib/mmse_interpolator_cc_impl.h index bcfbb1ff5d..a275c0c742 100644 --- a/gr-filter/lib/mmse_interpolator_cc_impl.h +++ b/gr-filter/lib/mmse_interpolator_cc_impl.h @@ -22,7 +22,7 @@ class FILTER_API mmse_interpolator_cc_impl : public mmse_interpolator_cc private: double d_mu; double d_mu_inc; - mmse_fir_interpolator_cc* d_interp; + mmse_fir_interpolator_cc d_interp; public: mmse_interpolator_cc_impl(float phase_shift, float interp_ratio); diff --git a/gr-filter/lib/mmse_interpolator_ff_impl.cc b/gr-filter/lib/mmse_interpolator_ff_impl.cc index 62d641fb14..1b40ad7a15 100644 --- a/gr-filter/lib/mmse_interpolator_ff_impl.cc +++ b/gr-filter/lib/mmse_interpolator_ff_impl.cc @@ -32,8 +32,7 @@ mmse_interpolator_ff_impl::mmse_interpolator_ff_impl(float phase_shift, io_signature::make(1, 1, sizeof(float)), io_signature::make(1, 1, sizeof(float))), d_mu(phase_shift), - d_mu_inc(interp_ratio), - d_interp(new mmse_fir_interpolator_ff()) + d_mu_inc(interp_ratio) { GR_LOG_WARN(d_logger, "mmse_interpolator is deprecated. Please use mmse_resampler instead."); @@ -46,7 +45,7 @@ mmse_interpolator_ff_impl::mmse_interpolator_ff_impl(float phase_shift, set_inverse_relative_rate(d_mu_inc); } -mmse_interpolator_ff_impl::~mmse_interpolator_ff_impl() { delete d_interp; } +mmse_interpolator_ff_impl::~mmse_interpolator_ff_impl() {} void mmse_interpolator_ff_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) @@ -54,7 +53,7 @@ void mmse_interpolator_ff_impl::forecast(int noutput_items, unsigned ninputs = ninput_items_required.size(); for (unsigned i = 0; i < ninputs; i++) { ninput_items_required[i] = - (int)ceil((noutput_items * d_mu_inc) + d_interp->ntaps()); + (int)ceil((noutput_items * d_mu_inc) + d_interp.ntaps()); } } @@ -70,7 +69,7 @@ int mmse_interpolator_ff_impl::general_work(int noutput_items, int oo = 0; // output index while (oo < noutput_items) { - out[oo++] = d_interp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_interp.interpolate(&in[ii], static_cast<float>(d_mu)); double s = d_mu + d_mu_inc; double f = floor(s); diff --git a/gr-filter/lib/mmse_interpolator_ff_impl.h b/gr-filter/lib/mmse_interpolator_ff_impl.h index 261a10fea3..bd1ada0768 100644 --- a/gr-filter/lib/mmse_interpolator_ff_impl.h +++ b/gr-filter/lib/mmse_interpolator_ff_impl.h @@ -22,7 +22,7 @@ class FILTER_API mmse_interpolator_ff_impl : public mmse_interpolator_ff private: double d_mu; double d_mu_inc; - mmse_fir_interpolator_ff* d_interp; + mmse_fir_interpolator_ff d_interp; public: mmse_interpolator_ff_impl(float phase_shift, float interp_ratio); diff --git a/gr-filter/lib/mmse_resampler_cc_impl.cc b/gr-filter/lib/mmse_resampler_cc_impl.cc index 7cdd4ab93c..939aadf8fd 100644 --- a/gr-filter/lib/mmse_resampler_cc_impl.cc +++ b/gr-filter/lib/mmse_resampler_cc_impl.cc @@ -30,8 +30,7 @@ mmse_resampler_cc_impl::mmse_resampler_cc_impl(float phase_shift, float resamp_r io_signature::make2(1, 2, sizeof(gr_complex), sizeof(float)), io_signature::make(1, 1, sizeof(gr_complex))), d_mu(phase_shift), - d_mu_inc(resamp_ratio), - d_resamp(new mmse_fir_interpolator_cc()) + d_mu_inc(resamp_ratio) { if (resamp_ratio <= 0) throw std::out_of_range("resampling ratio must be > 0"); @@ -44,7 +43,7 @@ mmse_resampler_cc_impl::mmse_resampler_cc_impl(float phase_shift, float resamp_r [this](pmt::pmt_t msg) { this->handle_msg(msg); }); } -mmse_resampler_cc_impl::~mmse_resampler_cc_impl() { delete d_resamp; } +mmse_resampler_cc_impl::~mmse_resampler_cc_impl() {} void mmse_resampler_cc_impl::handle_msg(pmt::pmt_t msg) { @@ -67,7 +66,7 @@ void mmse_resampler_cc_impl::forecast(int noutput_items, unsigned ninputs = ninput_items_required.size(); for (unsigned i = 0; i < ninputs; i++) { ninput_items_required[i] = - (int)ceil((noutput_items * d_mu_inc) + d_resamp->ntaps()); + (int)ceil((noutput_items * d_mu_inc) + d_resamp.ntaps()); } } @@ -84,7 +83,7 @@ int mmse_resampler_cc_impl::general_work(int noutput_items, if (ninput_items.size() == 1) { while (oo < noutput_items) { - out[oo++] = d_resamp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_resamp.interpolate(&in[ii], static_cast<float>(d_mu)); double s = d_mu + d_mu_inc; double f = floor(s); @@ -100,7 +99,7 @@ int mmse_resampler_cc_impl::general_work(int noutput_items, else { const float* rr = (const float*)input_items[1]; while (oo < noutput_items) { - out[oo++] = d_resamp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_resamp.interpolate(&in[ii], static_cast<float>(d_mu)); d_mu_inc = static_cast<double>(rr[ii]); double s = d_mu + d_mu_inc; diff --git a/gr-filter/lib/mmse_resampler_cc_impl.h b/gr-filter/lib/mmse_resampler_cc_impl.h index cf677eafea..8bfd693110 100644 --- a/gr-filter/lib/mmse_resampler_cc_impl.h +++ b/gr-filter/lib/mmse_resampler_cc_impl.h @@ -22,7 +22,7 @@ class FILTER_API mmse_resampler_cc_impl : public mmse_resampler_cc private: double d_mu; double d_mu_inc; - mmse_fir_interpolator_cc* d_resamp; + const mmse_fir_interpolator_cc d_resamp; public: mmse_resampler_cc_impl(float phase_shift, float resamp_ratio); diff --git a/gr-filter/lib/mmse_resampler_ff_impl.cc b/gr-filter/lib/mmse_resampler_ff_impl.cc index b034bb4d41..6a59b3c8bf 100644 --- a/gr-filter/lib/mmse_resampler_ff_impl.cc +++ b/gr-filter/lib/mmse_resampler_ff_impl.cc @@ -30,8 +30,7 @@ mmse_resampler_ff_impl::mmse_resampler_ff_impl(float phase_shift, float resamp_r io_signature::make(1, 2, sizeof(float)), io_signature::make(1, 1, sizeof(float))), d_mu(phase_shift), - d_mu_inc(resamp_ratio), - d_resamp(new mmse_fir_interpolator_ff()) + d_mu_inc(resamp_ratio) { if (resamp_ratio <= 0) throw std::out_of_range("resampling ratio must be > 0"); @@ -45,7 +44,7 @@ mmse_resampler_ff_impl::mmse_resampler_ff_impl(float phase_shift, float resamp_r [this](pmt::pmt_t msg) { this->handle_msg(msg); }); } -mmse_resampler_ff_impl::~mmse_resampler_ff_impl() { delete d_resamp; } +mmse_resampler_ff_impl::~mmse_resampler_ff_impl() {} void mmse_resampler_ff_impl::handle_msg(pmt::pmt_t msg) { @@ -68,7 +67,7 @@ void mmse_resampler_ff_impl::forecast(int noutput_items, unsigned ninputs = ninput_items_required.size(); for (unsigned i = 0; i < ninputs; i++) { ninput_items_required[i] = - (int)ceil((noutput_items * d_mu_inc) + d_resamp->ntaps()); + (int)ceil((noutput_items * d_mu_inc) + d_resamp.ntaps()); } } @@ -85,7 +84,7 @@ int mmse_resampler_ff_impl::general_work(int noutput_items, if (ninput_items.size() == 1) { while (oo < noutput_items) { - out[oo++] = d_resamp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_resamp.interpolate(&in[ii], static_cast<float>(d_mu)); double s = d_mu + d_mu_inc; double f = floor(s); @@ -99,7 +98,7 @@ int mmse_resampler_ff_impl::general_work(int noutput_items, } else { const float* rr = (const float*)input_items[1]; while (oo < noutput_items) { - out[oo++] = d_resamp->interpolate(&in[ii], static_cast<float>(d_mu)); + out[oo++] = d_resamp.interpolate(&in[ii], static_cast<float>(d_mu)); d_mu_inc = static_cast<double>(rr[ii]); double s = d_mu + d_mu_inc; diff --git a/gr-filter/lib/mmse_resampler_ff_impl.h b/gr-filter/lib/mmse_resampler_ff_impl.h index f6a6298795..c94f6a4ec0 100644 --- a/gr-filter/lib/mmse_resampler_ff_impl.h +++ b/gr-filter/lib/mmse_resampler_ff_impl.h @@ -22,7 +22,7 @@ class FILTER_API mmse_resampler_ff_impl : public mmse_resampler_ff private: double d_mu; double d_mu_inc; - mmse_fir_interpolator_ff* d_resamp; + const mmse_fir_interpolator_ff d_resamp; public: mmse_resampler_ff_impl(float phase_shift, float resamp_ratio); diff --git a/gr-filter/lib/pfb_arb_resampler.cc b/gr-filter/lib/pfb_arb_resampler.cc index d7f34e06e8..7d3d4d6cd6 100644 --- a/gr-filter/lib/pfb_arb_resampler.cc +++ b/gr-filter/lib/pfb_arb_resampler.cc @@ -43,14 +43,13 @@ pfb_arb_resampler_ccf::pfb_arb_resampler_ccf(float rate, d_last_filter = (taps.size() / 2) % filter_size; - d_filters = std::vector<fir_filter_ccf*>(d_int_rate); - d_diff_filters = std::vector<fir_filter_ccf*>(d_int_rate); - // Create an FIR filter for each channel and zero out the taps std::vector<float> vtaps(0, d_int_rate); + d_filters.reserve(d_int_rate); + d_diff_filters.reserve(d_int_rate); for (unsigned int i = 0; i < d_int_rate; i++) { - d_filters[i] = new fir_filter_ccf(1, vtaps); - d_diff_filters[i] = new fir_filter_ccf(1, vtaps); + d_filters.emplace_back(1, vtaps); + d_diff_filters.emplace_back(1, vtaps); } // Now, actually set the filters' taps @@ -76,17 +75,11 @@ pfb_arb_resampler_ccf::pfb_arb_resampler_ccf(float rate, d_est_phase_change = d_last_filter - (end_filter + accum_frac); } -pfb_arb_resampler_ccf::~pfb_arb_resampler_ccf() -{ - for (unsigned int i = 0; i < d_int_rate; i++) { - delete d_filters[i]; - delete d_diff_filters[i]; - } -} +pfb_arb_resampler_ccf::~pfb_arb_resampler_ccf() {} void pfb_arb_resampler_ccf::create_taps(const std::vector<float>& newtaps, std::vector<std::vector<float>>& ourtaps, - std::vector<fir_filter_ccf*>& ourfilter) + std::vector<fir_filter_ccf>& ourfilter) { unsigned int ntaps = newtaps.size(); d_taps_per_filter = (unsigned int)ceil((double)ntaps / (double)d_int_rate); @@ -110,7 +103,7 @@ void pfb_arb_resampler_ccf::create_taps(const std::vector<float>& newtaps, } // Build a filter for each channel and add it's taps to it - ourfilter[i]->set_taps(ourtaps[i]); + ourfilter[i].set_taps(ourtaps[i]); } } @@ -199,8 +192,8 @@ int pfb_arb_resampler_ccf::filter(gr_complex* output, // start j by wrapping around mod the number of channels while (j < d_int_rate) { // Take the current filter and derivative filter output - o0 = d_filters[j]->filter(&input[i_in]); - o1 = d_diff_filters[j]->filter(&input[i_in]); + o0 = d_filters[j].filter(&input[i_in]); + o1 = d_diff_filters[j].filter(&input[i_in]); output[i_out] = o0 + o1 * d_acc; // linearly interpolate between samples i_out++; @@ -241,14 +234,14 @@ pfb_arb_resampler_ccc::pfb_arb_resampler_ccc(float rate, d_last_filter = (taps.size() / 2) % filter_size; - d_filters = std::vector<fir_filter_ccc*>(d_int_rate); - d_diff_filters = std::vector<fir_filter_ccc*>(d_int_rate); + d_filters.reserve(d_int_rate); + d_diff_filters.reserve(d_int_rate); // Create an FIR filter for each channel and zero out the taps std::vector<gr_complex> vtaps(0, d_int_rate); for (unsigned int i = 0; i < d_int_rate; i++) { - d_filters[i] = new fir_filter_ccc(1, vtaps); - d_diff_filters[i] = new fir_filter_ccc(1, vtaps); + d_filters.emplace_back(1, vtaps); + d_diff_filters.emplace_back(1, vtaps); } // Now, actually set the filters' taps @@ -274,17 +267,11 @@ pfb_arb_resampler_ccc::pfb_arb_resampler_ccc(float rate, d_est_phase_change = d_last_filter - (end_filter + accum_frac); } -pfb_arb_resampler_ccc::~pfb_arb_resampler_ccc() -{ - for (unsigned int i = 0; i < d_int_rate; i++) { - delete d_filters[i]; - delete d_diff_filters[i]; - } -} +pfb_arb_resampler_ccc::~pfb_arb_resampler_ccc() {} void pfb_arb_resampler_ccc::create_taps(const std::vector<gr_complex>& newtaps, std::vector<std::vector<gr_complex>>& ourtaps, - std::vector<fir_filter_ccc*>& ourfilter) + std::vector<fir_filter_ccc>& ourfilter) { unsigned int ntaps = newtaps.size(); d_taps_per_filter = (unsigned int)ceil((double)ntaps / (double)d_int_rate); @@ -308,7 +295,7 @@ void pfb_arb_resampler_ccc::create_taps(const std::vector<gr_complex>& newtaps, } // Build a filter for each channel and add it's taps to it - ourfilter[i]->set_taps(ourtaps[i]); + ourfilter[i].set_taps(ourtaps[i]); } } @@ -400,8 +387,8 @@ int pfb_arb_resampler_ccc::filter(gr_complex* output, // start j by wrapping around mod the number of channels while (j < d_int_rate) { // Take the current filter and derivative filter output - o0 = d_filters[j]->filter(&input[i_in]); - o1 = d_diff_filters[j]->filter(&input[i_in]); + o0 = d_filters[j].filter(&input[i_in]); + o1 = d_diff_filters[j].filter(&input[i_in]); output[i_out] = o0 + o1 * d_acc; // linearly interpolate between samples i_out++; @@ -442,14 +429,14 @@ pfb_arb_resampler_fff::pfb_arb_resampler_fff(float rate, d_last_filter = (taps.size() / 2) % filter_size; - d_filters = std::vector<fir_filter_fff*>(d_int_rate); - d_diff_filters = std::vector<fir_filter_fff*>(d_int_rate); + d_filters.reserve(d_int_rate); + d_diff_filters.reserve(d_int_rate); // Create an FIR filter for each channel and zero out the taps std::vector<float> vtaps(0, d_int_rate); for (unsigned int i = 0; i < d_int_rate; i++) { - d_filters[i] = new fir_filter_fff(1, vtaps); - d_diff_filters[i] = new fir_filter_fff(1, vtaps); + d_filters.emplace_back(1, vtaps); + d_diff_filters.emplace_back(1, vtaps); } // Now, actually set the filters' taps @@ -475,17 +462,11 @@ pfb_arb_resampler_fff::pfb_arb_resampler_fff(float rate, d_est_phase_change = d_last_filter - (end_filter + accum_frac); } -pfb_arb_resampler_fff::~pfb_arb_resampler_fff() -{ - for (unsigned int i = 0; i < d_int_rate; i++) { - delete d_filters[i]; - delete d_diff_filters[i]; - } -} +pfb_arb_resampler_fff::~pfb_arb_resampler_fff() {} void pfb_arb_resampler_fff::create_taps(const std::vector<float>& newtaps, std::vector<std::vector<float>>& ourtaps, - std::vector<fir_filter_fff*>& ourfilter) + std::vector<fir_filter_fff>& ourfilter) { unsigned int ntaps = newtaps.size(); d_taps_per_filter = (unsigned int)ceil((double)ntaps / (double)d_int_rate); @@ -509,7 +490,7 @@ void pfb_arb_resampler_fff::create_taps(const std::vector<float>& newtaps, } // Build a filter for each channel and add it's taps to it - ourfilter[i]->set_taps(ourtaps[i]); + ourfilter[i].set_taps(ourtaps[i]); } } @@ -595,8 +576,8 @@ int pfb_arb_resampler_fff::filter(float* output, float* input, int n_to_read, in // start j by wrapping around mod the number of channels while (j < d_int_rate) { // Take the current filter and derivative filter output - o0 = d_filters[j]->filter(&input[i_in]); - o1 = d_diff_filters[j]->filter(&input[i_in]); + o0 = d_filters[j].filter(&input[i_in]); + o1 = d_diff_filters[j].filter(&input[i_in]); output[i_out] = o0 + o1 * d_acc; // linearly interpolate between samples i_out++; diff --git a/gr-filter/lib/pfb_arb_resampler_ccc_impl.cc b/gr-filter/lib/pfb_arb_resampler_ccc_impl.cc index e53a5011a9..1a0760a37a 100644 --- a/gr-filter/lib/pfb_arb_resampler_ccc_impl.cc +++ b/gr-filter/lib/pfb_arb_resampler_ccc_impl.cc @@ -31,16 +31,16 @@ pfb_arb_resampler_ccc_impl::pfb_arb_resampler_ccc_impl( float rate, const std::vector<gr_complex>& taps, unsigned int filter_size) : block("pfb_arb_resampler_ccc", io_signature::make(1, 1, sizeof(gr_complex)), - io_signature::make(1, 1, sizeof(gr_complex))) + io_signature::make(1, 1, sizeof(gr_complex))), + d_resamp(rate, taps, filter_size) { d_updated = false; - d_resamp = new kernel::pfb_arb_resampler_ccc(rate, taps, filter_size); - set_history(d_resamp->taps_per_filter()); + set_history(d_resamp.taps_per_filter()); set_relative_rate(rate); } -pfb_arb_resampler_ccc_impl::~pfb_arb_resampler_ccc_impl() { delete d_resamp; } +pfb_arb_resampler_ccc_impl::~pfb_arb_resampler_ccc_impl() {} void pfb_arb_resampler_ccc_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) @@ -59,59 +59,59 @@ void pfb_arb_resampler_ccc_impl::set_taps(const std::vector<gr_complex>& taps) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_taps(taps); - set_history(d_resamp->taps_per_filter()); + d_resamp.set_taps(taps); + set_history(d_resamp.taps_per_filter()); d_updated = true; } std::vector<std::vector<gr_complex>> pfb_arb_resampler_ccc_impl::taps() const { - return d_resamp->taps(); + return d_resamp.taps(); } -void pfb_arb_resampler_ccc_impl::print_taps() { d_resamp->print_taps(); } +void pfb_arb_resampler_ccc_impl::print_taps() { d_resamp.print_taps(); } void pfb_arb_resampler_ccc_impl::set_rate(float rate) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_rate(rate); + d_resamp.set_rate(rate); set_relative_rate(rate); } void pfb_arb_resampler_ccc_impl::set_phase(float ph) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_phase(ph); + d_resamp.set_phase(ph); } -float pfb_arb_resampler_ccc_impl::phase() const { return d_resamp->phase(); } +float pfb_arb_resampler_ccc_impl::phase() const { return d_resamp.phase(); } unsigned int pfb_arb_resampler_ccc_impl::interpolation_rate() const { - return d_resamp->interpolation_rate(); + return d_resamp.interpolation_rate(); } unsigned int pfb_arb_resampler_ccc_impl::decimation_rate() const { - return d_resamp->decimation_rate(); + return d_resamp.decimation_rate(); } float pfb_arb_resampler_ccc_impl::fractional_rate() const { - return d_resamp->fractional_rate(); + return d_resamp.fractional_rate(); } unsigned int pfb_arb_resampler_ccc_impl::taps_per_filter() const { - return d_resamp->taps_per_filter(); + return d_resamp.taps_per_filter(); } -int pfb_arb_resampler_ccc_impl::group_delay() const { return d_resamp->group_delay(); } +int pfb_arb_resampler_ccc_impl::group_delay() const { return d_resamp.group_delay(); } float pfb_arb_resampler_ccc_impl::phase_offset(float freq, float fs) { - return d_resamp->phase_offset(freq, fs); + return d_resamp.phase_offset(freq, fs); } int pfb_arb_resampler_ccc_impl::general_work(int noutput_items, @@ -131,7 +131,7 @@ int pfb_arb_resampler_ccc_impl::general_work(int noutput_items, int nitems_read; int nitems = floorf((float)noutput_items / relative_rate()); - int processed = d_resamp->filter(out, in, nitems, nitems_read); + int processed = d_resamp.filter(out, in, nitems, nitems_read); consume_each(nitems_read); return processed; diff --git a/gr-filter/lib/pfb_arb_resampler_ccc_impl.h b/gr-filter/lib/pfb_arb_resampler_ccc_impl.h index a2b841b0b2..2d6db46d3c 100644 --- a/gr-filter/lib/pfb_arb_resampler_ccc_impl.h +++ b/gr-filter/lib/pfb_arb_resampler_ccc_impl.h @@ -22,7 +22,7 @@ namespace filter { class FILTER_API pfb_arb_resampler_ccc_impl : public pfb_arb_resampler_ccc { private: - kernel::pfb_arb_resampler_ccc* d_resamp; + kernel::pfb_arb_resampler_ccc d_resamp; bool d_updated; gr::thread::mutex d_mutex; // mutex to protect set/work access diff --git a/gr-filter/lib/pfb_arb_resampler_ccf_impl.cc b/gr-filter/lib/pfb_arb_resampler_ccf_impl.cc index de012a0ee0..d56ed01680 100644 --- a/gr-filter/lib/pfb_arb_resampler_ccf_impl.cc +++ b/gr-filter/lib/pfb_arb_resampler_ccf_impl.cc @@ -33,16 +33,16 @@ pfb_arb_resampler_ccf_impl::pfb_arb_resampler_ccf_impl(float rate, unsigned int filter_size) : block("pfb_arb_resampler_ccf", io_signature::make(1, 1, sizeof(gr_complex)), - io_signature::make(1, 1, sizeof(gr_complex))) + io_signature::make(1, 1, sizeof(gr_complex))), + d_resamp(rate, taps, filter_size) { d_updated = false; - d_resamp = new kernel::pfb_arb_resampler_ccf(rate, taps, filter_size); - set_history(d_resamp->taps_per_filter()); + set_history(d_resamp.taps_per_filter()); set_relative_rate(rate); } -pfb_arb_resampler_ccf_impl::~pfb_arb_resampler_ccf_impl() { delete d_resamp; } +pfb_arb_resampler_ccf_impl::~pfb_arb_resampler_ccf_impl() {} void pfb_arb_resampler_ccf_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) @@ -61,59 +61,59 @@ void pfb_arb_resampler_ccf_impl::set_taps(const std::vector<float>& taps) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_taps(taps); - set_history(d_resamp->taps_per_filter()); + d_resamp.set_taps(taps); + set_history(d_resamp.taps_per_filter()); d_updated = true; } std::vector<std::vector<float>> pfb_arb_resampler_ccf_impl::taps() const { - return d_resamp->taps(); + return d_resamp.taps(); } -void pfb_arb_resampler_ccf_impl::print_taps() { d_resamp->print_taps(); } +void pfb_arb_resampler_ccf_impl::print_taps() { d_resamp.print_taps(); } void pfb_arb_resampler_ccf_impl::set_rate(float rate) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_rate(rate); + d_resamp.set_rate(rate); set_relative_rate(rate); } void pfb_arb_resampler_ccf_impl::set_phase(float ph) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_phase(ph); + d_resamp.set_phase(ph); } -float pfb_arb_resampler_ccf_impl::phase() const { return d_resamp->phase(); } +float pfb_arb_resampler_ccf_impl::phase() const { return d_resamp.phase(); } unsigned int pfb_arb_resampler_ccf_impl::interpolation_rate() const { - return d_resamp->interpolation_rate(); + return d_resamp.interpolation_rate(); } unsigned int pfb_arb_resampler_ccf_impl::decimation_rate() const { - return d_resamp->decimation_rate(); + return d_resamp.decimation_rate(); } float pfb_arb_resampler_ccf_impl::fractional_rate() const { - return d_resamp->fractional_rate(); + return d_resamp.fractional_rate(); } unsigned int pfb_arb_resampler_ccf_impl::taps_per_filter() const { - return d_resamp->taps_per_filter(); + return d_resamp.taps_per_filter(); } -int pfb_arb_resampler_ccf_impl::group_delay() const { return d_resamp->group_delay(); } +int pfb_arb_resampler_ccf_impl::group_delay() const { return d_resamp.group_delay(); } float pfb_arb_resampler_ccf_impl::phase_offset(float freq, float fs) { - return d_resamp->phase_offset(freq, fs); + return d_resamp.phase_offset(freq, fs); } int pfb_arb_resampler_ccf_impl::general_work(int noutput_items, @@ -133,7 +133,7 @@ int pfb_arb_resampler_ccf_impl::general_work(int noutput_items, int nitems_read; int nitems = floorf((float)noutput_items / relative_rate()); - int processed = d_resamp->filter(out, in, nitems, nitems_read); + int processed = d_resamp.filter(out, in, nitems, nitems_read); consume_each(nitems_read); return processed; diff --git a/gr-filter/lib/pfb_arb_resampler_ccf_impl.h b/gr-filter/lib/pfb_arb_resampler_ccf_impl.h index b4333f336f..b86ad0432f 100644 --- a/gr-filter/lib/pfb_arb_resampler_ccf_impl.h +++ b/gr-filter/lib/pfb_arb_resampler_ccf_impl.h @@ -22,7 +22,7 @@ namespace filter { class FILTER_API pfb_arb_resampler_ccf_impl : public pfb_arb_resampler_ccf { private: - kernel::pfb_arb_resampler_ccf* d_resamp; + kernel::pfb_arb_resampler_ccf d_resamp; bool d_updated; gr::thread::mutex d_mutex; // mutex to protect set/work access diff --git a/gr-filter/lib/pfb_arb_resampler_fff_impl.cc b/gr-filter/lib/pfb_arb_resampler_fff_impl.cc index 7a1ac19a85..49a8188c72 100644 --- a/gr-filter/lib/pfb_arb_resampler_fff_impl.cc +++ b/gr-filter/lib/pfb_arb_resampler_fff_impl.cc @@ -33,16 +33,16 @@ pfb_arb_resampler_fff_impl::pfb_arb_resampler_fff_impl(float rate, unsigned int filter_size) : block("pfb_arb_resampler_fff", io_signature::make(1, 1, sizeof(float)), - io_signature::make(1, 1, sizeof(float))) + io_signature::make(1, 1, sizeof(float))), + d_resamp(rate, taps, filter_size) { d_updated = false; - d_resamp = new kernel::pfb_arb_resampler_fff(rate, taps, filter_size); - set_history(d_resamp->taps_per_filter()); + set_history(d_resamp.taps_per_filter()); set_relative_rate(rate); } -pfb_arb_resampler_fff_impl::~pfb_arb_resampler_fff_impl() { delete d_resamp; } +pfb_arb_resampler_fff_impl::~pfb_arb_resampler_fff_impl() {} void pfb_arb_resampler_fff_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) @@ -61,59 +61,59 @@ void pfb_arb_resampler_fff_impl::set_taps(const std::vector<float>& taps) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_taps(taps); - set_history(d_resamp->taps_per_filter()); + d_resamp.set_taps(taps); + set_history(d_resamp.taps_per_filter()); d_updated = true; } std::vector<std::vector<float>> pfb_arb_resampler_fff_impl::taps() const { - return d_resamp->taps(); + return d_resamp.taps(); } -void pfb_arb_resampler_fff_impl::print_taps() { d_resamp->print_taps(); } +void pfb_arb_resampler_fff_impl::print_taps() { d_resamp.print_taps(); } void pfb_arb_resampler_fff_impl::set_rate(float rate) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_rate(rate); + d_resamp.set_rate(rate); set_relative_rate(rate); } void pfb_arb_resampler_fff_impl::set_phase(float ph) { gr::thread::scoped_lock guard(d_mutex); - d_resamp->set_phase(ph); + d_resamp.set_phase(ph); } -float pfb_arb_resampler_fff_impl::phase() const { return d_resamp->phase(); } +float pfb_arb_resampler_fff_impl::phase() const { return d_resamp.phase(); } unsigned int pfb_arb_resampler_fff_impl::interpolation_rate() const { - return d_resamp->interpolation_rate(); + return d_resamp.interpolation_rate(); } unsigned int pfb_arb_resampler_fff_impl::decimation_rate() const { - return d_resamp->decimation_rate(); + return d_resamp.decimation_rate(); } float pfb_arb_resampler_fff_impl::fractional_rate() const { - return d_resamp->fractional_rate(); + return d_resamp.fractional_rate(); } unsigned int pfb_arb_resampler_fff_impl::taps_per_filter() const { - return d_resamp->taps_per_filter(); + return d_resamp.taps_per_filter(); } -int pfb_arb_resampler_fff_impl::group_delay() const { return d_resamp->group_delay(); } +int pfb_arb_resampler_fff_impl::group_delay() const { return d_resamp.group_delay(); } float pfb_arb_resampler_fff_impl::phase_offset(float freq, float fs) { - return d_resamp->phase_offset(freq, fs); + return d_resamp.phase_offset(freq, fs); } int pfb_arb_resampler_fff_impl::general_work(int noutput_items, @@ -133,7 +133,7 @@ int pfb_arb_resampler_fff_impl::general_work(int noutput_items, int nitems_read; int nitems = floorf((float)noutput_items / relative_rate()); - int processed = d_resamp->filter(out, in, nitems, nitems_read); + int processed = d_resamp.filter(out, in, nitems, nitems_read); consume_each(nitems_read); return processed; diff --git a/gr-filter/lib/pfb_arb_resampler_fff_impl.h b/gr-filter/lib/pfb_arb_resampler_fff_impl.h index a9f93b7ebd..fdadb890fb 100644 --- a/gr-filter/lib/pfb_arb_resampler_fff_impl.h +++ b/gr-filter/lib/pfb_arb_resampler_fff_impl.h @@ -22,7 +22,7 @@ namespace filter { class FILTER_API pfb_arb_resampler_fff_impl : public pfb_arb_resampler_fff { private: - kernel::pfb_arb_resampler_fff* d_resamp; + kernel::pfb_arb_resampler_fff d_resamp; bool d_updated; gr::thread::mutex d_mutex; // mutex to protect set/work access diff --git a/gr-filter/lib/pfb_channelizer_ccf_impl.cc b/gr-filter/lib/pfb_channelizer_ccf_impl.cc index a3b18a09ba..514ea629a1 100644 --- a/gr-filter/lib/pfb_channelizer_ccf_impl.cc +++ b/gr-filter/lib/pfb_channelizer_ccf_impl.cc @@ -71,7 +71,7 @@ pfb_channelizer_ccf_impl::pfb_channelizer_ccf_impl(unsigned int nfilts, // with the first and put it into the fft object properly for // the same effect. d_rate_ratio = (int)rintf(d_nfilts / d_oversample_rate); - d_idxlut = new int[d_nfilts]; + d_idxlut.resize(d_nfilts); for (unsigned int i = 0; i < d_nfilts; i++) { d_idxlut[i] = d_nfilts - ((i + d_rate_ratio) % d_nfilts) - 1; } @@ -91,7 +91,7 @@ pfb_channelizer_ccf_impl::pfb_channelizer_ccf_impl(unsigned int nfilts, set_tag_propagation_policy(TPP_ONE_TO_ONE); } -pfb_channelizer_ccf_impl::~pfb_channelizer_ccf_impl() { delete[] d_idxlut; } +pfb_channelizer_ccf_impl::~pfb_channelizer_ccf_impl() {} void pfb_channelizer_ccf_impl::set_taps(const std::vector<float>& taps) { @@ -162,7 +162,7 @@ int pfb_channelizer_ccf_impl::general_work(int noutput_items, last = i; while (i >= 0) { in = (gr_complex*)input_items[j]; - d_fft->get_inbuf()[d_idxlut[j]] = d_fir_filters[i]->filter(&in[n]); + d_fft.get_inbuf()[d_idxlut[j]] = d_fir_filters[i].filter(&in[n]); j++; i--; } @@ -170,7 +170,7 @@ int pfb_channelizer_ccf_impl::general_work(int noutput_items, i = d_nfilts - 1; while (i > last) { in = (gr_complex*)input_items[j]; - d_fft->get_inbuf()[d_idxlut[j]] = d_fir_filters[i]->filter(&in[n - 1]); + d_fft.get_inbuf()[d_idxlut[j]] = d_fir_filters[i].filter(&in[n - 1]); j++; i--; } @@ -178,12 +178,12 @@ int pfb_channelizer_ccf_impl::general_work(int noutput_items, n += (i + d_rate_ratio) >= (int)d_nfilts; // despin through FFT - d_fft->execute(); + d_fft.execute(); // Send to output channels for (unsigned int nn = 0; nn < noutputs; nn++) { out = (gr_complex*)output_items[nn]; - out[oo] = d_fft->get_outbuf()[d_channel_map[nn]]; + out[oo] = d_fft.get_outbuf()[d_channel_map[nn]]; } oo++; } diff --git a/gr-filter/lib/pfb_channelizer_ccf_impl.h b/gr-filter/lib/pfb_channelizer_ccf_impl.h index 092488d55b..0feb2b9cb1 100644 --- a/gr-filter/lib/pfb_channelizer_ccf_impl.h +++ b/gr-filter/lib/pfb_channelizer_ccf_impl.h @@ -26,7 +26,7 @@ class FILTER_API pfb_channelizer_ccf_impl : public pfb_channelizer_ccf, private: bool d_updated; float d_oversample_rate; - int* d_idxlut; + std::vector<int> d_idxlut; int d_rate_ratio; int d_output_multiple; std::vector<int> d_channel_map; diff --git a/gr-filter/lib/pfb_decimator_ccf_impl.cc b/gr-filter/lib/pfb_decimator_ccf_impl.cc index 7d263c4331..fcb5da24ae 100644 --- a/gr-filter/lib/pfb_decimator_ccf_impl.cc +++ b/gr-filter/lib/pfb_decimator_ccf_impl.cc @@ -46,7 +46,7 @@ pfb_decimator_ccf_impl::pfb_decimator_ccf_impl(unsigned int decim, d_use_fft_filters(use_fft_filters) { d_rate = decim; - d_rotator = new gr_complex[d_rate]; + d_rotator.resize(d_rate); for (unsigned int i = 0; i < d_rate; i++) { d_rotator[i] = gr_expj(i * d_chan * 2 * GR_M_PI / d_rate); } @@ -55,8 +55,7 @@ pfb_decimator_ccf_impl::pfb_decimator_ccf_impl(unsigned int decim, if (d_use_fft_filters) { set_history(1); - set_output_multiple(d_fft_filters[0]->filtersize() - d_fft_filters[0]->ntaps() + - 1); + set_output_multiple(d_fft_filters[0].filtersize() - d_fft_filters[0].ntaps() + 1); } else { set_history(d_taps_per_filter); } @@ -82,7 +81,7 @@ bool pfb_decimator_ccf_impl::stop() return block::stop(); } -pfb_decimator_ccf_impl::~pfb_decimator_ccf_impl() { delete[] d_rotator; } +pfb_decimator_ccf_impl::~pfb_decimator_ccf_impl() {} void pfb_decimator_ccf_impl::set_taps(const std::vector<float>& taps) { @@ -146,7 +145,7 @@ int pfb_decimator_ccf_impl::work_fir_exp(int noutput_items, for (int j = d_rate - 1; j >= 0; j--) { // Take items from M-1 to 0; filter and rotate in = (gr_complex*)input_items[d_rate - 1 - j]; - out[i] += d_fir_filters[j]->filter(&in[i]) * d_rotator[j]; + out[i] += d_fir_filters[j].filter(&in[i]) * d_rotator[j]; } } @@ -167,14 +166,14 @@ int pfb_decimator_ccf_impl::work_fir_fft(int noutput_items, for (unsigned int j = 0; j < d_rate; j++) { // Take in the items from the first input stream to d_rate in = (gr_complex*)input_items[d_rate - 1 - j]; - d_fft->get_inbuf()[j] = d_fir_filters[j]->filter(&in[i]); + d_fft.get_inbuf()[j] = d_fir_filters[j].filter(&in[i]); } // Perform the FFT to do the complex multiply despinning for all channels - d_fft->execute(); + d_fft.execute(); // Select only the desired channel out - out[i] = d_fft->get_outbuf()[d_chan]; + out[i] = d_fft.get_outbuf()[d_chan]; } return noutput_items; @@ -194,7 +193,7 @@ int pfb_decimator_ccf_impl::work_fft_exp(int noutput_items, // setup and operation. for (unsigned int j = 0; j < d_rate; j++) { in = (gr_complex*)input_items[d_rate - j - 1]; - d_fft_filters[j]->filter(noutput_items, in, &(d_tmp[j * noutput_items])); + d_fft_filters[j].filter(noutput_items, in, &(d_tmp[j * noutput_items])); } // Rotate and add filter outputs (k=channel number; M=number of @@ -221,21 +220,21 @@ int pfb_decimator_ccf_impl::work_fft_fft(int noutput_items, for (unsigned int j = 0; j < d_rate; j++) { in = (gr_complex*)input_items[d_rate - j - 1]; - d_fft_filters[j]->filter(noutput_items, in, &d_tmp[j * noutput_items]); + d_fft_filters[j].filter(noutput_items, in, &d_tmp[j * noutput_items]); } // Performs the rotate and add operations by implementing it as // an FFT. for (i = 0; i < noutput_items; i++) { for (unsigned int j = 0; j < d_rate; j++) { - d_fft->get_inbuf()[j] = d_tmp[j * noutput_items + i]; + d_fft.get_inbuf()[j] = d_tmp[j * noutput_items + i]; } // Perform the FFT to do the complex multiply despinning for all channels - d_fft->execute(); + d_fft.execute(); // Select only the desired channel out - out[i] = d_fft->get_outbuf()[d_chan]; + out[i] = d_fft.get_outbuf()[d_chan]; } return noutput_items; diff --git a/gr-filter/lib/pfb_decimator_ccf_impl.h b/gr-filter/lib/pfb_decimator_ccf_impl.h index 8e7f111ef0..e9fa54f8f3 100644 --- a/gr-filter/lib/pfb_decimator_ccf_impl.h +++ b/gr-filter/lib/pfb_decimator_ccf_impl.h @@ -28,7 +28,7 @@ private: unsigned int d_chan; bool d_use_fft_rotator; bool d_use_fft_filters; - gr_complex* d_rotator; + std::vector<gr_complex> d_rotator; gr_complex* d_tmp; // used for fft filters gr::thread::mutex d_mutex; // mutex to protect set/work access @@ -54,6 +54,10 @@ public: ~pfb_decimator_ccf_impl(); + // No copy because d_tmp. + pfb_decimator_ccf_impl(const pfb_decimator_ccf_impl&) = delete; + pfb_decimator_ccf_impl& operator=(const pfb_decimator_ccf_impl&) = delete; + void set_taps(const std::vector<float>& taps); void print_taps(); std::vector<std::vector<float>> taps() const; diff --git a/gr-filter/lib/pfb_interpolator_ccf_impl.cc b/gr-filter/lib/pfb_interpolator_ccf_impl.cc index 39b7bdee58..197742a604 100644 --- a/gr-filter/lib/pfb_interpolator_ccf_impl.cc +++ b/gr-filter/lib/pfb_interpolator_ccf_impl.cc @@ -72,7 +72,7 @@ int pfb_interpolator_ccf_impl::work(int noutput_items, while (i < noutput_items) { for (unsigned int j = 0; j < d_rate; j++) { - out[i] = d_fir_filters[j]->filter(&in[count]); + out[i] = d_fir_filters[j].filter(&in[count]); i++; } count++; diff --git a/gr-filter/lib/pfb_synthesizer_ccf_impl.cc b/gr-filter/lib/pfb_synthesizer_ccf_impl.cc index 38e914ff6b..aebd782c8b 100644 --- a/gr-filter/lib/pfb_synthesizer_ccf_impl.cc +++ b/gr-filter/lib/pfb_synthesizer_ccf_impl.cc @@ -36,23 +36,24 @@ pfb_synthesizer_ccf_impl::pfb_synthesizer_ccf_impl(unsigned int numchans, numchans), d_updated(false), d_numchans(numchans), - d_state(0) + d_state(0), + d_twox(twox ? 2 : 1), + d_fft(d_twox * d_numchans, false) { // set up 2x multiplier; if twox==True, set to 2, otherwise to 1 - d_twox = (twox ? 2 : 1); if (d_numchans % d_twox != 0) { throw std::invalid_argument("pfb_synthesizer_ccf_impl: number of channels must " "be even for 2x oversampling."); } - d_filters = std::vector<kernel::fir_filter_with_buffer_ccf*>(d_twox * d_numchans); + d_filters.reserve(d_twox * d_numchans); d_channel_map.resize(d_twox * d_numchans); // Create an FIR filter for each channel and zero out the taps // and set the default channel map std::vector<float> vtaps(0, d_twox * d_numchans); for (unsigned int i = 0; i < d_twox * d_numchans; i++) { - d_filters[i] = new kernel::fir_filter_with_buffer_ccf(vtaps); + d_filters.emplace_back(vtaps); d_channel_map[i] = i; } @@ -60,19 +61,12 @@ pfb_synthesizer_ccf_impl::pfb_synthesizer_ccf_impl(unsigned int numchans, set_taps(taps); // Create the IFFT to handle the input channel rotations - d_fft = new fft::fft_complex(d_twox * d_numchans, false); - std::fill_n(d_fft->get_inbuf(), d_twox * d_numchans, 0); + std::fill_n(d_fft.get_inbuf(), d_twox * d_numchans, 0); set_output_multiple(d_numchans); } -pfb_synthesizer_ccf_impl::~pfb_synthesizer_ccf_impl() -{ - delete d_fft; - for (unsigned int i = 0; i < d_twox * d_numchans; i++) { - delete d_filters[i]; - } -} +pfb_synthesizer_ccf_impl::~pfb_synthesizer_ccf_impl() {} void pfb_synthesizer_ccf_impl::set_taps(const std::vector<float>& taps) { @@ -125,7 +119,7 @@ void pfb_synthesizer_ccf_impl::set_taps1(const std::vector<float>& taps) } // Set the filter taps for each channel - d_filters[i]->set_taps(d_taps[i]); + d_filters[i].set_taps(d_taps[i]); } } @@ -178,8 +172,8 @@ void pfb_synthesizer_ccf_impl::set_taps2(const std::vector<float>& taps) } // Set the filter taps for each channel - d_filters[i]->set_taps(d_taps[i]); - d_filters[d_numchans + i]->set_taps(d_taps[d_numchans + i]); + d_filters[i].set_taps(d_taps[i]); + d_filters[d_numchans + i].set_taps(d_taps[d_numchans + i]); } } @@ -212,7 +206,7 @@ void pfb_synthesizer_ccf_impl::set_channel_map(const std::vector<int>& map) d_channel_map = map; // Zero out fft buffer so that unused channels are always 0 - std::fill_n(d_fft->get_inbuf(), d_twox * d_numchans, 0); + std::fill_n(d_fft.get_inbuf(), d_twox * d_numchans, 0); } } @@ -240,14 +234,14 @@ int pfb_synthesizer_ccf_impl::work(int noutput_items, for (n = 0; n < noutput_items / d_numchans; n++) { for (i = 0; i < ninputs; i++) { in = (gr_complex*)input_items[i]; - d_fft->get_inbuf()[d_channel_map[i]] = in[n]; + d_fft.get_inbuf()[d_channel_map[i]] = in[n]; } // spin through IFFT - d_fft->execute(); + d_fft.execute(); for (i = 0; i < d_numchans; i++) { - out[i] = d_filters[i]->filter(d_fft->get_outbuf()[i]); + out[i] = d_filters[i].filter(d_fft.get_outbuf()[i]); } out += d_numchans; } @@ -259,20 +253,20 @@ int pfb_synthesizer_ccf_impl::work(int noutput_items, for (i = 0; i < ninputs; i++) { // in = (gr_complex*)input_items[ninputs-i-1]; in = (gr_complex*)input_items[i]; - d_fft->get_inbuf()[d_channel_map[i]] = in[n]; + d_fft.get_inbuf()[d_channel_map[i]] = in[n]; } // spin through IFFT - d_fft->execute(); + d_fft.execute(); // Output is sum of two filters, but the input buffer to the filters must be // circularly shifted by numchans every time through, done by using d_state to // determine which IFFT buffer position to pull from. for (i = 0; i < d_numchans; i++) { out[i] = - d_filters[i]->filter(d_fft->get_outbuf()[d_state * d_numchans + i]); - out[i] += d_filters[d_numchans + i]->filter( - d_fft->get_outbuf()[(d_state ^ 1) * d_numchans + i]); + d_filters[i].filter(d_fft.get_outbuf()[d_state * d_numchans + i]); + out[i] += d_filters[d_numchans + i].filter( + d_fft.get_outbuf()[(d_state ^ 1) * d_numchans + i]); } d_state ^= 1; diff --git a/gr-filter/lib/pfb_synthesizer_ccf_impl.h b/gr-filter/lib/pfb_synthesizer_ccf_impl.h index d5aa24398a..e24f5dcbcd 100644 --- a/gr-filter/lib/pfb_synthesizer_ccf_impl.h +++ b/gr-filter/lib/pfb_synthesizer_ccf_impl.h @@ -30,12 +30,12 @@ private: bool d_updated; unsigned int d_numchans; unsigned int d_taps_per_filter; - fft::fft_complex* d_fft; - std::vector<kernel::fir_filter_with_buffer_ccf*> d_filters; + std::vector<kernel::fir_filter_with_buffer_ccf> d_filters; std::vector<std::vector<float>> d_taps; int d_state; std::vector<int> d_channel_map; unsigned int d_twox; + fft::fft_complex d_fft; gr::thread::mutex d_mutex; // mutex to protect set/work access /*! diff --git a/gr-filter/lib/polyphase_filterbank.cc b/gr-filter/lib/polyphase_filterbank.cc index b46ddeb05c..a44309e70b 100644 --- a/gr-filter/lib/polyphase_filterbank.cc +++ b/gr-filter/lib/polyphase_filterbank.cc @@ -22,33 +22,23 @@ namespace kernel { polyphase_filterbank::polyphase_filterbank(unsigned int nfilts, const std::vector<float>& taps, bool fft_forward) - : d_nfilts(nfilts) + : d_nfilts(nfilts), d_fft(nfilts, fft_forward) { - d_fir_filters = std::vector<kernel::fir_filter_ccf*>(d_nfilts); - d_fft_filters = std::vector<kernel::fft_filter_ccf*>(d_nfilts); + d_fir_filters.reserve(d_nfilts); + d_fft_filters.reserve(d_nfilts); // Create an FIR filter for each channel and zero out the taps std::vector<float> vtaps(1, 0.0f); for (unsigned int i = 0; i < d_nfilts; i++) { - d_fir_filters[i] = new kernel::fir_filter_ccf(1, vtaps); - d_fft_filters[i] = new kernel::fft_filter_ccf(1, vtaps); + d_fir_filters.emplace_back(1, vtaps); + d_fft_filters.emplace_back(1, vtaps); } // Now, actually set the filters' taps set_taps(taps); - - // Create the FFT to handle the output de-spinning of the channels - d_fft = new fft::fft_complex(d_nfilts, fft_forward); } -polyphase_filterbank::~polyphase_filterbank() -{ - delete d_fft; - for (unsigned int i = 0; i < d_nfilts; i++) { - delete d_fir_filters[i]; - delete d_fft_filters[i]; - } -} +polyphase_filterbank::~polyphase_filterbank() {} void polyphase_filterbank::set_taps(const std::vector<float>& taps) { @@ -75,8 +65,8 @@ void polyphase_filterbank::set_taps(const std::vector<float>& taps) } // Set the filter taps for each channel - d_fir_filters[i]->set_taps(d_taps[i]); - d_fft_filters[i]->set_taps(d_taps[i]); + d_fir_filters[i].set_taps(d_taps[i]); + d_fft_filters[i].set_taps(d_taps[i]); } } diff --git a/gr-filter/lib/qa_fir_filter_with_buffer.cc b/gr-filter/lib/qa_fir_filter_with_buffer.cc index 3f896e40bb..6cb9e16d19 100644 --- a/gr-filter/lib/qa_fir_filter_with_buffer.cc +++ b/gr-filter/lib/qa_fir_filter_with_buffer.cc @@ -110,12 +110,11 @@ void test_decimate(unsigned int decimate) // build filter vector<tap_type> f1_taps(&taps[0], &taps[n]); - kernel::fir_filter_with_buffer_fff* f1 = - new kernel::fir_filter_with_buffer_fff(f1_taps); + kernel::fir_filter_with_buffer_fff f1(f1_taps); // zero the output, then do the filtering memset(actual_output, 0, OUTPUT_LEN * sizeof(o_type)); - f1->filterNdec(actual_output, input, ol / decimate, decimate); + f1.filterNdec(actual_output, input, ol / decimate, decimate); // check results // @@ -128,7 +127,6 @@ void test_decimate(unsigned int decimate) BOOST_CHECK(std::abs(expected_output[o] - actual_output[o]) <= sqrt((float)n) * 0.25 * MAX_DATA * MAX_DATA * ERR_DELTA); } - delete f1; } } volk_free(input); @@ -213,12 +211,11 @@ void test_decimate(unsigned int decimate) // build filter vector<tap_type> f1_taps(&taps[0], &taps[n]); - kernel::fir_filter_with_buffer_ccc* f1 = - new kernel::fir_filter_with_buffer_ccc(f1_taps); + kernel::fir_filter_with_buffer_ccc f1(f1_taps); // zero the output, then do the filtering std::fill_n(actual_output, OUTPUT_LEN, 0); - f1->filterNdec(actual_output, input, ol / decimate, decimate); + f1.filterNdec(actual_output, input, ol / decimate, decimate); // check results // @@ -231,7 +228,6 @@ void test_decimate(unsigned int decimate) BOOST_CHECK(std::abs(expected_output[o] - actual_output[o]) <= sqrt((float)n) * 0.25 * MAX_DATA * MAX_DATA * ERR_DELTA); } - delete f1; } } volk_free(input); @@ -314,12 +310,11 @@ void test_decimate(unsigned int decimate) // build filter vector<tap_type> f1_taps(&taps[0], &taps[n]); - kernel::fir_filter_with_buffer_ccf* f1 = - new kernel::fir_filter_with_buffer_ccf(f1_taps); + kernel::fir_filter_with_buffer_ccf f1(f1_taps); // zero the output, then do the filtering std::fill_n(actual_output, OUTPUT_LEN, 0); - f1->filterNdec(actual_output, input, ol / decimate, decimate); + f1.filterNdec(actual_output, input, ol / decimate, decimate); // check results // @@ -332,7 +327,6 @@ void test_decimate(unsigned int decimate) BOOST_CHECK(std::abs(expected_output[o] - actual_output[o]) <= sqrt((float)n) * 0.25 * MAX_DATA * MAX_DATA * ERR_DELTA); } - delete f1; } } volk_free(input); diff --git a/gr-filter/lib/rational_resampler_base_impl.cc b/gr-filter/lib/rational_resampler_base_impl.cc index 1cdf5095ee..06b5f50644 100644 --- a/gr-filter/lib/rational_resampler_base_impl.cc +++ b/gr-filter/lib/rational_resampler_base_impl.cc @@ -38,10 +38,8 @@ rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::rational_resampler_base_impl( io_signature::make(1, 1, sizeof(IN_T)), io_signature::make(1, 1, sizeof(OUT_T))), d_history(1), - d_interpolation(interpolation), d_decimation(decimation), d_ctr(0), - d_firs(interpolation), d_updated(false) { if (interpolation == 0) @@ -54,10 +52,9 @@ rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::rational_resampler_base_impl( this->set_relative_rate((uint64_t)interpolation, (uint64_t)decimation); this->set_output_multiple(1); - std::vector<TAP_T> dummy_taps; - + d_firs.reserve(interpolation); for (unsigned i = 0; i < interpolation; i++) { - d_firs[i] = new kernel::fir_filter<IN_T, OUT_T, TAP_T>(1, dummy_taps); + d_firs.emplace_back(1, std::vector<TAP_T>()); } set_taps(taps); @@ -67,10 +64,6 @@ rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::rational_resampler_base_impl( template <class IN_T, class OUT_T, class TAP_T> rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::~rational_resampler_base_impl() { - int interp = this->interpolation(); - for (int i = 0; i < interp; i++) { - delete d_firs[i]; - } } template <class IN_T, class OUT_T, class TAP_T> @@ -110,7 +103,7 @@ void rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::install_taps( xtaps[i % nfilters][i / nfilters] = taps[i]; for (int n = 0; n < nfilters; n++) - d_firs[n]->set_taps(xtaps[n]); + d_firs[n].set_taps(xtaps[n]); set_history(nt); d_updated = false; @@ -155,7 +148,7 @@ int rational_resampler_base_impl<IN_T, OUT_T, TAP_T>::general_work( int i = 0; while ((i < noutput_items) && (count < ninput_items[0])) { - out[i++] = d_firs[ctr]->filter(in); + out[i++] = d_firs[ctr].filter(in); ctr += this->decimation(); while (ctr >= this->interpolation()) { ctr -= this->interpolation(); diff --git a/gr-filter/lib/rational_resampler_base_impl.h b/gr-filter/lib/rational_resampler_base_impl.h index 5ab88d673c..52408660f3 100644 --- a/gr-filter/lib/rational_resampler_base_impl.h +++ b/gr-filter/lib/rational_resampler_base_impl.h @@ -23,11 +23,10 @@ class FILTER_API rational_resampler_base_impl { private: unsigned d_history; - unsigned d_interpolation; unsigned d_decimation; unsigned d_ctr; std::vector<TAP_T> d_new_taps; - std::vector<kernel::fir_filter<IN_T, OUT_T, TAP_T>*> d_firs; + std::vector<kernel::fir_filter<IN_T, OUT_T, TAP_T>> d_firs; bool d_updated; void install_taps(const std::vector<TAP_T>& taps); @@ -42,7 +41,7 @@ public: unsigned history() const { return d_history; } void set_history(unsigned history) { d_history = history; } - unsigned interpolation() const { return d_interpolation; } + unsigned interpolation() const { return d_firs.size(); } unsigned decimation() const { return d_decimation; } void set_taps(const std::vector<TAP_T>& taps); |