MIR Namespace Reference

Namespaces
namespace	anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}
namespace	anonymous_namespace{MirDsp.cpp}
namespace	anonymous_namespace{MirUtils.cpp}
namespace	anonymous_namespace{MusicInformationRetrieval.cpp}
namespace	anonymous_namespace{MusicInformationRetrievalTests.cpp}
namespace	anonymous_namespace{StftFrameProvider.cpp}
namespace	anonymous_namespace{StftFrameProviderTests.cpp}
namespace	anonymous_namespace{TatumQuantizationFitBenchmarking.cpp}

Classes
class	AnalyzedAudioClip
class	DecimatingMirAudioReader
	Our MIR operations do not need the full 44.1 or 48kHz resolution typical of audio files. It may change in the future, if we start looking at chromagrams for example, but for now even a certain amount of aliasing isn't an issue. In fact, for onset detection, it may even be beneficial, since it preserves a trace of the highest frequency components by folding them down below the nyquist. Thus we can decimate the audio signal to a certain extent. This is fast and easy to implement, meanwhile reducing dramatically the amount of data and operations. More...
class	EmptyMirAudioReader
class	FakeAnalyzedAudioClip
class	FakeProjectInterface
struct	LoopClassifierSettings
class	MirAudioReader
struct	MusicalMeter
struct	OctaveError
struct	OnsetQuantization
class	ProjectInterface
struct	ProjectSyncInfo
struct	ProjectSyncInfoInput
struct	QuantizationFitDebugOutput
struct	RocInfo
class	SquareWaveMirAudioReader
class	StftFrameProvider
class	WavMirAudioReader

Enumerations
enum class	FalsePositiveTolerance { Strict , Lenient }
enum class	TimeSignature {   TwoTwo , FourFour , ThreeFour , SixEight ,   _count }
enum class	TempoObtainedFrom { Header , Title , Signal }
	How the tempo was obtained: More...

Functions
std::optional< MusicalMeter >	GetMeterUsingTatumQuantizationFit (const MirAudioReader &audio, FalsePositiveTolerance tolerance, const std::function< void(double)> &progressCallback, QuantizationFitDebugOutput *debugOutput)
	Get the BPM of the given audio file, using the Tatum Quantization Fit method. More...
std::vector< float >	GetNormalizedCircularAutocorr (const std::vector< float > &x)
	Get the normalized, circular auto-correlation for a signal x whose length already is a power of two. Since the output is symmetric, only the left-hand side is returned, i.e., of size N/2 + 1, where N is the power of two the input was upsampled to. More...
std::vector< float >	GetOnsetDetectionFunction (const MirAudioReader &audio, const std::function< void(double)> &progressCallback, QuantizationFitDebugOutput *debugOutput)
int	GetNumerator (TimeSignature ts)
int	GetDenominator (TimeSignature ts)
std::vector< int >	GetPossibleBarDivisors (int lower, int upper)
	Function to generate numbers whose prime factorization contains only twos or threes. More...
std::vector< int >	GetPeakIndices (const std::vector< float > &x)
std::vector< float >	GetNormalizedHann (int size)
constexpr auto	IsPowOfTwo (int x)
std::optional< ProjectSyncInfo >	GetProjectSyncInfo (const ProjectSyncInfoInput &in)
std::optional< double >	GetBpmFromFilename (const std::string &filename)
std::optional< MusicalMeter >	GetMusicalMeterFromSignal (const MirAudioReader &audio, FalsePositiveTolerance tolerance, const std::function< void(double)> &progressCallback, QuantizationFitDebugOutput *debugOutput)
void	SynchronizeProject (const std::vector< std::shared_ptr< AnalyzedAudioClip > > &clips, ProjectInterface &project, bool projectWasEmpty)
void	ProgressBar (int width, int percent)
OctaveError	GetOctaveError (double expected, double actual)
	Gets the tempo detection octave error, as defined in section 5. of Schreiber, H., Urbano, J. and Müller, M., 2020. Music Tempo Estimation: Are We Done Yet?. Transactions of the International Society for Music Information Retrieval, 3(1), p.111–125. DOI: https://doi.org/10.5334/tismir.43 In short, with an example: two bars of a fast 3/4 can in some cases be interpreted as one bar of 6/8. However, there are 6 beats in the former, against 2 in the latter, leading to an "octave error" of 3. In that case, the returned factor would be 3, and the remainder, log2(3 * actual / expected) More...
template<typename Result >
RocInfo	GetRocInfo (std::vector< Result > results, double allowedFalsePositiveRate=0.)
template<typename T >
void	PrintPythonVector (std::ofstream &ofs, const std::vector< T > &v, const char *name)
template<int bufferSize = 1024>
float	GetChecksum (const MirAudioReader &source)
	TEST_CASE ("GetBpmFromFilename")
	TEST_CASE ("GetProjectSyncInfo")
	TEST_CASE ("SynchronizeProject")
	TEST_CASE ("StftFrameProvider")
	TEST_CASE ("GetRocInfo")
	TEST_CASE ("GetChecksum")
auto	ToString (const std::optional< TimeSignature > &ts)
	TEST_CASE ("TatumQuantizationFitBenchmarking")
	TEST_CASE ("TatumQuantizationFitVisualization")

Variables
static const std::unordered_map< FalsePositiveTolerance, LoopClassifierSettings >	loopClassifierSettings
static constexpr auto	runLocally = false

Detailed Description

---

Audacity: A Digital Audio Editor

DecimatingMirAudioReader.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

DecimatingMirAudioReader.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

GetMeterUsingTatumQuantizationFit.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

GetMeterUsingTatumQuantizationFit.h

Matthieu Hodgkinson

A method to classify audio recordings in loops and non-loops, with a confidence score, together with a BPM estimate.

The method evaluates the assumption that the given audio is a loop. Based on this assumption, and finite possible tempi and time signatures, a set of hypotheses is tested. For each hypothesis, a tatum* quantization is tried, returning an average of the normalized distance between Onset Detection Function (ODF) peaks and the closest tatum, weighted by the ODF peak values. This yields a single scalar that strongly correlates with the fact that the audio is a loop or not, and that we use for loop/non-loop classification.

Besides this score, the classification stage also yields the most likely tatum rate, which still needs disambiguation to find the beat rate. The autocorrelation of the ODF is taken, and, for each bar division explaining the tatum rate, is comb-filtered. The energy of the comb-filtering together with the BPM likelihood are combined together, and the BPM with largest score is returned.

