From 99b6ec2996e8d0fef2d12adcd6d5750e8281c42f Mon Sep 17 00:00:00 2001
From: Stefano D'Angelo <zanga.mail@gmail.com>
Date: Tue, 2 Jul 2024 11:28:45 +0200
Subject: [PATCH] this should be it

---
 include/bw_env_gen.h   |  2 +-
 include/bw_phaser.h    | 17 +++++++++++++++++
 include/bw_ppm.h       | 16 ++++++++++++++++
 include/bw_reverb.h    | 23 +++++++++++++++++++++++
 include/bw_ring_mod.h  | 13 +++++++++++++
 include/bw_satur.h     | 17 +++++++++++++++++
 include/bw_slew_lim.h  | 16 ++++++++++++++++
 include/bw_sr_reduce.h | 17 +++++++++++++++++
 include/bw_svf.h       | 18 ++++++++++++++++++
 include/bw_trem.h      | 17 +++++++++++++++++
 include/bw_wah.h       | 17 +++++++++++++++++
 11 files changed, 172 insertions(+), 1 deletion(-)

diff --git a/include/bw_env_gen.h b/include/bw_env_gen.h
index bd008ba..57b6503 100644
--- a/include/bw_env_gen.h
+++ b/include/bw_env_gen.h
@@ -40,7 +40,7 @@
  *  }}}
  *  changelog {{{
  *    <ul>
- *      <li>Version <strong>1.1.0</strong>:
+ *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
  *          <li>Added debugging checks from <code>bw_env_gen_process()</code> to
  *              <code>bw_env_gen_process_multi()</code>.</li>
diff --git a/include/bw_phaser.h b/include/bw_phaser.h
index 646f5d8..3aa7c61 100644
--- a/include/bw_phaser.h
+++ b/include/bw_phaser.h
@@ -32,6 +32,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_phaser_process()</code> to
+ *              <code>bw_phaser_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_phaser_process_multi()</code>
  *              to ensure that buffers used for both input and output appear at
  *              the same channel indices.</li>
@@ -552,6 +554,10 @@ static inline void bw_phaser_process_multi(
 	BW_ASSERT_DEEP(coeffs->center * bw_pow2f(coeffs->amount) >= 1e-6f && coeffs->center * bw_pow2f(coeffs->amount) <= 1e12f);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_phaser_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -562,6 +568,11 @@ static inline void bw_phaser_process_multi(
 	BW_ASSERT(x != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -576,6 +587,12 @@ static inline void bw_phaser_process_multi(
 
 	BW_ASSERT_DEEP(bw_phaser_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_phaser_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_phaser_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_phaser_set_rate(
diff --git a/include/bw_ppm.h b/include/bw_ppm.h
index 17efb39..8539349 100644
--- a/include/bw_ppm.h
+++ b/include/bw_ppm.h
@@ -32,6 +32,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_ppm_process()</code> to
+ *              <code>bw_ppm_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_ppm_process_multi()</code> to
  *              ensure that buffers used for both input and output appear at the
  *              same channel indices.</li>
@@ -510,12 +512,20 @@ static inline void bw_ppm_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_ppm_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_ppm_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
 #endif
 	BW_ASSERT(x != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+	}
 	if (y != BW_NULL) {
 		for (size_t i = 0; i < n_channels; i++)
 			for (size_t j = i + 1; j < n_channels; j++)
@@ -545,6 +555,12 @@ static inline void bw_ppm_process_multi(
 
 	BW_ASSERT_DEEP(bw_ppm_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_ppm_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_ppm_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(y != BW_NULL && y[i] != BW_NULL ? bw_has_only_finite(y[i], n_samples): 1);
+	}
+#endif
 }
 
 static inline void bw_ppm_set_integration_tau(
diff --git a/include/bw_reverb.h b/include/bw_reverb.h
index 8cdd33f..5f0744e 100644
--- a/include/bw_reverb.h
+++ b/include/bw_reverb.h
@@ -37,6 +37,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_reverb_process()</code> to
+ *              <code>bw_reverb_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_reverb_process_multi()</code>
  *              to ensure that buffers used for both input and output appear at
  *              the same channel indices.</li>
@@ -993,6 +995,11 @@ static inline void bw_reverb_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_reverb_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_reverb_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(state[i]->state >= bw_reverb_state_state_reset_state);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -1003,6 +1010,15 @@ static inline void bw_reverb_process_multi(
 	BW_ASSERT(y_r != BW_NULL);
 	BW_ASSERT(y_l != y_r);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x_l[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x_l[i], n_samples));
+		BW_ASSERT(x_r[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x_r[i], n_samples));
+		BW_ASSERT(y_l[i] != BW_NULL);
+		BW_ASSERT(y_r[i] != BW_NULL);
+		BW_ASSERT(y_l[i] != y_r[i]);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++) {
 			BW_ASSERT(y_l[i] != y_l[j]);
@@ -1029,6 +1045,13 @@ static inline void bw_reverb_process_multi(
 
 	BW_ASSERT_DEEP(bw_reverb_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_reverb_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_reverb_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y_l[i], n_samples));
+		BW_ASSERT_DEEP(bw_has_only_finite(y_r[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_reverb_set_predelay(
diff --git a/include/bw_ring_mod.h b/include/bw_ring_mod.h
index adf472c..2c43b1a 100644
--- a/include/bw_ring_mod.h
+++ b/include/bw_ring_mod.h
@@ -29,6 +29,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_ring_mod_process()</code>
+ *              to <code>bw_ring_mod_process_multi()</code>.</li>
  *          <li>Added debugging checks in
  *              <code>bw_ring_mod_process_multi()</code> to ensure that buffers
  *              used for both input and output appear at the same channel
@@ -367,6 +369,13 @@ static inline void bw_ring_mod_process_multi(
 	BW_ASSERT(x_car != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x_mod[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x_mod[i], n_samples));
+		BW_ASSERT(x_car[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x_car[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -385,6 +394,10 @@ static inline void bw_ring_mod_process_multi(
 
 	BW_ASSERT_DEEP(bw_ring_mod_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_ring_mod_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++)
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+#endif
 }
 
 static inline void bw_ring_mod_set_amount(
diff --git a/include/bw_satur.h b/include/bw_satur.h
index d397b3e..962d48a 100644
--- a/include/bw_satur.h
+++ b/include/bw_satur.h
@@ -47,6 +47,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_satur_process()</code> to
+ *              <code>bw_satur_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_satur_process_multi()</code>
  *              to ensure that buffers used for both input and output appear at
  *              the same channel indices.</li>
@@ -618,6 +620,10 @@ static inline void bw_satur_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_satur_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_satur_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -625,6 +631,11 @@ static inline void bw_satur_process_multi(
 	BW_ASSERT(x != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -649,6 +660,12 @@ static inline void bw_satur_process_multi(
 
 	BW_ASSERT_DEEP(bw_satur_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_satur_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_satur_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_satur_set_bias(
diff --git a/include/bw_slew_lim.h b/include/bw_slew_lim.h
index 09dba52..a5affa5 100644
--- a/include/bw_slew_lim.h
+++ b/include/bw_slew_lim.h
@@ -29,6 +29,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_slew_lim_process()</code>
+ *              to <code>bw_slew_lim_process_multi()</code>.</li>
  *          <li>Added debugging checks in
  *              <code>bw_slew_lim_process_multi()</code> to ensure that buffers
  *              used for both input and output appear at the same channel
@@ -679,12 +681,20 @@ static inline void bw_slew_lim_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_slew_lim_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_slew_lim_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
 #endif
 	BW_ASSERT(x != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+	}
 	if (y != BW_NULL) {
 		for (size_t i = 0; i < n_channels; i++)
 			for (size_t j = i + 1; j < n_channels; j++)
@@ -769,6 +779,12 @@ static inline void bw_slew_lim_process_multi(
 
 	BW_ASSERT_DEEP(bw_slew_lim_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_slew_lim_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_slew_lim_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(y != BW_NULL && y[i] != BW_NULL ? bw_has_only_finite(y[i], n_samples) : 1);
+	}
+#endif
 }
 
 static inline void bw_slew_lim_set_max_rate(
diff --git a/include/bw_sr_reduce.h b/include/bw_sr_reduce.h
index 7023d5b..11e23a8 100644
--- a/include/bw_sr_reduce.h
+++ b/include/bw_sr_reduce.h
@@ -33,6 +33,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_sr_reduce_process()</code>
+ *              to <code>bw_sr_reduce_process_multi()</code>.</li>
  *          <li>Added debugging checks in
  *              <code>bw_sr_reduce_process_multi()</code> to ensure that buffers
  *              used for both input and output appear at the same channel
@@ -492,6 +494,10 @@ static inline void bw_sr_reduce_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_sr_reduce_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_sr_reduce_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -499,6 +505,11 @@ static inline void bw_sr_reduce_process_multi(
 	BW_ASSERT(x != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -512,6 +523,12 @@ static inline void bw_sr_reduce_process_multi(
 
 	BW_ASSERT_DEEP(bw_sr_reduce_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_sr_reduce_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_sr_reduce_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_sr_reduce_set_ratio(
diff --git a/include/bw_svf.h b/include/bw_svf.h
index ea2caa7..3c0b65b 100644
--- a/include/bw_svf.h
+++ b/include/bw_svf.h
@@ -30,6 +30,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_svf_process()</code> to
+ *              <code>bw_svf_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_svf_process_multi()</code> to
  *              ensure that buffers used for both input and output appear at the
  *              same channel indices.</li>
@@ -771,6 +773,10 @@ static inline void bw_svf_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_svf_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_svf_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -780,6 +786,10 @@ static inline void bw_svf_process_multi(
 	BW_ASSERT(y_lp == BW_NULL || y_hp == BW_NULL || y_lp != y_hp);
 	BW_ASSERT(y_bp == BW_NULL || y_hp == BW_NULL || y_bp != y_hp);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+	}
 	if (y_lp != BW_NULL) {
 		for (size_t i = 0; i < n_channels; i++)
 			for (size_t j = i + 1; j < n_channels; j++)
@@ -922,6 +932,14 @@ static inline void bw_svf_process_multi(
 
 	BW_ASSERT_DEEP(bw_svf_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_svf_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_svf_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(y_lp != BW_NULL && y_lp[i] != BW_NULL ? bw_has_only_finite(y_lp[i], n_samples) : 1);
+		BW_ASSERT_DEEP(y_bp != BW_NULL && y_bp[i] != BW_NULL ? bw_has_only_finite(y_bp[i], n_samples) : 1);
+		BW_ASSERT_DEEP(y_hp != BW_NULL && y_hp[i] != BW_NULL ? bw_has_only_finite(y_hp[i], n_samples) : 1);
+	}
+#endif
 }
 
 static inline void bw_svf_set_cutoff(
diff --git a/include/bw_trem.h b/include/bw_trem.h
index dd88fdf..65bbc7d 100644
--- a/include/bw_trem.h
+++ b/include/bw_trem.h
@@ -31,6 +31,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_trem_process()</code> to
+ *              <code>bw_trem_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_trem_process_multi()</code>
  *              to ensure that buffers used for both input and output appear at
  *              the same channel indices.</li>
@@ -508,6 +510,10 @@ static inline void bw_trem_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_trem_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_trem_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -515,6 +521,11 @@ static inline void bw_trem_process_multi(
 	BW_ASSERT(x != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -532,6 +543,12 @@ static inline void bw_trem_process_multi(
 
 	BW_ASSERT_DEEP(bw_trem_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_trem_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_trem_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_trem_set_rate(
diff --git a/include/bw_wah.h b/include/bw_wah.h
index d273291..3c368b5 100644
--- a/include/bw_wah.h
+++ b/include/bw_wah.h
@@ -31,6 +31,8 @@
  *    <ul>
  *      <li>Version <strong>1.1.1</strong>:
  *        <ul>
+ *          <li>Added debugging checks from <code>bw_wah_process()</code> to
+ *              <code>bw_wah_process_multi()</code>.</li>
  *          <li>Added debugging checks in <code>bw_wah_process_multi()</code> to
  *              ensure that buffers used for both input and output appear at the
  *              same channel indices.</li>
@@ -498,6 +500,10 @@ static inline void bw_wah_process_multi(
 	BW_ASSERT_DEEP(coeffs->state >= bw_wah_coeffs_state_reset_coeffs);
 	BW_ASSERT(state != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(state[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_wah_state_is_valid(coeffs, state[i]));
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(state[i] != state[j]);
@@ -505,6 +511,11 @@ static inline void bw_wah_process_multi(
 	BW_ASSERT(x != BW_NULL);
 	BW_ASSERT(y != BW_NULL);
 #ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT(x[i] != BW_NULL);
+		BW_ASSERT_DEEP(bw_has_only_finite(x[i], n_samples));
+		BW_ASSERT(y[i] != BW_NULL);
+	}
 	for (size_t i = 0; i < n_channels; i++)
 		for (size_t j = i + 1; j < n_channels; j++)
 			BW_ASSERT(y[i] != y[j]);
@@ -522,6 +533,12 @@ static inline void bw_wah_process_multi(
 
 	BW_ASSERT_DEEP(bw_wah_coeffs_is_valid(coeffs));
 	BW_ASSERT_DEEP(coeffs->state >= bw_wah_coeffs_state_reset_coeffs);
+#ifndef BW_NO_DEBUG
+	for (size_t i = 0; i < n_channels; i++) {
+		BW_ASSERT_DEEP(bw_wah_state_is_valid(coeffs, state[i]));
+		BW_ASSERT_DEEP(bw_has_only_finite(y[i], n_samples));
+	}
+#endif
 }
 
 static inline void bw_wah_set_wah(