Line data    Source code

       1             : /**
       2             :  * \file WrapFilter.cpp
       3             :  */
       4             : 
       5             : #include "WrapFilter.h"
       6             : #include <ATK/Core/Utilities.h>
       7             : 
       8             : #include <algorithm>
       9             : 
      10             : namespace ATK
      11             : {
      12             : template <typename DataType_, typename DataType__>
      13           3 : WrapFilter<DataType_, DataType__>::WrapFilter(gsl::index nb_input_ports,
      14             :     gsl::index nb_output_ports,
      15             :     const std::function<void(std::vector<InPointerFilter<DataType_>>& inputFilters,
      16             :         std::vector<OutPointerFilter<DataType__>>& outputFilters,
      17             :         std::vector<gsl::unique_ptr<BaseFilter>>& filters)>& fun)
      18           3 :   : Parent(nb_input_ports, nb_output_ports)
      19             : {
      20           7 :   for(size_t i = 0; i < nb_input_ports; ++i)
      21             :   {
      22           4 :     inputFilters.emplace_back(nullptr, 1, 0, false);
      23             :   }
      24           9 :   for(size_t i = 0; i < nb_output_ports; ++i)
      25             :   {
      26           6 :     outputFilters.emplace_back(nullptr, 1, 0, false);
      27             :   }
      28           9 :   for(size_t i = 0; i < nb_output_ports; ++i)
      29             :   {
      30           6 :     sink.add_filter(&outputFilters[i]);
      31             :   }
      32             : 
      33           3 :   fun(inputFilters, outputFilters, filters);
      34           3 : }
      35             : 
      36             : template <typename DataType_, typename DataType__>
      37           6 : void WrapFilter<DataType_, DataType__>::full_setup()
      38             : {
      39          14 :   for(auto& filter: inputFilters)
      40             :   {
      41           8 :     filter.set_input_sampling_rate(get_input_sampling_rate());
      42           8 :     filter.set_output_sampling_rate(get_input_sampling_rate());
      43             :   }
      44          18 :   for(auto& filter: outputFilters)
      45             :   {
      46          12 :     filter.set_input_sampling_rate(get_output_sampling_rate());
      47          12 :     filter.set_output_sampling_rate(get_output_sampling_rate());
      48             :   }
      49           6 :   for(auto& filter: filters)
      50             :   {
      51           0 :     filter->set_input_sampling_rate(get_input_sampling_rate());
      52           0 :     filter->set_output_sampling_rate(get_output_sampling_rate());
      53             :   }
      54           6 :   sink.set_input_sampling_rate(get_input_sampling_rate());
      55           6 :   sink.set_output_sampling_rate(get_output_sampling_rate());
      56           6 : }
      57             : 
      58             : template <typename DataType_, typename DataType__>
      59           0 : void WrapFilter<DataType_, DataType__>::dry_run(gsl::index size)
      60             : {
      61           0 :   reset();
      62           0 :   sink.dryrun(size);
      63           0 : }
      64             : 
      65             : template <typename DataType_, typename DataType__>
      66           3 : void WrapFilter<DataType_, DataType__>::process_impl(gsl::index size) const
      67             : {
      68           7 :   for(size_t i = 0; i < inputFilters.size(); ++i)
      69             :   {
      70           4 :     inputFilters[i].set_pointer(converted_inputs[i], size);
      71             :   }
      72           9 :   for(size_t i = 0; i < outputFilters.size(); ++i)
      73             :   {
      74           6 :     outputFilters[i].set_pointer(outputs[i], size);
      75             :   }
      76             : 
      77           3 :   sink.process(size);
      78           3 : }
      79             : 
      80             : template class WrapFilter<int64_t>;
      81             : template class WrapFilter<float>;
      82             : template class WrapFilter<double>;
      83             : } // namespace ATK