This approach is in some aspects like existing tempo detection methods (e.g. Percival, Graham & Tzanetakis, George (2014), implemented in the Essentia framework at https://essentia.upf.edu/), insofar as it first derives an ODF and then somehow correlates it with expected rhythmic patterns. However, the quantization distance, at the core of the method, is not known by the author to be used in other methods. Also, once the ODF is taken, the loop assumption lends itself to a single analysis of the entire ODF, rather than performing mid-term analyses which are then combined together. Finally, albeit restricting the use of application, the loop assumption reduces the number of tried hypotheses, reducing the risk of non-musical recordings to be detected as musical by sheer luck. This increased robustness of the algorithm against false positives is quintessential for Audacity, where non-music users should not be bothered by wrong detections. The loop assumption is nevertheless not fundamental, and the algorithm could be implemented without it, at the cost of a higher risk of false positives.

Evaluation and benchmarking code can be found in TatumQuantizationFitBenchmarking.cpp. This code takes a tolerable false-positive rate, and outputs the corresponding loop/non-loop threshold. It also returns the Octave Error accuracy measure, as introduced in "Schreiber, H., et al. (2020). Music Tempo Estimation: Are We Done Yet?".

A tatum is the smallest rhythmic unit in a musical piece. Quoting from https://en.wikipedia.org/wiki/Tatum_(music): "The term was coined by Jeff Bilmes (...) and is named after the influential jazz pianist Art Tatum, "whose tatum was faster than all others""

---

Audacity: A Digital Audio Editor

MirDsp.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirDsp.h

Matthieu Hodgkinson

DSP utilities used by the Music Information Retrieval code. These may migrate to lib-math if needed elsewhere.

---

Audacity: A Digital Audio Editor

MirProjectInterface.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirTypes.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirUtils.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirUtils.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MusicInformationRetrieval.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MusicInformationRetrieval.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

StftFrameProvider.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

StftFrameProvider.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirFakes.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

MirTestUtils.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

StftFrameProviderTests.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

WaveMirAudioReader.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

WaveMirAudioReader.h

Matthieu Hodgkinson

Enumeration Type Documentation

FalsePositiveTolerance

enum class MIR::FalsePositiveTolerance

strong

Enumerator
Strict
Lenient

Definition at line 24 of file MirTypes.h.

{
   Strict,
   Lenient,
};

TempoObtainedFrom

enum class MIR::TempoObtainedFrom

strong

How the tempo was obtained:

• looking for RIFF and ACID metadata in a WAV file's header,
• looking for a tempo in the title of the file,
• analyzing the signal.

Enumerator
Header
Title
Signal

Definition at line 59 of file MirTypes.h.

{
   Header,
   Title,
   Signal,
};

TimeSignature

enum class MIR::TimeSignature

strong

Enumerator
TwoTwo
FourFour
ThreeFour
SixEight
_count

Definition at line 30 of file MirTypes.h.

{
   TwoTwo,
   FourFour,
   ThreeFour,
   SixEight,
   _count
};

Function Documentation

GetBpmFromFilename()

MUSIC_INFORMATION_RETRIEVAL_API std::optional< double > MIR::GetBpmFromFilename

(

const std::string &

filename

)

Definition at line 107 of file MusicInformationRetrieval.cpp.

{
   // regex matching a forward or backward slash:
 
   // Regex: <(anything + (directory) separator) or nothing> <2 or 3 digits>
   // <optional separator> <bpm (case-insensitive)> <separator or nothing>
   const std::regex bpmRegex {
      R"((?:.*(?:_|-|\s|\.|/|\\))?(\d+)(?:_|-|\s|\.)?bpm(?:(?:_|-|\s|\.).*)?)",
      std::regex::icase
   };
   std::smatch matches;
   if (std::regex_match(filename, matches, bpmRegex))
      try
      {
         const auto value = std::stoi(matches[1]);
         return 30 <= value && value <= 300 ? std::optional<double> { value } :
                                              std::nullopt;
      }
      catch (const std::invalid_argument& e)
      {
         assert(false);
      }
   return {};
}

Referenced by GetProjectSyncInfo(), and TEST_CASE().

Here is the caller graph for this function:

GetChecksum()

template<int bufferSize = 1024>

float MIR::GetChecksum

(

const MirAudioReader &

source

)

Definition at line 163 of file MirTestUtils.h.

{
   // Sum samples to checksum.
   float checksum = 0.f;
   long long start = 0;
   std::array<float, bufferSize> buffer;
   while (true)
   {
      const auto numSamples =
         std::min<long long>(bufferSize, source.GetNumSamples() - start);
      if (numSamples == 0)
         break;
      source.ReadFloats(buffer.data(), start, numSamples);
      checksum +=
         std::accumulate(buffer.begin(), buffer.begin() + numSamples, 0.f);
      start += numSamples;
   }
   return checksum;
}

References MIR::MirAudioReader::GetNumSamples(), and MIR::MirAudioReader::ReadFloats().

Referenced by TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDenominator()

int MIR::GetDenominator ( TimeSignature  ts )

inline

Definition at line 46 of file MirTypes.h.

{
   constexpr std::array<int, static_cast<int>(TimeSignature::_count)>
      denominators = { 2, 4, 4, 8 };
   return denominators[static_cast<int>(ts)];
}

References _count.

Referenced by AudacityMirProject::ReconfigureMusicGrid().

Here is the caller graph for this function:

GetMeterUsingTatumQuantizationFit()

std::optional< MusicalMeter > MIR::GetMeterUsingTatumQuantizationFit	(	const MirAudioReader &	audio,
		FalsePositiveTolerance	tolerance,
		const std::function< void(double)> &	progressCallback,
		QuantizationFitDebugOutput *	debugOutput
	)

Get the BPM of the given audio file, using the Tatum Quantization Fit method.

Definition at line 392 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   const auto odf =
      GetOnsetDetectionFunction(audio, progressCallback, debugOutput);
   const auto odfSr =
      1. * audio.GetSampleRate() * odf.size() / audio.GetNumSamples();
   const auto audioFileDuration =
      1. * audio.GetNumSamples() / audio.GetSampleRate();
 
   const auto peakIndices = GetPeakIndices(odf);
   if (debugOutput)
   {
      debugOutput->audioFileDuration = audioFileDuration;
      debugOutput->odfSr = odfSr;
      debugOutput->odfPeakIndices = peakIndices;
   }
 
   const auto peakValues = ([&]() {
      std::vector<float> peakValues(peakIndices.size());
      std::transform(
         peakIndices.begin(), peakIndices.end(), peakValues.begin(),
         [&](int i) { return odf[i]; });
      return peakValues;
   })();
 
   if (IsSingleEvent(peakIndices, peakValues))
      return {};
 
   const auto possibleDivs = GetPossibleDivHierarchies(audioFileDuration);
   if (possibleDivs.empty())
      // The file is probably too short to be a loop.
      return {};
 
   const auto possibleNumTatums = [&]() {
      std::vector<int> possibleNumTatums(possibleDivs.size());
      std::transform(
         possibleDivs.begin(), possibleDivs.end(), possibleNumTatums.begin(),
         [&](const auto& entry) { return entry.first; });
      return possibleNumTatums;
   }();
 
   const auto experiment = RunQuantizationExperiment(
      odf, peakIndices, peakValues, possibleNumTatums, debugOutput);
 
   const auto winnerMeter = GetMostLikelyMeterFromQuantizationExperiment(
      odf, experiment.numDivisions, possibleDivs.at(experiment.numDivisions),
      audioFileDuration, debugOutput);
 
   const auto score = 1 - experiment.error;
 
   if (debugOutput)
   {
      debugOutput->tatumQuantization = experiment;
      debugOutput->bpm = winnerMeter.bpm;
      debugOutput->timeSignature = winnerMeter.timeSignature;
      debugOutput->odf = odf;
      debugOutput->odfSr = odfSr;
      debugOutput->audioFileDuration = audioFileDuration;
      debugOutput->score = score;
   }
 
   return score < loopClassifierSettings.at(tolerance).threshold ?
             std::optional<MusicalMeter> {} :
             winnerMeter;
}

References audio, MIR::QuantizationFitDebugOutput::audioFileDuration, MIR::QuantizationFitDebugOutput::bpm, entry, MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetMostLikelyMeterFromQuantizationExperiment(), GetOnsetDetectionFunction(), GetPeakIndices(), MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetPossibleDivHierarchies(), MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::IsSingleEvent(), loopClassifierSettings, MIR::QuantizationFitDebugOutput::odf, MIR::QuantizationFitDebugOutput::odfPeakIndices, MIR::QuantizationFitDebugOutput::odfSr, MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::RunQuantizationExperiment(), MIR::QuantizationFitDebugOutput::score, MIR::QuantizationFitDebugOutput::tatumQuantization, and MIR::QuantizationFitDebugOutput::timeSignature.

Referenced by GetMusicalMeterFromSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMusicalMeterFromSignal()

