Check for audio noise and pops

cover

 lib/igt_audio.c       | 58 ++++++++++++++++++++++++++++++++++++++----
 lib/tests/igt_audio.c | 59 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+), 5 deletions(-)
---
 lib/igt_audio.c | 58 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 53 insertions(+), 5 deletions(-)
index 08c0fb6af0db..e0b1bafe1be2 100644
@@ -39,6 +39,17 @@
 #define CHANNELS_MAX 8
 #define SYNTHESIZE_AMPLITUDE 0.9
 #define SYNTHESIZE_ACCURACY 0.2
+/** MIN_FREQ: minimum frequency that audio_signal can generate.
+ *
+ * To make sure the audio signal doesn't contain noise, #audio_signal_detect
+ * checks that low frequencies have a power lower than #NOISE_THRESHOLD.
+ * However if too-low frequencies are generated, noise detection can fail.
+ *
+ * This value should be at least 100Hz plus one bin. Best is not to change this
+ * value.
+ */
+#define MIN_FREQ 200 /* Hz */
+#define NOISE_THRESHOLD 0.0005
 
 /**
  * SECTION:igt_audio

@@ -108,6 +119,7 @@ int audio_signal_add_frequency(struct audio_signal *signal, int frequency,
 
 	igt_assert(index < FREQS_MAX);
 	igt_assert(channel < signal->channels);
+	igt_assert(frequency >= MIN_FREQ);
 
 	/* Stay within the Nyquist–Shannon sampling theorem. */
 	if (frequency > signal->sampling_rate / 2) {

@@ -304,6 +316,12 @@ void audio_signal_fill(struct audio_signal *signal, double *buffer,
 	audio_sanity_check(buffer, signal->channels * samples);
 }
 
+/* See https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows */
+static double hann_window(double v, size_t i, size_t N)
+{
+	return v * 0.5 * (1 - cos(2.0 * M_PI * (double) i / (double) N));
+}
+
 /**
  * Checks that frequencies specified in signal, and only those, are included
  * in the input data.

@@ -328,6 +346,16 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 	data = malloc(samples_len * sizeof(double));
 	memcpy(data, samples, samples_len * sizeof(double));
 
+	/* Apply a Hann window to the input signal, to reduce frequency leaks
+	 * due to the endpoints of the signal being discontinuous.
+	 *
+	 * For more info:
+	 * - https://download.ni.com/evaluation/pxi/Understanding%20FFTs%20and%20Windowing.pdf
+	 * - https://en.wikipedia.org/wiki/Window_function
+	 */
+	for (i = 0; i < data_len; i++)
+		data[i] = hann_window(data[i], i, data_len);
+
 	/* Allowed error in Hz due to FFT step */
 	freq_accuracy = sampling_rate / data_len;
 	igt_debug("Allowed freq. error: %d Hz\n", freq_accuracy);

@@ -338,8 +366,7 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 		igt_assert(0);
 	}
 
-	/* Compute the power received by every bin of the FFT, and record the
-	 * maximum power received as a way to normalize all the others.
+	/* Compute the power received by every bin of the FFT.
 	 *
 	 * For i < data_len / 2, the real part of the i-th term is stored at
 	 * data[i] and its imaginary part is stored at data[data_len - i].

@@ -349,15 +376,36 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 	 * The power is encoded as the magnitude of the complex number and the
 	 * phase is encoded as its angle.
 	 */
-	max = 0;
 	bin_power[0] = data[0];
 	for (i = 1; i < bin_power_len - 1; i++) {
 		bin_power[i] = hypot(data[i], data[data_len - i]);
-		if (bin_power[i] > max)
-			max = bin_power[i];
 	}
 	bin_power[bin_power_len - 1] = data[data_len / 2];
 
+	/* Normalize the power */
+	for (i = 0; i < bin_power_len; i++)
+		bin_power[i] = 2 * bin_power[i] / data_len;
+
+	/* Detect noise with a threshold on the power of low frequencies */
+	for (i = 0; i < bin_power_len; i++) {
+		freq = sampling_rate * i / data_len;
+		if (freq > MIN_FREQ - 100)
+			break;
+		if (bin_power[i] > NOISE_THRESHOLD) {
+			igt_debug("Noise level too high: freq=%d power=%f\n",
+				  freq, bin_power[i]);
+			return false;
+		}
+	}
+
+	/* Record the maximum power received as a way to normalize all the
+	 * others. */
+	max = NAN;
+	for (i = 0; i < bin_power_len; i++) {
+		if (isnan(max) || bin_power[i] > max)
+			max = bin_power[i];
+	}
+
 	for (i = 0; i < signal->freqs_count; i++)
 		detected[i] = false;
 

