Line data    Source code

       1             : /**
       2             :  * \file AttackReleaseFilter.cpp
       3             :  */
       4             : 
       5             : #include "AttackReleaseFilter.h"
       6             : #include <ATK/Core/Utilities.h>
       7             : 
       8             : #include <cassert>
       9             : #include <cstdint>
      10             : 
      11             : namespace ATK
      12             : {
      13             :   template<typename DataType_>
      14           7 :   AttackReleaseFilter<DataType_>::AttackReleaseFilter(gsl::index nb_channels)
      15           7 :   :Parent(nb_channels, nb_channels)
      16             :   {
      17           7 :     output_delay = 1;
      18           7 :   }
      19             : 
      20             :   template<typename DataType_>
      21           4 :   void AttackReleaseFilter<DataType_>::set_attack(DataType_ attack)
      22             :   {
      23           4 :     if(attack < 0)
      24             :     {
      25           1 :       throw ATK::RuntimeError("Attack factor must be positive value");
      26             :     }
      27           3 :     if(attack > 1)
      28             :     {
      29           1 :       throw ATK::RuntimeError("Attack factor must be less than 1");
      30             :     }
      31           2 :     this->attack = attack;
      32           2 :   }
      33             :   
      34             :   template<typename DataType_>
      35           1 :   DataType_ AttackReleaseFilter<DataType_>::get_attack() const
      36             :   {
      37           1 :     return attack;
      38             :   }
      39             : 
      40             :   template<typename DataType_>
      41           4 :   void AttackReleaseFilter<DataType_>::set_release(DataType_ release)
      42             :   {
      43           4 :     if(release < 0)
      44             :     {
      45           1 :       throw ATK::RuntimeError("Release factor must be positive value");
      46             :     }
      47           3 :     if(release > 1)
      48             :     {
      49           1 :       throw ATK::RuntimeError("Release factor must be less than 1");
      50             :     }
      51           2 :     this->release = release;
      52           2 :   }
      53             : 
      54             :   template<typename DataType_>
      55           1 :   DataType_ AttackReleaseFilter<DataType_>::get_release() const
      56             :   {
      57           1 :     return release;
      58             :   }
      59             : 
      60             :   template<typename DataType_>
      61           1 :   void AttackReleaseFilter<DataType_>::process_impl(gsl::index size) const
      62             :   {
      63           1 :     assert(nb_input_ports == nb_output_ports);
      64           2 :     for(gsl::index channel = 0; channel < nb_input_ports; ++channel)
      65             :     {
      66           1 :       const DataType* ATK_RESTRICT input = converted_inputs[channel];
      67           1 :       DataType* ATK_RESTRICT output = outputs[channel];
      68       65537 :       for(gsl::index i = 0; i < size; ++i)
      69             :       {
      70       65536 :         if(output[i-1] > input[i])
      71             :         {
      72           0 :           output[i] = (1 - release) * input[i] + release * output[i-1];//release phase
      73             :         }
      74             :         else
      75             :         {
      76       65536 :           output[i] = (1 - attack) * input[i] + attack * output[i-1];//attack phase
      77             :         }
      78             :       }
      79             :     }
      80           1 :   }
      81             :   
      82             : #if ATK_ENABLE_INSTANTIATION
      83             :   template class AttackReleaseFilter<float>;
      84             : #endif
      85             :   template class AttackReleaseFilter<double>;
      86             : }