MUSIC_INFORMATION_RETRIEVAL_API std::optional< MusicalMeter > MIR::GetMusicalMeterFromSignal	(	const MirAudioReader &	audio,
		FalsePositiveTolerance	tolerance,
		const std::function< void(double)> &	progressCallback,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 132 of file MusicInformationRetrieval.cpp.

{
   if (audio.GetSampleRate() <= 0)
      return {};
   const auto duration = 1. * audio.GetNumSamples() / audio.GetSampleRate();
   if (duration > 60)
      // A file longer than 1 minute is most likely not a loop, and processing
      // it would be costly.
      return {};
   DecimatingMirAudioReader decimatedAudio { audio };
   return GetMeterUsingTatumQuantizationFit(
      decimatedAudio, tolerance, progressCallback, debugOutput);
}

References audio, and GetMeterUsingTatumQuantizationFit().

Referenced by GetProjectSyncInfo(), and TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNormalizedCircularAutocorr()

std::vector< float > MIR::GetNormalizedCircularAutocorr

(

const std::vector< float > &

x

)

Get the normalized, circular auto-correlation for a signal x whose length already is a power of two. Since the output is symmetric, only the left-hand side is returned, i.e., of size N/2 + 1, where N is the power of two the input was upsampled to.

Precondition

x.size() is a power of two.

Postcondition

returned vector has size x.size() / 2 + 1.

Definition at line 73 of file MirDsp.cpp.

{
   if (std::all_of(ux.begin(), ux.end(), [](float x) { return x == 0.f; }))
      return ux;
   const auto N = ux.size();
   assert(IsPowOfTwo(N));
   PffftSetupHolder setup { pffft_new_setup(N, PFFFT_REAL) };
   PffftFloatVector x { ux.begin(), ux.end() };
   PffftFloatVector work(N);
   pffft_transform_ordered(
      setup.get(), x.data(), x.data(), work.data(), PFFFT_FORWARD);
 
   // Transform to a power spectrum, but preserving the layout expected by PFFFT
   // in preparation for the inverse transform.
   x[0] *= x[0];
   x[1] *= x[1];
   for (auto n = 2; n < N; n += 2)
   {
      x[n] = x[n] * x[n] + x[n + 1] * x[n + 1];
      x[n + 1] = 0.f;
   }
 
   pffft_transform_ordered(
      setup.get(), x.data(), x.data(), work.data(), PFFFT_BACKWARD);
 
   // The second half of the circular autocorrelation is the mirror of the first
   // half. We are economic and only keep the first half.
   x.erase(x.begin() + N / 2 + 1, x.end());
 
   const auto normalizer = 1 / x[0];
   std::transform(x.begin(), x.end(), x.begin(), [normalizer](float x) {
      return x * normalizer;
   });
   return { x.begin(), x.end() };
}

References IsPowOfTwo().

Referenced by MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetBestBarDivisionIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNormalizedHann()

std::vector< float > MIR::GetNormalizedHann

(

int

size

)

Definition at line 80 of file MirUtils.cpp.

{
   std::vector<float> window(size);
   for (auto n = 0; n < size; ++n)
      window[n] = .5 * (1 - std::cos(2 * pi * n / size));
   const auto windowSum = std::accumulate(window.begin(), window.end(), 0.f);
   std::transform(
      window.begin(), window.end(), window.begin(),
      [windowSum](float w) { return w / windowSum; });
   return window;
}

References MIR::anonymous_namespace{MirUtils.cpp}::pi, and size.

Referenced by MIR::anonymous_namespace{MirDsp.cpp}::GetMovingAverage().

Here is the caller graph for this function:

GetNumerator()

int MIR::GetNumerator ( TimeSignature  ts )

inline

Definition at line 39 of file MirTypes.h.

{
   constexpr std::array<int, static_cast<int>(TimeSignature::_count)>
      numerators = { 2, 4, 3, 6 };
   return numerators[static_cast<int>(ts)];
}

References _count.

Referenced by AudacityMirProject::ReconfigureMusicGrid().

Here is the caller graph for this function:

GetOctaveError()

OctaveError MIR::GetOctaveError	(	double	expected,
		double	actual
	)

Gets the tempo detection octave error, as defined in section 5. of Schreiber, H., Urbano, J. and Müller, M., 2020. Music Tempo Estimation: Are We Done Yet?. Transactions of the International Society for Music Information Retrieval, 3(1), p.111–125. DOI: https://doi.org/10.5334/tismir.43 In short, with an example: two bars of a fast 3/4 can in some cases be interpreted as one bar of 6/8. However, there are 6 beats in the former, against 2 in the latter, leading to an "octave error" of 3. In that case, the returned factor would be 3, and the remainder, log2(3 * actual / expected)

Definition at line 39 of file MirTestUtils.cpp.

{
   constexpr std::array<double, 5> factors { 1., 2., .5, 3., 1. / 3 };
   std::vector<OctaveError> octaveErrors;
   std::transform(
      factors.begin(), factors.end(), std::back_inserter(octaveErrors),
      [&](double factor) {
         const auto remainder = std::log2(factor * actual / expected);
         return OctaveError { factor, remainder };
      });
   return *std::min_element(
      octaveErrors.begin(), octaveErrors.end(),
      [](const auto& a, const auto& b) {
         return std::abs(a.remainder) < std::abs(b.remainder);
      });
}

Referenced by TEST_CASE().

Here is the caller graph for this function:

GetOnsetDetectionFunction()

std::vector< float > MIR::GetOnsetDetectionFunction	(	const MirAudioReader &	audio,
		const std::function< void(double)> &	progressCallback,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 109 of file MirDsp.cpp.

{
   StftFrameProvider frameProvider { audio };
   const auto sampleRate = frameProvider.GetSampleRate();
   const auto numFrames = frameProvider.GetNumFrames();
   const auto frameSize = frameProvider.GetFftSize();
   PffftFloatVector buffer(frameSize);
   std::vector<float> odf;
   odf.reserve(numFrames);
   const auto powSpecSize = frameSize / 2 + 1;
   PffftFloatVector powSpec(powSpecSize);
   PffftFloatVector prevPowSpec(powSpecSize);
   PffftFloatVector firstPowSpec;
   std::fill(prevPowSpec.begin(), prevPowSpec.end(), 0.f);
 
   PowerSpectrumGetter getPowerSpectrum { frameSize };
 
   auto frameCounter = 0;
   while (frameProvider.GetNextFrame(buffer))
   {
      getPowerSpectrum(buffer.aligned(), powSpec.aligned());
 
      // Compress the frame as per section (6.5) in Müller, Meinard.
      // Fundamentals of music processing: Audio, analysis, algorithms,
      // applications. Vol. 5. Cham: Springer, 2015.
      constexpr auto gamma = 100.f;
      std::transform(
         powSpec.begin(), powSpec.end(), powSpec.begin(),
         [gamma](float x) { return FastLog2(1 + gamma * std::sqrt(x)); });
 
      if (firstPowSpec.empty())
         firstPowSpec = powSpec;
      else
         odf.push_back(GetNoveltyMeasure(prevPowSpec, powSpec));
 
      if (debugOutput)
         debugOutput->postProcessedStft.push_back(powSpec);
 
      std::swap(prevPowSpec, powSpec);
 
      if (progressCallback)
         progressCallback(1. * ++frameCounter / numFrames);
   }
 
   // Close the loop.
   odf.push_back(GetNoveltyMeasure(prevPowSpec, firstPowSpec));
   assert(IsPowOfTwo(odf.size()));
 
   const auto movingAverage =
      GetMovingAverage(odf, frameProvider.GetFrameRate());
 
   if (debugOutput)
   {
      debugOutput->rawOdf = odf;
      debugOutput->movingAverage = movingAverage;
   }
 
   // Subtract moving average from ODF.
   std::transform(
      odf.begin(), odf.end(), movingAverage.begin(), odf.begin(),
      [](float a, float b) { return std::max<float>(a - b, 0.f); });
 
   return odf;
}

References PffftFloatVector::aligned(), audio, MIR::anonymous_namespace{MirDsp.cpp}::GetMovingAverage(), MIR::anonymous_namespace{MirDsp.cpp}::GetNoveltyMeasure(), IsPowOfTwo(), MIR::QuantizationFitDebugOutput::movingAverage, MIR::QuantizationFitDebugOutput::postProcessedStft, MIR::QuantizationFitDebugOutput::rawOdf, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by GetMeterUsingTatumQuantizationFit().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPeakIndices()

std::vector< int > MIR::GetPeakIndices

(

const std::vector< float > &

x

)

Definition at line 67 of file MirUtils.cpp.

{
   std::vector<int> peakIndices;
   for (auto j = 0; j < x.size(); ++j)
   {
      const auto i = j == 0 ? x.size() - 1 : j - 1;
      const auto k = j == x.size() - 1 ? 0 : j + 1;
      if (x[i] < x[j] && x[j] > x[k])
         peakIndices.push_back(j);
   }
   return peakIndices;
}

Referenced by GetMeterUsingTatumQuantizationFit().

Here is the caller graph for this function:

GetPossibleBarDivisors()

std::vector< int > MIR::GetPossibleBarDivisors	(	int	lower,
		int	upper
	)

Function to generate numbers whose prime factorization contains only twos or threes.

Definition at line 54 of file MirUtils.cpp.

{
   auto result = GetPowersOf2And3(lower, upper);
   // Remove divisors that have more than two triplet levels. E.g. 3/4s are
   // okay, 3/4s with swung ryhthms too, but beyond that it's probably very rare
   // (e.g. swung 9/8 ??...)
   result.erase(
      std::remove_if(
         result.begin(), result.end(), [](int n) { return n % 27 == 0; }),
      result.end());
   return result;
}

References MIR::anonymous_namespace{MirUtils.cpp}::GetPowersOf2And3().

Here is the call graph for this function:

GetProjectSyncInfo()

std::optional< ProjectSyncInfo > MUSIC_INFORMATION_RETRIEVAL_API MIR::GetProjectSyncInfo

(

const ProjectSyncInfoInput &

in

)

Definition at line 49 of file MusicInformationRetrieval.cpp.

{
   if (in.tags.has_value() && in.tags->isOneShot)
      // That's a one-shot file, we don't want to sync it.
      return {};
 
   std::optional<double> bpm;
   std::optional<TimeSignature> timeSignature;
   std::optional<TempoObtainedFrom> usedMethod;
 
   if (in.tags.has_value() && in.tags->bpm.has_value() && *in.tags->bpm > 30.)
   {
      bpm = in.tags->bpm;
      usedMethod = TempoObtainedFrom::Header;
   }
   else if ((bpm = GetBpmFromFilename(in.filename)))
      usedMethod = TempoObtainedFrom::Title;
   else if (
      const auto meter = GetMusicalMeterFromSignal(
         in.source,
         in.viewIsBeatsAndMeasures ? FalsePositiveTolerance::Lenient :
                                     FalsePositiveTolerance::Strict,
         in.progressCallback))
   {
      bpm = meter->bpm;
      timeSignature = meter->timeSignature;
      usedMethod = TempoObtainedFrom::Signal;
   }
   else
      return {};
 
   const auto qpm = *bpm * quarternotesPerBeat[static_cast<int>(
                              timeSignature.value_or(TimeSignature::FourFour))];
 
   auto recommendedStretch = 1.0;
   if (!in.projectWasEmpty)
      // There already is content in this project, meaning that its tempo won't
      // be changed. Change speed by some power of two to minimize stretching.
      recommendedStretch =
         std::pow(2., std::round(std::log2(in.projectTempo / qpm)));
 
   auto excessDurationInQuarternotes = 0.;
   auto numQuarters = in.source.GetDuration() * qpm / 60.;
   const auto roundedNumQuarters = std::round(numQuarters);
   const auto delta = numQuarters - roundedNumQuarters;
   // If there is an excess less than a 32nd, we treat it as an edit error.
   if (0 < delta && delta < 1. / 8)
      excessDurationInQuarternotes = delta;
 
   return ProjectSyncInfo {
      qpm,
      *usedMethod,
      timeSignature,
      recommendedStretch,
      excessDurationInQuarternotes,
   };
}

References MIR::ProjectSyncInfoInput::filename, FourFour, GetBpmFromFilename(), MIR::MirAudioReader::GetDuration(), GetMusicalMeterFromSignal(), Header, Lenient, MIR::ProjectSyncInfoInput::progressCallback, MIR::ProjectSyncInfoInput::projectTempo, MIR::ProjectSyncInfoInput::projectWasEmpty, MIR::anonymous_namespace{MusicInformationRetrieval.cpp}::quarternotesPerBeat, fast_float::round(), Signal, MIR::ProjectSyncInfoInput::source, Strict, MIR::ProjectSyncInfoInput::tags, Title, and MIR::ProjectSyncInfoInput::viewIsBeatsAndMeasures.

Referenced by anonymous_namespace{ProjectFileManager.cpp}::RunTempoDetection(), and TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

GetRocInfo()

template<typename Result >

RocInfo MIR::GetRocInfo	(	std::vector< Result >	results,
		double	allowedFalsePositiveRate = 0.
	)

The Receiver Operating Characteristic (ROC) curve is a plot of the true positive rate (TPR) against the false positive rate (FPR) for the different possible thresholds of a binary classifier. The area under the curve (AUC) is a measure of the classifier's performance. The greater the AUC, the better the classifier.

Template Parameters

Result

has public members truth, boolean, and score, numeric

Parameters

results

true classifications and scores of some population

Precondition

at least one of results is really positive (truth is true), and at least one is really negative

0. <= allowedFalsePositiveRate && allowedFalsePositiveRate <= 1.

Definition at line 52 of file MirTestUtils.h.

{
   const auto truth = std::mem_fn(&Result::truth);
   const auto falsity = std::not_fn(truth);
 
   // There is at least one positive and one negative sample.
   assert(any_of(results.begin(), results.end(), truth));
   assert(any_of(results.begin(), results.end(), falsity));
 
   assert(allowedFalsePositiveRate >= 0. && allowedFalsePositiveRate <= 1.);
   allowedFalsePositiveRate = std::clamp(allowedFalsePositiveRate, 0., 1.);
 
   // Sort the results by score, descending.
   std::sort(results.begin(), results.end(), [](const auto& a, const auto& b) {
      return a.score > b.score;
   });
 
   const auto size = results.size();
   const auto numPositives = count_if(results.begin(), results.end(), truth);
   const auto numNegatives = size - numPositives;
 
   // Find true and false positive rates for various score thresholds.
   // True positive and false positive counts are nondecreasing with i,
   // therefore if false positive rate has increased at some i, true positive
   // rate has not decreased.
   std::vector<double> truePositiveRates;
   truePositiveRates.reserve(size);
   std::vector<double> falsePositiveRates;
   falsePositiveRates.reserve(size);
   size_t numTruePositives = 0;
   size_t numFalsePositives = 0;
   for (const auto& result : results)
   {
      if (result.truth)
         ++numTruePositives;
      else
         ++numFalsePositives;
      truePositiveRates.push_back(
         static_cast<double>(numTruePositives) / numPositives);
      falsePositiveRates.push_back(
         static_cast<double>(numFalsePositives) / numNegatives);
   }
 
   // Now find the area under the non-decreasing curve with FPR as x-axis,
   // TPR as y, and i as a parameter.  (This curve is within a square with unit
   // side.)
   double auc = 0.;
   for (size_t i = 0; i <= size; ++i)
   {
      const auto leftFpr = i == 0 ? 0. : falsePositiveRates[i - 1];
      const auto rightFpr = i == size ? 1. : falsePositiveRates[i];
      const auto leftTpr = i == 0 ? 0. : truePositiveRates[i - 1];
      const auto rightTpr = i == size ? 1. : truePositiveRates[i];
      const auto trapezoid = (rightTpr + leftTpr) * (rightFpr - leftFpr) / 2.;
      assert(trapezoid >= 0); // See comments above
      auc += trapezoid;
   }
 
   // Find the parameter at which the x coordinate exceeds the allowed FPR.
   const auto it = std::upper_bound(
      falsePositiveRates.begin(), falsePositiveRates.end(),
      allowedFalsePositiveRate);
 
   if (it == falsePositiveRates.end())
      // All breakpoints satify the constraint. Return the least score.
      return { auc, results.back().score };
   else if (it == falsePositiveRates.begin())
      // No breakpoint satisfies the constraint. Return the greatest score.
      return { auc, results.front().score };
 
   // For threshold, use the score halfway between the last breakpoint that
   // satisfies the constraint and the first breakpoint that doesn't.
   const auto index = it - falsePositiveRates.begin();
   const auto threshold = (results[index - 1].score + results[index].score) / 2;
 
   return { auc, threshold };
}

References size.

Referenced by TEST_CASE().

Here is the caller graph for this function:

IsPowOfTwo()

constexpr auto MIR::IsPowOfTwo ( int  x )

constexpr

Definition at line 28 of file MirUtils.h.

{
   return x > 0 && (x & (x - 1)) == 0;
}

Referenced by MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetBestBarDivisionIndex(), GetNormalizedCircularAutocorr(), GetOnsetDetectionFunction(), MIR::StftFrameProvider::StftFrameProvider(), and TEST_CASE().

Here is the caller graph for this function:

PrintPythonVector()

template<typename T >

void MIR::PrintPythonVector	(	std::ofstream &	ofs,
		const std::vector< T > &	v,
		const char *	name
	)

Definition at line 133 of file MirTestUtils.h.

{
   ofs << name << " = [";
   std::for_each(v.begin(), v.end(), [&](T x) { ofs << x << ","; });
   ofs << "]\n";
}

References name.

Referenced by TEST_CASE().

Here is the caller graph for this function:

ProgressBar()

void MIR::ProgressBar	(	int	width,
		int	percent
	)

Definition at line 26 of file MirTestUtils.cpp.

{
   int progress = (width * percent) / 100;
   std::cout << "[";
   for (int i = 0; i < width; ++i)
      if (i < progress)
         std::cout << "=";
      else
         std::cout << " ";
   std::cout << "] " << std::setw(3) << percent << "%\r";
   std::cout.flush();
}

Referenced by TEST_CASE().

Here is the caller graph for this function:

SynchronizeProject()

MUSIC_INFORMATION_RETRIEVAL_API void MIR::SynchronizeProject	(	const std::vector< std::shared_ptr< AnalyzedAudioClip > > &	clips,
		ProjectInterface &	project,
		bool	projectWasEmpty
	)

Definition at line 149 of file MusicInformationRetrieval.cpp.

{
   const auto isBeatsAndMeasures = project.ViewIsBeatsAndMeasures();
 
   if (!projectWasEmpty && !isBeatsAndMeasures)
      return;
 
   const auto projectTempo =
      !projectWasEmpty ? std::make_optional(project.GetTempo()) : std::nullopt;
 
   if (!std::any_of(
          clips.begin(), clips.end(),
          [](const std::shared_ptr<AnalyzedAudioClip>& clip) {
             return clip->GetSyncInfo().has_value();
          }))
      return;
 
   Finally Do = [&] {
      // Re-evaluate if we are in B&M view - we might have convinced the user to
      // switch:
      if (!project.ViewIsBeatsAndMeasures())
         return;
      std::for_each(
         clips.begin(), clips.end(),
         [&](const std::shared_ptr<AnalyzedAudioClip>& clip) {
            clip->Synchronize();
         });
      project.OnClipsSynchronized();
   };
 
   if (!projectWasEmpty && isBeatsAndMeasures)
      return;
 
   const auto [loopIndices, oneshotIndices] = [&] {
      std::vector<size_t> loopIndices;
      std::vector<size_t> oneshotIndices;
      for (size_t i = 0; i < clips.size(); ++i)
         if (clips[i]->GetSyncInfo().has_value())
            loopIndices.push_back(i);
         else
            oneshotIndices.push_back(i);
      return std::make_pair(loopIndices, oneshotIndices);
   }();
 
   // Favor results based on reliability. We assume that header info is most
   // reliable, followed by title, followed by DSP.
   std::unordered_map<TempoObtainedFrom, size_t> indexMap;
   std::for_each(loopIndices.begin(), loopIndices.end(), [&](size_t i) {
      const auto usedMethod = clips[i]->GetSyncInfo()->usedMethod;
      if (!indexMap.count(usedMethod))
         indexMap[usedMethod] = i;
   });
 
   const auto chosenIndex = indexMap.count(TempoObtainedFrom::Header) ?
                               indexMap.at(TempoObtainedFrom::Header) :
                            indexMap.count(TempoObtainedFrom::Title) ?
                               indexMap.at(TempoObtainedFrom::Title) :
                               indexMap.at(TempoObtainedFrom::Signal);
 
   const auto& chosenSyncInfo = *clips[chosenIndex]->GetSyncInfo();
   const auto isSingleFileImport = clips.size() == 1;
   if (!project.ShouldBeReconfigured(
          chosenSyncInfo.rawAudioTempo, isSingleFileImport))
      return;
 
   project.ReconfigureMusicGrid(
      chosenSyncInfo.rawAudioTempo, chosenSyncInfo.timeSignature);
 
   // Reset tempo of one-shots to this new project tempo, so that they don't
   // get stretched:
   std::for_each(oneshotIndices.begin(), oneshotIndices.end(), [&](size_t i) {
      clips[i]->SetRawAudioTempo(chosenSyncInfo.rawAudioTempo);
   });
}

References Header, project, Signal, and Title.

Referenced by ProjectFileManager::ImportAndRunTempoDetection(), and TEST_CASE().

Here is the caller graph for this function:

TEST_CASE() [1/8]

MIR::TEST_CASE

(

"GetBpmFromFilename"

)

Definition at line 10 of file MusicInformationRetrievalTests.cpp.

{
   const std::vector<std::pair<std::string, std::optional<double>>> testCases {
      { "120 BPM", 120 },
 
      // there may be an extension
      { "120 BPM.opus", 120 },
      { "120 BPM", 120 },
 
      // it may be preceeded by a path
      { "C:/my\\path/to\\120 BPM", 120 },
 
      // value must be between 30 and 300 inclusive
      { "1 BPM", std::nullopt },
      { "29 BPM", std::nullopt },
      { "30 BPM", 30 },
      { "300 BPM", 300 },
      { "301 BPM", std::nullopt },
      { "1000 BPM", std::nullopt },
 
      // it may be preceeded by zeros
      { "000120 BPM", 120 },
 
      // there may be something before the value
      { "anything 120 BPM", 120 },
      // but then there must be a separator
      { "anything120 BPM", std::nullopt },
      // there may be something after the value
      { "120 BPM anything", 120 },
      // but then there must also be a separator
      { "120 BPManything", std::nullopt },
 
      // what separator is used doesn't matter
      { "anything-120-BPM", 120 },
      { "anything_120_BPM", 120 },
      { "anything.120.BPM", 120 },
 
      // but of course that can't be an illegal filename character
      { "120/BPM", std::nullopt },
      { "120\\BPM", std::nullopt },
      { "120:BPM", std::nullopt },
      { "120;BPM", std::nullopt },
      { "120'BPM", std::nullopt },
      // ... and so on.
 
      // separators before and after don't have to match
      { "anything_120-BPM", 120 },
 
      // no separator between value and "bpm" is ok
      { "anything.120BPM", 120 },
 
      // a few real file names found out there
      { "Cymatics - Cyclone Top Drum Loop 3 - 174 BPM", 174 },
      { "Fantasie Impromptu Op. 66.mp3", std::nullopt },
   };
   std::vector<bool> success(testCases.size());
   std::transform(
      testCases.begin(), testCases.end(), success.begin(),
      [](const auto& testCase) {
         return GetBpmFromFilename(testCase.first) == testCase.second;
      });
   REQUIRE(
      std::all_of(success.begin(), success.end(), [](bool b) { return b; }));
}

TEST_CASE() [2/8]

MIR::TEST_CASE

(

"GetChecksum"

)

Definition at line 132 of file TatumQuantizationFitBenchmarking.cpp.

{
   constexpr auto bufferSize = 5;
   const auto checksum = GetChecksum<bufferSize>(SquareWaveMirAudioReader {});
   REQUIRE(checksum == 0.);
}

TEST_CASE() [3/8]

MIR::TEST_CASE

(

"GetProjectSyncInfo"

)

Definition at line 83 of file MusicInformationRetrievalTests.cpp.

{
   SECTION("operator bool")
   {
      SECTION("returns false if ACID tag says one-shot")
      {
         auto input = arbitaryInput;
         input.tags.emplace(AcidizerTags::OneShot {});
         REQUIRE(!GetProjectSyncInfo(input).has_value());
      }
 
      SECTION("returns true if ACID tag says non-one-shot")
      {
         auto input = arbitaryInput;
         input.tags.emplace(AcidizerTags::Loop { 120.0 });
         REQUIRE(GetProjectSyncInfo(input).has_value());
      }
 
      SECTION("BPM is invalid")
      {
         SECTION("returns true if filename has BPM")
         {
            auto input = arbitaryInput;
            input.filename = filename100bpm;
            REQUIRE(GetProjectSyncInfo(input).has_value());
         }
 
         SECTION("returns false if filename has no BPM")
         {
            auto input = arbitaryInput;
            input.filename = "filenameWithoutBpm";
            REQUIRE(!GetProjectSyncInfo(input).has_value());
         }
      }
   }
 
   SECTION("GetProjectSyncInfo")
   {
      SECTION("prioritizes ACID tags over filename")
      {
         auto input = arbitaryInput;
         input.filename = filename100bpm;
         input.tags.emplace(AcidizerTags::Loop { 120. });
         const auto info = GetProjectSyncInfo(input);
         REQUIRE(info);
         REQUIRE(info->rawAudioTempo == 120);
      }
 
      SECTION("falls back on filename if tag bpm is invalid")
      {
         auto input = arbitaryInput;
         input.filename = filename100bpm;
         input.tags.emplace(AcidizerTags::Loop { -1. });
         const auto info = GetProjectSyncInfo(input);
         REQUIRE(info);
         REQUIRE(info->rawAudioTempo == 100);
      }
 
      SECTION("stretchMinimizingPowOfTwo is as expected")
      {
         auto input = arbitaryInput;
         input.filename = filename100bpm;
 
         input.projectTempo = 100.;
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 1.);
 
         // Project tempo twice as fast. Without compensation, the audio would
         // be stretched to 0.5 its length. Not stretching it at all may still
         // yield musically interesting results.
         input.projectTempo = 200;
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 2.);
 
         // Same principle applies in the following:
         input.projectTempo = 400;
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 4.);
         input.projectTempo = 50;
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == .5);
         input.projectTempo = 25;
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == .25);
 
         // Now testing edge cases:
         input.projectTempo = 100 * std::pow(2, .51);
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 2.);
         input.projectTempo = 100 * std::pow(2, .49);
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 1.);
         input.projectTempo = 100 * std::pow(2, -.49);
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == 1.);
         input.projectTempo = 100 * std::pow(2, -.51);
         REQUIRE(GetProjectSyncInfo(input)->stretchMinimizingPowOfTwo == .5);
      }
   }
}

