MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp} Namespace Reference

Classes
struct	BarDivision

Typedefs
using	PossibleDivHierarchies = std::unordered_map< int, std::vector< BarDivision > >

Functions
PossibleDivHierarchies	GetPossibleDivHierarchies (double audioFileDuration)
int	GetOnsetLag (const std::vector< float > &odf, int numTatums)
double	GetQuantizationDistance (const std::vector< int > &peakIndices, const std::vector< float > &peakValues, size_t size, int numDivisions, int lag)
OnsetQuantization	RunQuantizationExperiment (const std::vector< float > &odf, const std::vector< int > &peakIndices, const std::vector< float > &peakValues, const std::vector< int > &possibleNumTatums, QuantizationFitDebugOutput *debugOutput)
std::optional< TimeSignature >	GetTimeSignature (const BarDivision &barDivision, int numTatums)
double	GetTimeSignatureLikelihood (const std::optional< TimeSignature > &ts, double bpm)
double	GetBeatSelfSimilarityScore (double odfAutoCorrSampleRate, double bpm, const std::vector< float > &odfAutoCorr, int odfAutocorrFullSize, QuantizationFitDebugOutput *debugOutput)
size_t	GetBestBarDivisionIndex (const std::vector< BarDivision > &possibleBarDivisions, double audioFileDuration, int numTatums, const std::vector< float > &odf, QuantizationFitDebugOutput *debugOutput)
MusicalMeter	GetMostLikelyMeterFromQuantizationExperiment (const std::vector< float > &odf, int numTatums, std::vector< BarDivision > possibleBarDivisions, double audioFileDuration, QuantizationFitDebugOutput *debugOutput)
bool	IsSingleEvent (const std::vector< int > &peakIndices, const std::vector< float > &peakValues)

Variables
constexpr auto	minTatumsPerMinute = 100
constexpr auto	maxTatumsPerMinute = 700
constexpr auto	minBpm = 50.
constexpr auto	maxBpm = 200.
constexpr auto	minBeatsPerBar = 2
constexpr auto	maxBeatsPerBar = 4
constexpr std::array< std::pair< int, int >, 9 >	possibleTatumsPerBeat

Typedef Documentation

PossibleDivHierarchies

using MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::PossibleDivHierarchies = typedef std::unordered_map<int , std::vector<BarDivision> >

Definition at line 55 of file GetMeterUsingTatumQuantizationFit.cpp.

Function Documentation

GetBeatSelfSimilarityScore()

double MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetBeatSelfSimilarityScore	(	double	odfAutoCorrSampleRate,
		double	bpm,
		const std::vector< float > &	odfAutoCorr,
		int	odfAutocorrFullSize,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 269 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   // Look for closest peak in `odfAutoCorr`:
   const auto lag = odfAutoCorrSampleRate * 60 / bpm;
   // Traverse all the auto-correlation by steps of `k*lag`, each time
   // finding the closest peak, and average the values. Doing this rather
   // than evaluating only just one peak is more robust to rhythms which
   // miss beats.
   auto periodIndex = 1;
   auto sum = 0.;
   auto numIndices = 0;
   while (true)
   {
      auto j = static_cast<int>(periodIndex++ * lag + .5);
      if (j >= odfAutoCorr.size())
         break;
      while (true)
      {
         const auto i = MapToPositiveHalfIndex(j - 1, odfAutocorrFullSize);
         const auto k = MapToPositiveHalfIndex(j + 1, odfAutocorrFullSize);
         if (
            odfAutoCorr[i] <= odfAutoCorr[j] &&
            odfAutoCorr[j] >= odfAutoCorr[k])
            break;
         j = odfAutoCorr[i] > odfAutoCorr[k] ? i : k;
      }
      sum += odfAutoCorr[j];
      ++numIndices;
      if (debugOutput)
         debugOutput->odfAutoCorrPeakIndices.push_back(j);
   }
   return sum / numIndices;
}