2.21.0

_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev
---
 lib/igt_audio.c | 58 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 53 insertions(+), 5 deletions(-)
index 08c0fb6af0db..e0b1bafe1be2 100644
@@ -39,6 +39,17 @@
 #define CHANNELS_MAX 8
 #define SYNTHESIZE_AMPLITUDE 0.9
 #define SYNTHESIZE_ACCURACY 0.2
+/** MIN_FREQ: minimum frequency that audio_signal can generate.
+ *
+ * To make sure the audio signal doesn't contain noise, #audio_signal_detect
+ * checks that low frequencies have a power lower than #NOISE_THRESHOLD.
+ * However if too-low frequencies are generated, noise detection can fail.
+ *
+ * This value should be at least 100Hz plus one bin. Best is not to change this
+ * value.
+ */
+#define MIN_FREQ 200 /* Hz */
+#define NOISE_THRESHOLD 0.0005
 
 /**
  * SECTION:igt_audio

@@ -108,6 +119,7 @@ int audio_signal_add_frequency(struct audio_signal *signal, int frequency,
 
 	igt_assert(index < FREQS_MAX);
 	igt_assert(channel < signal->channels);
+	igt_assert(frequency >= MIN_FREQ);
 
 	/* Stay within the Nyquist–Shannon sampling theorem. */
 	if (frequency > signal->sampling_rate / 2) {

@@ -304,6 +316,12 @@ void audio_signal_fill(struct audio_signal *signal, double *buffer,
 	audio_sanity_check(buffer, signal->channels * samples);
 }
 
+/* See https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows */
+static double hann_window(double v, size_t i, size_t N)
+{
+	return v * 0.5 * (1 - cos(2.0 * M_PI * (double) i / (double) N));
+}
+
 /**
  * Checks that frequencies specified in signal, and only those, are included
  * in the input data.

@@ -328,6 +346,16 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 	data = malloc(samples_len * sizeof(double));
 	memcpy(data, samples, samples_len * sizeof(double));
 
+	/* Apply a Hann window to the input signal, to reduce frequency leaks
+	 * due to the endpoints of the signal being discontinuous.
+	 *
+	 * For more info:
+	 * - https://download.ni.com/evaluation/pxi/Understanding%20FFTs%20and%20Windowing.pdf
+	 * - https://en.wikipedia.org/wiki/Window_function
+	 */
+	for (i = 0; i < data_len; i++)
+		data[i] = hann_window(data[i], i, data_len);
+
 	/* Allowed error in Hz due to FFT step */
 	freq_accuracy = sampling_rate / data_len;
 	igt_debug("Allowed freq. error: %d Hz\n", freq_accuracy);

@@ -338,8 +366,7 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 		igt_assert(0);
 	}
 
-	/* Compute the power received by every bin of the FFT, and record the
-	 * maximum power received as a way to normalize all the others.
+	/* Compute the power received by every bin of the FFT.
 	 *
 	 * For i < data_len / 2, the real part of the i-th term is stored at
 	 * data[i] and its imaginary part is stored at data[data_len - i].

@@ -349,15 +376,36 @@ bool audio_signal_detect(struct audio_signal *signal, int sampling_rate,
 	 * The power is encoded as the magnitude of the complex number and the
 	 * phase is encoded as its angle.
 	 */
-	max = 0;
 	bin_power[0] = data[0];
 	for (i = 1; i < bin_power_len - 1; i++) {
 		bin_power[i] = hypot(data[i], data[data_len - i]);
-		if (bin_power[i] > max)
-			max = bin_power[i];
 	}
 	bin_power[bin_power_len - 1] = data[data_len / 2];
 