References MIR::anonymous_namespace{MusicInformationRetrievalTests.cpp}::arbitaryInput, MIR::ProjectSyncInfoInput::filename, MIR::anonymous_namespace{MusicInformationRetrievalTests.cpp}::filename100bpm, GetProjectSyncInfo(), and MIR::ProjectSyncInfoInput::tags.

Here is the call graph for this function:

TEST_CASE() [4/8]

MIR::TEST_CASE

(

"GetRocInfo"

)

Definition at line 73 of file TatumQuantizationFitBenchmarking.cpp.

{
   // We use the AUC as a measure of the classifier's performance. With a
   // suitable data set, this helps us detect regressions, and guide fine-tuning
   // of the algorithm. This test should help understand how it works and also
   // make sure that we've implemented that metric correctly :)
 
   struct Sample
   {
      bool truth;
      double score;
   };
 
   using Samples = std::vector<Sample>;
 
   struct Expected
   {
      double areaUnderCurve;
      double threshold;
   };
 
   struct TestCase
   {
      const Samples samples;
      const double allowedFalsePositiveRate;
      const Expected expected;
   };
 
   const std::vector<TestCase> testCases {
      // Classifier is upside down. We don't tolerate false positives. The
      // returned threshold is then 100 will satisfy this, but the TPR will also
      // be 0 ...
      TestCase { Samples { { true, 100. }, { false, 200. } }, 0.,
                 Expected { 0., 200. } },
 
      // Classifier is still upside down. We'll get true positives only if we
      // accept an FPR of 1.
      TestCase { Samples { { true, 100. }, { false, 200. } }, 1.,
                 Expected { 0., 100. } },
 
      // Now we have a classifier that works. We don't accept false positives.
      TestCase { Samples { { false, 100. }, { false, 150. }, { true, 200. } },
                 0., Expected { 1., 175. } },
 
      // A random classifier, which should have an AUC of 0.75.
      TestCase {
         Samples { { false, 1. }, { true, 2. }, { false, 3. }, { true, 4. } },
         0.5, Expected { .75, 1.5 } },
   };
 
   for (const auto& testCase : testCases)
   {
      const auto roc =
         GetRocInfo(testCase.samples, testCase.allowedFalsePositiveRate);
      REQUIRE(roc.areaUnderCurve == testCase.expected.areaUnderCurve);
      REQUIRE(roc.threshold == testCase.expected.threshold);
   }
}