References MapToPositiveHalfIndex(), and MIR::QuantizationFitDebugOutput::odfAutoCorrPeakIndices.

Here is the call graph for this function:

GetBestBarDivisionIndex()

size_t MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetBestBarDivisionIndex	(	const std::vector< BarDivision > &	possibleBarDivisions,
		double	audioFileDuration,
		int	numTatums,
		const std::vector< float > &	odf,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 306 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   const auto odfAutoCorr = GetNormalizedCircularAutocorr(odf);
   if (debugOutput)
      debugOutput->odfAutoCorr = odfAutoCorr;
   const auto odfAutocorrFullSize = 2 * (odfAutoCorr.size() - 1);
   assert(IsPowOfTwo(odfAutocorrFullSize));
   const auto odfAutoCorrSampleRate = odfAutocorrFullSize / audioFileDuration;
 
   std::vector<double> scores(possibleBarDivisions.size());
   // These (still) only depend on the beat rate. We look at
   // self-similarities at beat intervals, so to say, without examining the
   // contents of the beats. Since several bar divisions may yield the same
   // number of beats, we may be able to re-use some calculations.
   std::unordered_map<int /*numBeats*/, double> autocorrScoreCache;
   std::transform(
      possibleBarDivisions.begin(), possibleBarDivisions.end(), scores.begin(),
      [&](const BarDivision& barDivision) {
         const auto numBeats = barDivision.numBars * barDivision.beatsPerBar;
         const auto timeSignature = GetTimeSignature(barDivision, numTatums);
         const auto bpm = 1. * numBeats / audioFileDuration * 60;
         const auto likelihood = GetTimeSignatureLikelihood(timeSignature, bpm);
         if (!autocorrScoreCache.count(numBeats))
            autocorrScoreCache[numBeats] = GetBeatSelfSimilarityScore(
               odfAutoCorrSampleRate, bpm, odfAutoCorr, odfAutocorrFullSize,
               debugOutput);
         const auto selfSimilarityScore = autocorrScoreCache.at(numBeats);
         return likelihood * selfSimilarityScore;
      });
 
   return std::max_element(scores.begin(), scores.end()) - scores.begin();
}

References MIR::GetNormalizedCircularAutocorr(), MIR::IsPowOfTwo(), and MIR::QuantizationFitDebugOutput::odfAutoCorr.

Referenced by GetMostLikelyMeterFromQuantizationExperiment().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMostLikelyMeterFromQuantizationExperiment()

MusicalMeter MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetMostLikelyMeterFromQuantizationExperiment	(	const std::vector< float > &	odf,
		int	numTatums,
		std::vector< BarDivision >	possibleBarDivisions,
		double	audioFileDuration,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 343 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   std::vector<BarDivision> fourFourDivs;
   for_each_in_range(
      IotaRange<size_t>(0, possibleBarDivisions.size()), [&](size_t i) {
         if (
            GetTimeSignature(possibleBarDivisions[i], numTatums) ==
            TimeSignature::FourFour)
            fourFourDivs.push_back(possibleBarDivisions[i]);
      });
 
   // If there is one or more 4/4 possibilities, don't take any risk and only
   // consider these because much more frequent, especially in the world of
   // loops. When we get more clever about time-signature detection, we may be
   // more assertive.
   if (!fourFourDivs.empty())
      std::swap(possibleBarDivisions, fourFourDivs);
 
   const auto winnerIndex = GetBestBarDivisionIndex(
      possibleBarDivisions, audioFileDuration, numTatums, odf, debugOutput);
 
   const auto& barDivision = possibleBarDivisions[winnerIndex];
   const auto numBeats = barDivision.numBars * barDivision.beatsPerBar;
   const auto signature = GetTimeSignature(barDivision, numTatums);
   const auto bpm = 60. * numBeats / audioFileDuration;
 
   return { bpm, signature };
}

