Find dirac in wave file - c++

Question

This is about room correction.
I have a reference wave file, which is played back via a stereo amplifier and recorded using a microphone (umik 1).
Now my problem is that I have to manually find the diracs (loud „clicks“) inserted into the reference audio, and manually calculate the clock drift of the microphone. For example, in the reference file the click is at 0.5s and another one at 62s.
In the file recorded the clicks are slightly off. I‘m currently checking the wave file and calculate the actual clock / sample rate from the actual recorded distance between the two clicks.
How can I recognize this click in code, and get required info to do the calculations?

Answer 1

You can:
go forward in the audio signal and find the first sample whose absolute value is above the noise_level threshold
then, walk back from that location to find the first zero-crossing.
find_relevant_start implements this, and you can use it like so:
// You may need to adjust `noise_level` based on the characteristics of your audio.
constexpr auto noise_level = 0.1f;
std::vector<float> audio;
auto it = find_relevant_start(audio.begin(), audio.end(), noise_level);
if(it==audio.end()) {
// not found, maybe 'noise_level' was too high?
}
This is the code (from a personal project):
/*
* #param abs_relevant_level : if the absolute value of the signal
* is bigger than this value, it is considered to be relevant.
* Use a non-zero value if your signal contains noise.
*/
template<typename ITER, typename VAL = typename ITER::value_type>
ITER first_relevant_value(ITER it, ITER end, VAL abs_relevant_level) {
for(; it != end; ++ it ) {
if(std::abs(*it) > abs_relevant_level) {
break;
}
}
return it;
}
template<typename ITER>
ITER first_zero_crossing(ITER it, ITER end) {
using VAL = typename ITER::value_type;
using Tr = NumTraits<VAL>;
bool first = true;
VAL prev;
while(it != end) {
auto cur = *it;
if(cur == Tr::zero()) {
break;
}
if(first) {
first = false;
}
else if(prev * cur < Tr::zero()) {
break;
}
prev = cur;
++it;
}
return it;
}
template<typename ITER, typename VAL = typename ITER::value_type>
ITER find_relevant_start(ITER it, ITER end, VAL abs_relevant_level) {
auto it_relevant_value = first_relevant_value(it, end, abs_relevant_level);
if(it_relevant_value == end) {
return end;
}
using REVERSE_ITER = std::reverse_iterator<ITER>;
auto rit = REVERSE_ITER(it_relevant_value + 1);
auto rend = REVERSE_ITER(it);
auto rzero = first_zero_crossing( rit, rend);
// first_zero_crossing returns the iterator after the zero crossing (in the reverse direction)
// so rzero.base() is the iterator on the other side of the zero crossing
return rzero.base();
}
These unit tests will show you how it performs on simple arrays:
TEST(Peaks, find_relevant_start)
{
using namespace imajuscule;
{
std::vector<float> v{ -0.04f, -0.03f, -0.02f, -0.01f, 0.1f, 0.2f, 0.3f };
auto it = find_relevant_start(v.begin(), v.end(), 0.15f);
ASSERT_EQ(0.1f, *it);
}
{
std::vector<float> v{ -0.04f, -0.03f, -0.02f, -0.01f, 0.1f, 0.2f, 0.3f };
auto it = find_relevant_start(v.begin(), v.end(), 0.25f);
// the algorithm finds the first relevant value, and goes backward from there to find the first sign change and returns the sample just after
ASSERT_EQ(0.1f, *it);
}
{
std::vector<float> v{ 0.04f, 0.03f, 0.02f, 0.01f, -0.1f, -0.2f, -0.3f };
auto it = find_relevant_start(v.begin(), v.end(), 0.25f);
// the algorithm finds the first relevant value, and goes backward from there to find the first sign change and returns the sample just after
ASSERT_EQ(-0.1f, *it);
}
{
std::vector<float> v{ -0.04f, -0.03f, -0.02f, -0.01f, 0.1f, 0.2f, 0.3f };
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
// the level is too high and was never reached so "end" should be returned
ASSERT_EQ(v.end(), it);
}
{
std::vector<float> v{ 1.f, 2.f, 1.f };
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(v.begin(), it);
}
{
std::vector<float> v{ -1.f, -2.f, -1.f };
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(v.begin(), it);
}
{
std::vector<float> v;
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(v.end(), it);
}
{
std::vector<float> v{.1f};
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(v.end(), it);
}
{
std::vector<float> v{1.f};
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(1.f, *it);
}
{
std::vector<float> v{-1.f};
auto it = find_relevant_start(v.begin(), v.end(), 0.5f);
ASSERT_EQ(-1.f, *it);
}
}