References GetRocInfo().

Here is the call graph for this function:

TEST_CASE() [5/8]

MIR::TEST_CASE

(

"StftFrameProvider"

)

Definition at line 46 of file StftFrameProviderTests.cpp.

{
   SECTION("handles empty files")
   {
      StftFrameProvider sut { TestMirAudioReader { 0 } };
      PffftFloatVector frame;
      REQUIRE(!sut.GetNextFrame(frame));
   }
   SECTION("handles very short files")
   {
      StftFrameProvider sut { TestMirAudioReader { 1 } };
      PffftFloatVector frame;
      REQUIRE(!sut.GetNextFrame(frame));
   }
   SECTION("has power-of-two number of frames")
   {
      StftFrameProvider sut { TestMirAudioReader { 123456 } };
      REQUIRE(IsPowOfTwo(sut.GetNumFrames()));
   }
   SECTION("respects MirAudioReader boundaries")
   {
      TestMirAudioReader reader { 123456 };
      StftFrameProvider sut { reader };
      PffftFloatVector frame;
      while (sut.GetNextFrame(frame))
         ;
   }
}

References IsPowOfTwo().

Here is the call graph for this function:

TEST_CASE() [6/8]

MIR::TEST_CASE

(

"SynchronizeProject"

)

Definition at line 176 of file MusicInformationRetrievalTests.cpp.