References for_each_in_range(), GetBestBarDivisionIndex(), GetTimeSignature(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by MIR::GetMeterUsingTatumQuantizationFit().

Here is the call graph for this function:

Here is the caller graph for this function:

GetOnsetLag()

int MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetOnsetLag	(	const std::vector< float > &	odf,
		int	numTatums
	)

Definition at line 107 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   // Understandably, the first onset of a loop recording isn't typically
   // centered on time 0, or there would be a click at the onset. The entire
   // recording is therefore likely to have a small lag. It is important that we
   // take this lag into account for the quantization distance measure.
   // The code below is equivalent to cross-correlating the odf with a pulse
   // train of frequency `numTatums / odf.size()`. We take the position of the
   // first peak to be the lag.
   const auto pulseTrainPeriod = 1. * odf.size() / numTatums;
   auto max = std::numeric_limits<float>::lowest();
   auto lag = 0;
   while (true)
   {
      auto val = 0.f;
      for_each_in_range(IotaRange { 0, numTatums }, [&](int i) {
         const int j = std::round(i * pulseTrainPeriod) + lag;
         val += (j < odf.size() ? odf[j] : 0.f);
      });
      if (val < max)
         break;
      max = val;
      ++lag;
   }
   return lag - 1;
}

References for_each_in_range(), and fast_float::round().

Here is the call graph for this function:

GetPossibleDivHierarchies()

PossibleDivHierarchies MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetPossibleDivHierarchies

(

double

audioFileDuration

)

Definition at line 61 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   constexpr auto minBarDuration = 1.;
   constexpr auto maxBarDuration = 4.;
   const int minNumBars =
      std::max(std::round(audioFileDuration / maxBarDuration), 1.);
   const int maxNumBars = std::round(audioFileDuration / minBarDuration);
   PossibleDivHierarchies possibleDivHierarchies;
   for_each_in_range(
      IotaRange { minNumBars, maxNumBars + 1 }, [&](int numBars) {
         const auto barDuration = audioFileDuration / numBars;
         const auto minBpb = std::clamp<int>(
            std::floor(minBpm * barDuration / 60), minBeatsPerBar,
            maxBeatsPerBar);
         const auto maxBpb = std::clamp<int>(
            std::ceil(maxBpm * barDuration / 60), minBeatsPerBar,
            maxBeatsPerBar);
         for_each_in_range(
            IotaRange { minBpb, maxBpb + 1 }, [&](int beatsPerBar) {
               std::for_each(
                  possibleTatumsPerBeat.begin(), possibleTatumsPerBeat.end(),
                  [&](const std::pair<int, int>& tatumsPerBeat) {
                     const auto [tatumsPerBeatNum, tatumsPerBeatDen] =
                        tatumsPerBeat;
 
                     // Number of tatums per bar must be round:
                     if (
                        (beatsPerBar * tatumsPerBeatNum) % tatumsPerBeatDen !=
                        0)
                        return;
 
                     const int tatumsPerBar =
                        beatsPerBar * tatumsPerBeatNum / tatumsPerBeatDen;
                     const int numTatums = tatumsPerBar * numBars;
                     const auto tatumRate = 60. * numTatums / audioFileDuration;
                     if (
                        minTatumsPerMinute < tatumRate &&
                        tatumRate < maxTatumsPerMinute)
                        possibleDivHierarchies[numTatums].push_back(
                           BarDivision { numBars, beatsPerBar });
                  });
            });
      });
   return possibleDivHierarchies;
}

References for_each_in_range(), maxBeatsPerBar, maxBpm, minBeatsPerBar, minBpm, possibleTatumsPerBeat, and fast_float::round().

Referenced by MIR::GetMeterUsingTatumQuantizationFit().

Here is the call graph for this function:

Here is the caller graph for this function:

GetQuantizationDistance()

double MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetQuantizationDistance	(	const std::vector< int > &	peakIndices,
		const std::vector< float > &	peakValues,
		size_t	size,
		int	numDivisions,
		int	lag
	)

