1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
#include <dsp/onsets/DetectionFunction.h>
#include <dsp/tempotracking/TempoTrackV2.h>
// Class header comes after library includes here since our preprocessor
// definitions interfere with qm-dsp's headers.
#include "analyzer/plugins/analyzerqueenmarybeats.h"
#include "analyzer/constants.h"
namespace mixxx {
namespace {
// This determines the resolution of the resulting BeatMap.
// ~12 ms (86 Hz) is a fair compromise between accuracy and analysis speed,
// also matching the preferred window/step sizes from BeatTrack VAMP.
// For a 44.1 kHz track, we go in 512 sample steps
// TODO: kStepSecs and the waveform sample rate of 441
// (defined in AnalyzerWaveform::initialize) do not align well and thus
// generate interference. Currently we are at this odd factor: 441 * 0.01161 = 5.12.
// This should be adjusted to be an integer.
constexpr float kStepSecs = 0.01161f;
// results in 43 Hz @ 44.1 kHz / 47 Hz @ 48 kHz / 47 Hz @ 96 kHz
constexpr int kMaximumBinSizeHz = 50; // Hz
DFConfig makeDetectionFunctionConfig(int stepSize, int windowSize) {
// These are the defaults for the VAMP beat tracker plugin we used in Mixxx
// 2.0.
DFConfig config;
config.DFType = DF_COMPLEXSD;
config.stepSize = stepSize;
config.frameLength = windowSize;
config.dbRise = 3;
config.adaptiveWhitening = 0;
config.whiteningRelaxCoeff = -1;
config.whiteningFloor = -1;
return config;
}
} // namespace
AnalyzerQueenMaryBeats::AnalyzerQueenMaryBeats()
: m_iSampleRate(0),
m_windowSize(0),
m_stepSize(0) {
}
AnalyzerQueenMaryBeats::~AnalyzerQueenMaryBeats() {
}
bool AnalyzerQueenMaryBeats::initialize(int samplerate) {
m_detectionResults.clear();
m_iSampleRate = samplerate;
m_stepSize = m_iSampleRate * kStepSecs;
m_windowSize = MathUtilities::nextPowerOfTwo(m_iSampleRate / kMaximumBinSizeHz);
m_pDetectionFunction = std::make_unique<DetectionFunction>(
makeDetectionFunctionConfig(m_stepSize, m_windowSize));
qDebug() << "input sample rate is " << m_iSampleRate << ", step size is " << m_stepSize;
m_helper.initialize(
m_windowSize, m_stepSize, [this](double* pWindow, size_t) {
// TODO(rryan) reserve?
m_detectionResults.push_back(
m_pDetectionFunction->processTimeDomain(pWindow));
return true;
});
return true;
}
bool AnalyzerQueenMaryBeats::processSamples(const CSAMPLE* pIn, const int iLen) {
DEBUG_ASSERT(iLen % kAnalysisChannels == 0);
if (!m_pDetectionFunction) {
return false;
}
return m_helper.processStereoSamples(pIn, iLen);
}
bool AnalyzerQueenMaryBeats::finalize() {
m_helper.finalize();
int nonZeroCount = m_detectionResults.size();
while (nonZeroCount > 0 && m_detectionResults.at(nonZeroCount - 1) <= 0.0) {
--nonZeroCount;
}
std::vector<double> df;
std::vector<double> beatPeriod;
std::vector<double> tempi;
const auto required_size = std::max(0, nonZeroCount - 2);
df.reserve(required_size);
beatPeriod.reserve(required_size);
// skip first 2 results as it might have detect noise as onset
// that's how vamp does and seems works best this way
for (int i = 2; i < nonZeroCount; ++i) {
df.push_back(m_detectionResults.at(i));
beatPeriod.push_back(0.0);
}
TempoTrackV2 tt(m_iSampleRate, m_stepSize);
tt.calculateBeatPeriod(df, beatPeriod, tempi);
std::vector<double> beats;
tt.calculateBeats(df, beatPeriod, beats);
m_resultBeats.reserve(beats.size());
for (size_t i = 0; i < beats.size(); ++i) {
double result = (beats.at(i) * m_stepSize) - m_stepSize / 2;
m_resultBeats.push_back(result);
}
m_pDetectionFunction.reset();
return true;
}
} // namespace mixxx
|