{
   constexpr auto initialProjectTempo = 100.;
   FakeProjectInterface project { initialProjectTempo };
 
   SECTION("single-file import")
   {
      constexpr FakeAnalyzedAudioClip::Params clipParams {
         123., TempoObtainedFrom::Title
      };
 
      // Generate all possible situations, and in the sections filter for the
      // conditions we want to check.
      project.isBeatsAndMeasures = GENERATE(false, true);
      project.shouldBeReconfigured = GENERATE(false, true);
      const auto projectWasEmpty = GENERATE(false, true);
      const auto clipsHaveTempo = GENERATE(false, true);
 
      const std::vector<std::shared_ptr<AnalyzedAudioClip>> clips {
         std::make_shared<FakeAnalyzedAudioClip>(
            clipsHaveTempo ? std::make_optional(clipParams) : std::nullopt)
      };
 
      const auto projectWasReconfigured = [&](bool yes) {
         const auto reconfigurationCheck = yes == project.wasReconfigured;
         const auto projectTempoCheck =
            project.projectTempo ==
            (yes ? clipParams.tempo : initialProjectTempo);
         REQUIRE(reconfigurationCheck);
         REQUIRE(projectTempoCheck);
      };
 
      const auto clipsWereSynchronized = [&](bool yes) {
         const auto check = yes == project.clipsWereSynchronized;
         REQUIRE(check);
      };
 
      SECTION("nothing happens if")
      {
         SECTION("no clip has tempo")
         if (!clipsHaveTempo)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            projectWasReconfigured(false);
            clipsWereSynchronized(false);
         }
         SECTION(
            "user doesn't want reconfiguration and view is minutes and seconds")
         if (!project.shouldBeReconfigured && !project.isBeatsAndMeasures)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            projectWasReconfigured(false);
            clipsWereSynchronized(false);
         }
         SECTION(
            "user wants reconfiguration but view is minutes and seconds and project is not empty")
         if (
            project.shouldBeReconfigured && !project.isBeatsAndMeasures &&
            !projectWasEmpty)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            projectWasReconfigured(false);
            clipsWereSynchronized(false);
         }
      }
 
      SECTION(
         "project gets reconfigured only if clips have tempo, user wants to and project is empty")
      {
         SynchronizeProject(clips, project, projectWasEmpty);
         projectWasReconfigured(
            clipsHaveTempo && project.shouldBeReconfigured && projectWasEmpty);
      }
 
      SECTION("project does not get reconfigured if")
      {
         SECTION("user doesn't want to")
         if (!project.shouldBeReconfigured)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            projectWasReconfigured(false);
         }
 
         SECTION("project was not empty")
         if (!projectWasEmpty)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            projectWasReconfigured(false);
         }
      }
 
      SECTION("clips don't get synchronized if view is minutes and seconds and")
      if (!project.isBeatsAndMeasures)
      {
         SECTION("user says no to reconfiguration")
         if (!project.shouldBeReconfigured)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            clipsWereSynchronized(false);
         }
         SECTION("project was not empty")
         if (!projectWasEmpty)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            clipsWereSynchronized(false);
         }
      }
 
      SECTION("clips get synchronized if some clip has tempo and")
      if (clipsHaveTempo)
      {
         SECTION(
            "user doesn't want reconfiguration but view is beats and measures")
         if (!project.shouldBeReconfigured && project.isBeatsAndMeasures)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            clipsWereSynchronized(true);
         }
         SECTION(
            "user wants reconfiguration, view is beats and measures and project is not empty")
         if (
            project.shouldBeReconfigured && project.isBeatsAndMeasures &&
            !projectWasEmpty)
         {
            SynchronizeProject(clips, project, projectWasEmpty);
            clipsWereSynchronized(true);
         }
      }
   }
 
   SECTION("multiple-file import")
   {
      project.shouldBeReconfigured = true;
      constexpr auto projectWasEmpty = true;
 
      SECTION(
         "for clips of different tempi, precedence is header-based, then title-based, then signal-based")
      {
         SynchronizeProject(
            {
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 123.,
                                                  TempoObtainedFrom::Title }),
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 456.,
                                                  TempoObtainedFrom::Header }),
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 789.,
                                                  TempoObtainedFrom::Signal }),
            },
            project, projectWasEmpty);
         REQUIRE(project.projectTempo == 456.);
 
         SynchronizeProject(
            {
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 789.,
                                                  TempoObtainedFrom::Signal }),
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 123.,
                                                  TempoObtainedFrom::Title }),
            },
            project, projectWasEmpty);
         REQUIRE(project.projectTempo == 123.);
 
         SynchronizeProject(
            {
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 789.,
                                                  TempoObtainedFrom::Signal }),
            },
            project, projectWasEmpty);
         REQUIRE(project.projectTempo == 789.);
      }
 
      SECTION("raw audio tempo of one-shot clips is set to project tempo")
      {
         const auto oneShotClip =
            std::make_shared<FakeAnalyzedAudioClip>(std::nullopt);
         constexpr auto whicheverMethod = TempoObtainedFrom::Signal;
         SynchronizeProject(
            {
               std::make_shared<FakeAnalyzedAudioClip>(
                  FakeAnalyzedAudioClip::Params { 123., whicheverMethod }),
               oneShotClip,
            },
            project, projectWasEmpty);
         REQUIRE(project.projectTempo == 123);
         REQUIRE(oneShotClip->rawAudioTempo == 123);
      }
   }
}