+	/* Normalize the power */
+	for (i = 0; i < bin_power_len; i++)
+		bin_power[i] = 2 * bin_power[i] / data_len;
+
+	/* Detect noise with a threshold on the power of low frequencies */
+	for (i = 0; i < bin_power_len; i++) {
+		freq = sampling_rate * i / data_len;
+		if (freq > MIN_FREQ - 100)
+			break;
+		if (bin_power[i] > NOISE_THRESHOLD) {
+			igt_debug("Noise level too high: freq=%d power=%f\n",
+				  freq, bin_power[i]);
+			return false;
+		}
+	}
+
+	/* Record the maximum power received as a way to normalize all the

+	 * others. */
+	max = NAN;
+	for (i = 0; i < bin_power_len; i++) {
+		if (isnan(max) || bin_power[i] > max)
+			max = bin_power[i];
+	}
+
 	for (i = 0; i < signal->freqs_count; i++)
 		detected[i] = false;
 

---
 lib/tests/igt_audio.c | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
index 47e61adf74fe..821813bae47a 100644
@@ -116,6 +116,26 @@ static void test_signal_detect_with_unexpected_freq(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_pop(struct audio_signal *signal)
+{
+	double *buf;
+	bool ok;
+	size_t i;
+
+	buf = malloc(BUFFER_LEN * sizeof(double));
+	audio_signal_fill(signal, buf, BUFFER_LEN / CHANNELS);
+
+	/* Add a discontinuity in the signal */
+	for (i = 0; i < 5; i++)
+		buf[BUFFER_LEN / 3 + i] = 0.9;
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);
+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -151,6 +171,9 @@ igt_main
 		igt_subtest("signal-detect-with-unexpected-freq")
 			test_signal_detect_with_unexpected_freq(signal);
 
+		igt_subtest("signal-detect-pop")
+			test_signal_detect_pop(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}

2.21.0

_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev
---
 lib/tests/igt_audio.c | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
index 47e61adf74fe..821813bae47a 100644

@@ -116,6 +116,26 @@ static void test_signal_detect_with_unexpected_freq(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_pop(struct audio_signal *signal)

+{
+	double *buf;
+	bool ok;
+	size_t i;
+
+	buf = malloc(BUFFER_LEN * sizeof(double));
+	audio_signal_fill(signal, buf, BUFFER_LEN / CHANNELS);
+
+	/* Add a discontinuity in the signal */
+	for (i = 0; i < 5; i++)
+		buf[BUFFER_LEN / 3 + i] = 0.9;
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);
+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -151,6 +171,9 @@ igt_main
 		igt_subtest("signal-detect-with-unexpected-freq")
 			test_signal_detect_with_unexpected_freq(signal);
 
+		igt_subtest("signal-detect-pop")
+			test_signal_detect_pop(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}

---
 lib/tests/igt_audio.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
index 47e61adf74fe..d18537d66fb7 100644
@@ -116,6 +116,28 @@ static void test_signal_detect_with_unexpected_freq(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_held_sample(struct audio_signal *signal)
+{
+	double *buf;
+	bool ok;
+	size_t i;
+	double value;
+
+	buf = malloc(BUFFER_LEN * sizeof(double));
+	audio_signal_fill(signal, buf, BUFFER_LEN / CHANNELS);
+
+	/* Repeat a sample in the middle of the signal */
+	value = buf[BUFFER_LEN / 3];
+	for (i = 0; i < 5; i++)
+		buf[BUFFER_LEN / 3 + i] = value;
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);
+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -151,6 +173,9 @@ igt_main
 		igt_subtest("signal-detect-with-unexpected-freq")
 			test_signal_detect_with_unexpected_freq(signal);
 
+		igt_subtest("signal-detect-held-sample")
+			test_signal_detect_held_sample(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}

---
 lib/tests/igt_audio.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
index 47e61adf74fe..d18537d66fb7 100644
@@ -116,6 +116,28 @@ static void test_signal_detect_with_unexpected_freq(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_held_sample(struct audio_signal *signal)
+{
+	double *buf;
+	bool ok;
+	size_t i;
+	double value;
+
+	buf = malloc(BUFFER_LEN * sizeof(double));
+	audio_signal_fill(signal, buf, BUFFER_LEN / CHANNELS);
+

+	/* Repeat a sample in the middle of the signal */
+	value = buf[BUFFER_LEN / 3];
+	for (i = 0; i < 5; i++)
+		buf[BUFFER_LEN / 3 + i] = value;
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);

+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -151,6 +173,9 @@ igt_main
 		igt_subtest("signal-detect-with-unexpected-freq")
 			test_signal_detect_with_unexpected_freq(signal);
 
+		igt_subtest("signal-detect-held-sample")
+			test_signal_detect_held_sample(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}
--

---
 lib/tests/igt_audio.c | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
index 821813bae47a..7c5279acc92e 100644
@@ -33,6 +33,8 @@
 #define SAMPLING_RATE 44100
 #define CHANNELS 1
 #define BUFFER_LEN 2048
+/** PHASESHIFT_LEN: how many samples will be truncated from the signal */
+#define PHASESHIFT_LEN 8
 
 static const int test_freqs[] = { 300, 700, 5000 };
 

@@ -136,6 +138,37 @@ static void test_signal_detect_pop(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_phaseshift(struct audio_signal *signal)
+{
+	double *buf;
+	bool ok;
+
+	buf = malloc((BUFFER_LEN + PHASESHIFT_LEN) * sizeof(double));
+	audio_signal_fill(signal, buf, (BUFFER_LEN + PHASESHIFT_LEN) / CHANNELS);
+
+	/* Perform a phaseshift (this isn't related to sirens).
+	 *
+	 * The idea is to remove a part of the signal in the middle of the
+	 * buffer:
+	 *
+	 *   BUFFER_LEN/3   PHASESHIFT_LEN            2*BUFFER_LEN/3
+	 * [--------------|################|---------------------------------]
+	 *
+	 *                           |
+	 *                           V
+	 *
+	 * [--------------|---------------------------------]
+	 */
+	memmove(&buf[BUFFER_LEN / 3], &buf[BUFFER_LEN / 3 + PHASESHIFT_LEN],
+		(2 * BUFFER_LEN / 3) * sizeof(double));
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);
+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -174,6 +207,9 @@ igt_main
 		igt_subtest("signal-detect-pop")
 			test_signal_detect_pop(signal);
 
+		igt_subtest("signal-detect-phaseshift")
+			test_signal_detect_phaseshift(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}

2.21.0

_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev
---
 lib/tests/igt_audio.c | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
index 821813bae47a..7c5279acc92e 100644
@@ -33,6 +33,8 @@
 #define SAMPLING_RATE 44100
 #define CHANNELS 1
 #define BUFFER_LEN 2048
+/** PHASESHIFT_LEN: how many samples will be truncated from the signal */
+#define PHASESHIFT_LEN 8
 
 static const int test_freqs[] = { 300, 700, 5000 };
 

@@ -136,6 +138,37 @@ static void test_signal_detect_pop(struct audio_signal *signal)
 	igt_assert(!ok);
 }
 
+static void test_signal_detect_phaseshift(struct audio_signal *signal)
+{
+	double *buf;
+	bool ok;
+
+	buf = malloc((BUFFER_LEN + PHASESHIFT_LEN) * sizeof(double));
+	audio_signal_fill(signal, buf, (BUFFER_LEN + PHASESHIFT_LEN) / CHANNELS);
+
+	/* Perform a phaseshift (this isn't related to sirens).
+	 *
+	 * The idea is to remove a part of the signal in the middle of the
+	 * buffer:
+	 *
+	 *   BUFFER_LEN/3   PHASESHIFT_LEN            2*BUFFER_LEN/3
+	 * [--------------|################|---------------------------------]
+	 *
+	 *                           |
+	 *                           V
+	 *
+	 * [--------------|---------------------------------]
+	 */
+	memmove(&buf[BUFFER_LEN / 3], &buf[BUFFER_LEN / 3 + PHASESHIFT_LEN],
+		(2 * BUFFER_LEN / 3) * sizeof(double));
+
+	ok = audio_signal_detect(signal, SAMPLING_RATE, 0, buf, BUFFER_LEN);
+
+	free(buf);
+
+	igt_assert(!ok);
+}
+
 igt_main
 {
 	struct audio_signal *signal;

@@ -174,6 +207,9 @@ igt_main
 		igt_subtest("signal-detect-pop")
 			test_signal_detect_pop(signal);
 
+		igt_subtest("signal-detect-phaseshift")
+			test_signal_detect_phaseshift(signal);
+
 		igt_fixture {
 			audio_signal_fini(signal);
 		}


Check for audio noise and pops

Simon Ser

Simon Ser

Martin Peres

Simon Ser

Martin Peres

Simon Ser

Martin Peres

Simon Ser

Martin Peres

Patchwork

Patchwork

Patchwork

Patchwork