Definition at line 143 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   std::vector<double> peakDistances(peakIndices.size());
   const auto peakSum =
      std::accumulate(peakValues.begin(), peakValues.end(), 0.);
   const auto odfSamplesPerDiv = 1. * size / numDivisions;
   std::transform(
      peakIndices.begin(), peakIndices.end(), peakDistances.begin(),
      [&](int peakIndex) {
         const auto shiftedIndex = peakIndex - lag;
         const auto closestDiv = std::round(shiftedIndex / odfSamplesPerDiv);
         // Normalized distance between 0 and 1:
         const auto distance =
            (shiftedIndex - closestDiv * odfSamplesPerDiv) / odfSamplesPerDiv;
         // Mutliply by two such that the error spans `[0, 1)`.
         return 2 * std::abs(distance);
      });
   // Calculate the score as the sum of the distances weighted by
   // the odf values:
   const auto weightedAverage =
      std::inner_product(
         peakDistances.begin(), peakDistances.end(), peakValues.begin(), 0.) /
      peakSum;
   return weightedAverage;
}

References size.

GetTimeSignature()

std::optional< TimeSignature > MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetTimeSignature	(	const BarDivision &	barDivision,
		int	numTatums
	)

Definition at line 206 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   const auto numBeats = barDivision.numBars * barDivision.beatsPerBar;
   const auto tatumsPerBeat = 1. * numTatums / numBeats;
   switch (barDivision.beatsPerBar)
   {
   case 2:
      return (tatumsPerBeat == 3) ? TimeSignature::SixEight :
                                    TimeSignature::TwoTwo;
   case 3:
      return TimeSignature::ThreeFour;
   case 4:
      return TimeSignature::FourFour;
   default:
      // Since the bar-division hypotheses are based on these very time
      // signatures, this should never happen. But the code would need to be
      // structured more clearly to really have confidence and risk crashing.
      // For now we accept that the time-signature cannot be recognized in
      // release builds.
      assert(false);
      return std::nullopt;
   }
}

References MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::BarDivision::beatsPerBar, and MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::BarDivision::numBars.

Referenced by GetMostLikelyMeterFromQuantizationExperiment().

Here is the caller graph for this function:

GetTimeSignatureLikelihood()

double MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetTimeSignatureLikelihood	(	const std::optional< TimeSignature > &	ts,
		double	bpm
	)

Definition at line 231 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   // TODO these were taken from a rather old PoC - review.
   if (!ts.has_value())
      return 0.;
 
   static const std::unordered_map<TimeSignature, double> expectedBpms {
      { TimeSignature::TwoTwo, 115. },
      { TimeSignature::FourFour, 115. },
      { TimeSignature::ThreeFour, 140. },
      { TimeSignature::SixEight, 64. },
   };
 
   static const std::unordered_map<TimeSignature, double> bpmStdDevs {
      { TimeSignature::TwoTwo, 25. },
      { TimeSignature::FourFour, 25. },
      { TimeSignature::ThreeFour, 25. },
      { TimeSignature::SixEight, 15. },
   };
 
   // Add a slight bias towards 4/4, which is the most common time signature.
   static const std::unordered_map<TimeSignature, double> tsPrior {
      { TimeSignature::TwoTwo, .1 },
      { TimeSignature::FourFour, .45 },
      { TimeSignature::ThreeFour, .2 },
      { TimeSignature::SixEight, .25 },
   };
 
   const auto mu = expectedBpms.at(*ts);
   const auto sigma = bpmStdDevs.at(*ts);
   const auto tmp = (bpm - mu) / sigma;
   const auto likelihood = std::exp(-.5 * tmp * tmp);
   return likelihood * tsPrior.at(*ts);
}

IsSingleEvent()

bool MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::IsSingleEvent	(	const std::vector< int > &	peakIndices,
		const std::vector< float > &	peakValues
	)