References Header, project, Signal, SynchronizeProject(), and Title.

Here is the call graph for this function:

TEST_CASE() [7/8]

MIR::TEST_CASE

(

"TatumQuantizationFitBenchmarking"

)

Definition at line 160 of file TatumQuantizationFitBenchmarking.cpp.

{
   // For this test to run, you will need to set `runLocally` to `true`, and
   // you'll also need the benchmarking sound files. To get these, just open
   // `download-benchmarking-dataset.html` in a browser. This will download a
   // zip file that you'll need to extract and place in a `benchmarking-dataset`
   // directory under this directory.
 
   // Running this test will update
   // `TatumQuantizationFitBenchmarkingOutput/summary.txt`. The summary contains
   //
   // 1. the AUC metric for regression-testing,
   // 2. the strict- and lenient-mode thresholds,
   // 3. the octave-error RMS (Schreiber, H., et al. (2020)), and
   // 4. the hash of the audio files used.
   //
   // The AUC can only be used for comparison if the hash doesn't change. At the
   // time of writing, the benchmarking can only conveniently be run on the
   // author's machine (Windows), because the files used are not
   // redistributable. Setting up a redistributable dataset that can be used by
   // other developers is currently being worked on.
 
   // We only observe the results for the most lenient classifier. The other,
   // stricter classifier will yield the same results, only with fewer false
   // positives.
   if (!runLocally)
      return;
 
   constexpr auto tolerance = FalsePositiveTolerance::Lenient;
   constexpr int progressBarWidth = 50;
   const auto audioFiles = GetBenchmarkingAudioFiles();
   std::stringstream sampleValueCsv;
   sampleValueCsv
      << "truth,score,tatumRate,bpm,ts,octaveFactor,octaveError,lag,filename\n";
 
   float checksum = 0.f;
   struct Sample
   {
      bool truth;
      double score;
      std::optional<OctaveError> octaveError;
   };
   std::vector<Sample> samples;
   const auto numFiles = audioFiles.size();
   auto count = 0;
   std::chrono::milliseconds computationTime { 0 };
   std::transform(
      audioFiles.begin(), audioFiles.begin() + numFiles,
      std::back_inserter(samples), [&](const std::string& wavFile) {
         const WavMirAudioReader audio { wavFile };
         checksum += GetChecksum(audio);
         QuantizationFitDebugOutput debugOutput;
         std::function<void(double)> progressCb;
         const auto now = std::chrono::steady_clock::now();
         GetMusicalMeterFromSignal(audio, tolerance, progressCb, &debugOutput);
         computationTime +=
            std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now() - now);
         ProgressBar(progressBarWidth, 100 * count++ / numFiles);
         const auto expected = GetBpmFromFilename(wavFile);
         const auto truth = expected.has_value();
         const std::optional<OctaveError> error =
            truth && debugOutput.bpm > 0 ?
               std::make_optional(GetOctaveError(*expected, debugOutput.bpm)) :
               std::nullopt;
         sampleValueCsv << (truth ? "true" : "false") << ","
                        << debugOutput.score << ","
                        << 60. * debugOutput.tatumQuantization.numDivisions /
                              debugOutput.audioFileDuration
                        << "," << debugOutput.bpm << ","
                        << ToString(debugOutput.timeSignature) << ","
                        << (error.has_value() ? error->factor : 0.) << ","
                        << (error.has_value() ? error->remainder : 0.) << ","
                        << debugOutput.tatumQuantization.lag << ","
                        << Pretty(wavFile) << "\n";
         return Sample { truth, debugOutput.score, error };
      });
 
   {
      std::ofstream timeMeasurementFile { "./timeMeasurement.txt" };
      timeMeasurementFile << computationTime.count() << "ms\n";
   }
 
   // AUC of ROC curve. Tells how good our loop/not-loop clasifier is.
   const auto rocInfo = GetRocInfo(
      samples, loopClassifierSettings.at(tolerance).allowedFalsePositiveRate);
 
   const auto strictThreshold =
      GetRocInfo(
         samples, loopClassifierSettings.at(FalsePositiveTolerance::Strict)
                     .allowedFalsePositiveRate)
         .threshold;
 
   // Get RMS of octave errors. Tells how good the BPM estimation is.
   const auto octaveErrors = std::accumulate(
      samples.begin(), samples.end(), std::vector<double> {},
      [&](std::vector<double> octaveErrors, const Sample& sample)
      {
         if (sample.octaveError.has_value())
            octaveErrors.push_back(sample.octaveError->remainder);
         return octaveErrors;
      });
   const auto octaveErrorStd = std::sqrt(
      std::accumulate(
         octaveErrors.begin(), octaveErrors.end(), 0.,
         [&](double sum, double octaveError)
         { return sum + octaveError * octaveError; }) /
      octaveErrors.size());
 
   constexpr auto previousAuc = 0.9312244897959182;
   const auto classifierQualityHasChanged =
      std::abs(rocInfo.areaUnderCurve - previousAuc) >= 0.01;
 
   // Only update the summary if the figures have significantly changed.
   if (classifierQualityHasChanged)
   {
      std::ofstream summaryFile {
         std::string(CMAKE_CURRENT_SOURCE_DIR) +
         "/TatumQuantizationFitBenchmarkingOutput/summary.txt"
      };
      summaryFile << std::setprecision(
                        std::numeric_limits<double>::digits10 + 1)
                  << "AUC: " << rocInfo.areaUnderCurve << "\n"
                  << "Strict Threshold (Minutes-and-Seconds): "
                  << strictThreshold << "\n"
                  << "Lenient Threshold (Beats-and-Measures): "
                  << rocInfo.threshold << "\n"
                  << "Octave error RMS: " << octaveErrorStd << "\n"
                  << "Audio file checksum: " << checksum << "\n";
      // Write sampleValueCsv to a file.
      std::ofstream sampleValueCsvFile {
         std::string(CMAKE_CURRENT_SOURCE_DIR) +
         "/TatumQuantizationFitBenchmarkingOutput/sampleValues.csv"
      };
      sampleValueCsvFile << sampleValueCsv.rdbuf();
   }
 
   // If this changed, then some non-refactoring code change happened. If
   // `rocInfo.areaUnderCurve > previousAuc`, then there's probably no argument
   // about the change. On the contrary, though, the change is either an
   // inadvertent bug, and if it is deliberate, should be well justified.
   REQUIRE(!classifierQualityHasChanged);
}

