kfr

commit 7c946c1e10e64d8662502955a338bd8e20178e13
parent 7503a880e8a4e05c602de6878129c7129547fbde
Author: d.levin256@gmail.com <d.levin256@gmail.com>
Date:   Wed,  9 Nov 2016 11:25:25 +0300

biquad filter: set zero latency version as default

Diffstat:
M
include/kfr/dsp/biquad.hpp
 | 
22
+++++++++++-----------

1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/include/kfr/dsp/biquad.hpp b/include/kfr/dsp/biquad.hpp
@@ -130,11 +130,11 @@ struct biquad_block
 };
 
 template <size_t filters, typename T, typename E1, KFR_ARCH_DEP>
-struct expression_biquads : public expression_base<E1>
+struct expression_biquads_l : public expression_base<E1>
 {
     using value_type = T;
 
-    expression_biquads(const biquad_block<T, filters>& bq, E1&& e1)
+    expression_biquads_l(const biquad_block<T, filters>& bq, E1&& e1)
         : expression_base<E1>(std::forward<E1>(e1)), bq(bq)
     {
     }
@@ -166,11 +166,11 @@ struct expression_biquads : public expression_base<E1>
 };
 
 template <size_t filters, typename T, typename E1, KFR_ARCH_DEP>
-struct expression_biquads_zl : expression_base<E1>
+struct expression_biquads : expression_base<E1>
 {
     using value_type = T;
 
-    expression_biquads_zl(const biquad_block<T, filters>& bq, E1&& e1)
+    expression_biquads(const biquad_block<T, filters>& bq, E1&& e1)
         : expression_base<E1>(std::forward<E1>(e1)), bq(bq), block_end(0)
     {
     }
@@ -266,9 +266,10 @@ CMT_INLINE internal::expression_biquads<1, T, E1> biquad(const biquad_params<T>&
  * @note This implementation introduces delay of N - 1 samples, where N is the filter count.
  */
 template <size_t filters, typename T, typename E1>
-CMT_INLINE internal::expression_biquads<filters, T, E1> biquad(const biquad_params<T> (&bq)[filters], E1&& e1)
+CMT_INLINE internal::expression_biquads_l<filters, T, E1> biquad_l(const biquad_params<T> (&bq)[filters],
+                                                                   E1&& e1)
 {
-    return internal::expression_biquads<filters, T, E1>(bq, std::forward<E1>(e1));
+    return internal::expression_biquads_l<filters, T, E1>(bq, std::forward<E1>(e1));
 }
 
 /**
@@ -278,10 +279,9 @@ CMT_INLINE internal::expression_biquads<filters, T, E1> biquad(const biquad_para
  * @note This implementation has zero latency
  */
 template <size_t filters, typename T, typename E1>
-CMT_INLINE internal::expression_biquads_zl<filters, T, E1> biquad_zl(const biquad_params<T> (&bq)[filters],
-                                                                     E1&& e1)
+CMT_INLINE internal::expression_biquads<filters, T, E1> biquad(const biquad_params<T> (&bq)[filters], E1&& e1)
 {
-    return internal::expression_biquads_zl<filters, T, E1>(bq, std::forward<E1>(e1));
+    return internal::expression_biquads<filters, T, E1>(bq, std::forward<E1>(e1));
 }
 
 /**
@@ -291,12 +291,12 @@ CMT_INLINE internal::expression_biquads_zl<filters, T, E1> biquad_zl(const biqua
  * @note This implementation has zero latency
  */
 template <typename T, typename E1>
-CMT_INLINE expression_pointer<T> biquad_zl(const biquad_params<T>* bq, size_t count, E1&& e1)
+CMT_INLINE expression_pointer<T> biquad(const biquad_params<T>* bq, size_t count, E1&& e1)
 {
     return cswitch(csizes_t<1, 2, 4, 8, 16, 32, 64>(), next_poweroftwo(count),
                    [&](auto x) {
                        constexpr size_t filters = x;
-                       return to_pointer(internal::expression_biquads_zl<filters, T, E1>(
+                       return to_pointer(internal::expression_biquads<filters, T, E1>(
                            internal::biquad_block<T, filters>(bq, count), std::forward<E1>(e1)));
                    },
                    [&] { return to_pointer(zeros<T>()); });