Definition at line 375 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   // Detect single-event recordings, e.g. only just one crash cymbal hit. This
   // will translate as one large peak and maybe a few much smaller ones. In
   // that case we can expect the average to be between these two groups.
   const auto peakAvg =
      std::accumulate(peakValues.begin(), peakValues.end(), 0.) /
      peakIndices.size();
   const auto numPeaksAboveAvg =
      std::count_if(peakValues.begin(), peakValues.end(), [&](float v) {
         return v > peakAvg;
      });
   return numPeaksAboveAvg <= 1;
}

Referenced by MIR::GetMeterUsingTatumQuantizationFit().

Here is the caller graph for this function:

RunQuantizationExperiment()

OnsetQuantization MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::RunQuantizationExperiment	(	const std::vector< float > &	odf,
		const std::vector< int > &	peakIndices,
		const std::vector< float > &	peakValues,
		const std::vector< int > &	possibleNumTatums,
		QuantizationFitDebugOutput *	debugOutput
	)

Definition at line 171 of file GetMeterUsingTatumQuantizationFit.cpp.

{
   const auto quantizations = [&]() {
      std::unordered_map<int, OnsetQuantization> quantizations;
      std::transform(
         possibleNumTatums.begin(), possibleNumTatums.end(),
         std::inserter(quantizations, quantizations.end()), [&](int numTatums) {
            const auto lag = GetOnsetLag(odf, numTatums);
            const auto distance = GetQuantizationDistance(
               peakIndices, peakValues, odf.size(), numTatums, lag);
            return std::make_pair(
               numTatums, OnsetQuantization { distance, lag, numTatums });
         });
      return quantizations;
   }();
 
   const auto bestFitIt = std::min_element(
      quantizations.begin(), quantizations.end(),
      [](const std::pair<int, OnsetQuantization>& a,
         const std::pair<int, OnsetQuantization>& b) {
         return a.second.error < b.second.error;
      });
 
   const auto error = bestFitIt->second.error;
   const auto mostLikelyNumTatums = bestFitIt->first;
   const auto lag = bestFitIt->second.lag;
 
   return { error, lag, mostLikelyNumTatums };
}

Referenced by MIR::GetMeterUsingTatumQuantizationFit().

Here is the caller graph for this function:

Variable Documentation

maxBeatsPerBar

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::maxBeatsPerBar = 4

constexpr

Definition at line 37 of file GetMeterUsingTatumQuantizationFit.cpp.

Referenced by GetPossibleDivHierarchies().

maxBpm

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::maxBpm = 200.

constexpr

Definition at line 35 of file GetMeterUsingTatumQuantizationFit.cpp.

Referenced by GetPossibleDivHierarchies().

maxTatumsPerMinute

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::maxTatumsPerMinute = 700

constexpr

Definition at line 33 of file GetMeterUsingTatumQuantizationFit.cpp.

minBeatsPerBar

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::minBeatsPerBar = 2

constexpr

Definition at line 36 of file GetMeterUsingTatumQuantizationFit.cpp.

Referenced by GetPossibleDivHierarchies().

minBpm

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::minBpm = 50.

constexpr

Definition at line 34 of file GetMeterUsingTatumQuantizationFit.cpp.

Referenced by GetPossibleDivHierarchies().

minTatumsPerMinute

constexpr auto MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::minTatumsPerMinute = 100

constexpr

Definition at line 32 of file GetMeterUsingTatumQuantizationFit.cpp.

possibleTatumsPerBeat

constexpr std::array<std::pair<int, int>, 9> MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::possibleTatumsPerBeat

constexpr

Initial value:

{
   std::pair<int, int> { 1, 1 }, 
   std::pair<int, int> { 2, 1 }, std::pair<int, int> { 3, 1 },
   std::pair<int, int> { 4, 1 }, std::pair<int, int> { 6, 1 }, 
   std::pair<int, int> { 1, 2 }, std::pair<int, int> { 1, 3 },
   std::pair<int, int> { 1, 4 }, std::pair<int, int> { 1, 6 } 
}

Definition at line 38 of file GetMeterUsingTatumQuantizationFit.cpp.

Referenced by GetPossibleDivHierarchies().