References audio, MIR::QuantizationFitDebugOutput::audioFileDuration, MIR::QuantizationFitDebugOutput::bpm, MIR::anonymous_namespace{TatumQuantizationFitBenchmarking.cpp}::GetBenchmarkingAudioFiles(), GetBpmFromFilename(), GetChecksum(), GetMusicalMeterFromSignal(), GetOctaveError(), MIR::OnsetQuantization::lag, Lenient, MIR::OnsetQuantization::numDivisions, MIR::anonymous_namespace{TatumQuantizationFitBenchmarking.cpp}::Pretty(), ProgressBar(), runLocally, MIR::QuantizationFitDebugOutput::score, MIR::QuantizationFitDebugOutput::tatumQuantization, MIR::QuantizationFitDebugOutput::timeSignature, and ToString().

Here is the call graph for this function:

TEST_CASE() [8/8]

MIR::TEST_CASE

(

"TatumQuantizationFitVisualization"

)

Definition at line 11 of file TatumQuantizationFitVisualization.cpp.

{
   // This test produces python files containing data. Besides being useful for
   // debugging, after you have run this, you can run
   // `visualize_debug_output.py` to visualize the working of the algorithm, or
   // `visualize_post-processed_STFT.py` to visualize the STFT used to produce
   // the ODF.
 
   if (!runLocally)
      return;
 
   const auto wavFile =
      std::string { CMAKE_CURRENT_SOURCE_DIR } +
      "/benchmarking-dataset/loops/Acoustic Loop Lucaz Collab 116BPM.wav.mp3";
   const WavMirAudioReader audio { wavFile };
   QuantizationFitDebugOutput debugOutput;
   const auto result = GetMusicalMeterFromSignal(
      audio, FalsePositiveTolerance::Lenient, nullptr, &debugOutput);
 
   std::ofstream debug_output_module {
      std::string(CMAKE_CURRENT_SOURCE_DIR) +
      "/TatumQuantizationFitVisualization/debug_output.py"
   };
   debug_output_module << "wavFile = \"" << wavFile << "\"\n";
   debug_output_module << "odfSr = " << debugOutput.odfSr << "\n";
   debug_output_module << "audioFileDuration = "
                       << debugOutput.audioFileDuration << "\n";
   debug_output_module << "score = " << debugOutput.score << "\n";
   debug_output_module << "tatumRate = "
                       << 60. * debugOutput.tatumQuantization.numDivisions /
                             debugOutput.audioFileDuration
                       << "\n";
   debug_output_module << "bpm = " << (result.has_value() ? result->bpm : 0.)
                       << "\n";
   debug_output_module << "lag = " << debugOutput.tatumQuantization.lag << "\n";
   debug_output_module << "odf_peak_indices = [";
   std::for_each(
      debugOutput.odfPeakIndices.begin(), debugOutput.odfPeakIndices.end(),
      [&](int i) { debug_output_module << i << ","; });
   debug_output_module << "]\n";
   PrintPythonVector(debug_output_module, debugOutput.odf, "odf");
   PrintPythonVector(debug_output_module, debugOutput.rawOdf, "rawOdf");
   PrintPythonVector(
      debug_output_module, debugOutput.movingAverage, "movingAverage");
   PrintPythonVector(
      debug_output_module, debugOutput.odfAutoCorr, "odfAutoCorr");
   PrintPythonVector(
      debug_output_module, debugOutput.odfAutoCorrPeakIndices,
      "odfAutoCorrPeakIndices");
 
   std::ofstream stft_log_module {
      std::string { CMAKE_CURRENT_SOURCE_DIR } +
      "/TatumQuantizationFitVisualization/stft_log.py"
   };
   stft_log_module << "wavFile = \"" << wavFile << "\"\n";
   stft_log_module << "sampleRate = " << audio.GetSampleRate() << "\n";
   stft_log_module << "frameRate = " << debugOutput.odfSr << "\n";
   stft_log_module << "stft = [";
   std::for_each(
      debugOutput.postProcessedStft.begin(),
      debugOutput.postProcessedStft.end(), [&](const auto& row) {
         stft_log_module << "[";
         std::for_each(row.begin(), row.end(), [&](float x) {
            stft_log_module << x << ",";
         });
         stft_log_module << "],";
      });
   stft_log_module << "]\n";
}

References audio, MIR::QuantizationFitDebugOutput::audioFileDuration, GetMusicalMeterFromSignal(), MIR::OnsetQuantization::lag, Lenient, MIR::QuantizationFitDebugOutput::movingAverage, MIR::OnsetQuantization::numDivisions, MIR::QuantizationFitDebugOutput::odf, MIR::QuantizationFitDebugOutput::odfAutoCorr, MIR::QuantizationFitDebugOutput::odfAutoCorrPeakIndices, MIR::QuantizationFitDebugOutput::odfPeakIndices, MIR::QuantizationFitDebugOutput::odfSr, MIR::QuantizationFitDebugOutput::postProcessedStft, PrintPythonVector(), MIR::QuantizationFitDebugOutput::rawOdf, runLocally, MIR::QuantizationFitDebugOutput::score, and MIR::QuantizationFitDebugOutput::tatumQuantization.

Here is the call graph for this function:

ToString()

auto MIR::ToString

(

const std::optional< TimeSignature > &

ts

)

Definition at line 139 of file TatumQuantizationFitBenchmarking.cpp.

{
   if (ts.has_value())
      switch (*ts)
      {
      case TimeSignature::TwoTwo:
         return std::string("2/2");
      case TimeSignature::FourFour:
 
         return std::string("4/4");
      case TimeSignature::ThreeFour:
         return std::string("3/4");
      case TimeSignature::SixEight:
         return std::string("6/8");
      default:
         return std::string("none");
      }
   else
      return std::string("none");
}

References FourFour, SixEight, ThreeFour, and TwoTwo.

Referenced by audacity::sentry::Report::ReportImpl::Send(), and TEST_CASE().

Here is the caller graph for this function:

Variable Documentation

loopClassifierSettings

const std::unordered_map<FalsePositiveTolerance, LoopClassifierSettings> MIR::loopClassifierSettings

static

Initial value:

{
      { FalsePositiveTolerance::Strict, { .04, 0.8679721717368254 } },
      { FalsePositiveTolerance::Lenient, { .1, 0.7129778875046098 } },
   }

Tolerance-dependent thresholds, used internally by GetMusicalMeterFromSignal to decide whether to return a null or valid MusicalMeter. The value compared against these are scores which get higher as the signal is more likely to contain music content. They are obtained by running the TatumQuantizationFitBenchmarking test case. More information there.

Definition at line 49 of file MusicInformationRetrieval.h.

Referenced by GetMeterUsingTatumQuantizationFit().

runLocally

constexpr auto MIR::runLocally = false

staticconstexpr

Definition at line 29 of file MirTestUtils.h.

Referenced by TEST_CASE().