// TODO(XXX): Get rid of the horrible duplication here between initialise and
// loadStored.
bool AnalyserBeats::initialise(TrackPointer tio, int sampleRate, int totalSamples) {
if (totalSamples == 0) {
return false;
}
bool bPreferencesBeatDetectionEnabled = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_DETECTION_ENABLED)).toInt());
if (!bPreferencesBeatDetectionEnabled) {
qDebug() << "Beat calculation is deactivated";
return false;
}
bool bpmLock = tio->hasBpmLock();
if (bpmLock) {
qDebug() << "Track is BpmLocked: Beat calculation will not start";
return false;
}
bool allow_above = static_cast<bool>(m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_ABOVE_RANGE_ENABLED)).toInt());
if (allow_above) {
m_iMinBpm = 0;
m_iMaxBpm = 9999;
} else {
m_iMinBpm = m_pConfig->getValueString(ConfigKey(BPM_CONFIG_KEY, BPM_RANGE_START)).toInt();
m_iMaxBpm = m_pConfig->getValueString(ConfigKey(BPM_CONFIG_KEY, BPM_RANGE_END)).toInt();
}
m_bPreferencesFixedTempo = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FIXED_TEMPO_ASSUMPTION)).toInt());
m_bPreferencesOffsetCorrection = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FIXED_TEMPO_OFFSET_CORRECTION)).toInt());
m_bPreferencesReanalyzeOldBpm = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_REANALYZE_WHEN_SETTINGS_CHANGE)).toInt());
m_bPreferencesFastAnalysis = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FAST_ANALYSIS_ENABLED)).toInt());
QString library = m_pConfig->getValueString(
ConfigKey(VAMP_CONFIG_KEY, VAMP_ANALYSER_BEAT_LIBRARY));
QString pluginID = m_pConfig->getValueString(
ConfigKey(VAMP_CONFIG_KEY, VAMP_ANALYSER_BEAT_PLUGIN_ID));
m_pluginId = pluginID;
m_iSampleRate = sampleRate;
m_iTotalSamples = totalSamples;
// If the track already has a Beats object then we need to decide whether to
// analyze this track or not.
bool bShouldAnalyze = false;
BeatsPointer pBeats = tio->getBeats();
if (pBeats) {
QString version = pBeats->getVersion();
QString subVersion = pBeats->getSubVersion();
QHash<QString, QString> extraVersionInfo = getExtraVersionInfo(
m_pluginId, m_bPreferencesFastAnalysis);
QString newVersion = BeatFactory::getPreferredVersion(
m_bPreferencesFixedTempo);
QString newSubVersion = BeatFactory::getPreferredSubVersion(
m_bPreferencesFixedTempo, m_bPreferencesOffsetCorrection,
m_iMinBpm, m_iMaxBpm, extraVersionInfo);
if (version == newVersion && subVersion == newSubVersion) {
// If the version and settings have not changed then if the world is
// sane, re-analyzing will do nothing.
bShouldAnalyze = false;
qDebug() << "Beat sub-version has not changed since previous analysis so not analyzing.";
} else if (m_bPreferencesReanalyzeOldBpm) {
bShouldAnalyze = true;
} else if (pBeats->getBpm() == 0.0) {
bShouldAnalyze = true;
qDebug() << "BPM is 0 for track so re-analyzing despite preference settings.";
} else if (pBeats->findNextBeat(0) <= 0.0) {
bShouldAnalyze = true;
qDebug() << "First beat is 0 for grid so analyzing track to find first beat.";
} else {
bShouldAnalyze = false;
qDebug() << "Beat calculation skips analyzing because the track has"
<< "a BPM computed by a previous Mixxx version and user"
<< "preferences indicate we should not change it.";
}
} else {
// No valid keys stored so we want to analyze this track.
bShouldAnalyze = true;
}
if (bShouldAnalyze) {
m_pVamp = new VampAnalyser(m_pConfig);
bShouldAnalyze = m_pVamp->Init(library, pluginID, m_iSampleRate, totalSamples,
m_bPreferencesFastAnalysis);
if (!bShouldAnalyze) {
delete m_pVamp;
m_pVamp = NULL;
}
}
if (bShouldAnalyze) {
qDebug() << "Beat calculation started with plugin" << pluginID;
} else {
qDebug() << "Beat calculation will not start";
}
return bShouldAnalyze;
}
// TODO(XXX): Get rid of the horrible duplication here between initialise and
// loadStored.
bool AnalyserBeats::loadStored(TrackPointer tio) const {
int iMinBpm;
int iMaxBpm;
bool allow_above = static_cast<bool>(m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_ABOVE_RANGE_ENABLED)).toInt());
if (allow_above) {
iMinBpm = 0;
iMaxBpm = 9999;
} else {
iMinBpm = m_pConfig->getValueString(ConfigKey(BPM_CONFIG_KEY, BPM_RANGE_START)).toInt();
iMaxBpm = m_pConfig->getValueString(ConfigKey(BPM_CONFIG_KEY, BPM_RANGE_END)).toInt();
}
bool bPreferencesFixedTempo = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FIXED_TEMPO_ASSUMPTION)).toInt());
bool bPreferencesOffsetCorrection = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FIXED_TEMPO_OFFSET_CORRECTION)).toInt());
bool bPreferencesReanalyzeOldBpm = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_REANALYZE_WHEN_SETTINGS_CHANGE)).toInt());
bool bPreferencesFastAnalysis = static_cast<bool>(
m_pConfig->getValueString(
ConfigKey(BPM_CONFIG_KEY, BPM_FAST_ANALYSIS_ENABLED)).toInt());
bool bpmLock = tio->hasBpmLock();
if (bpmLock) {
qDebug() << "Track is BpmLocked: Beat calculation will not start";
return true;
}
QString library = m_pConfig->getValueString(
ConfigKey(VAMP_CONFIG_KEY, VAMP_ANALYSER_BEAT_LIBRARY));
QString pluginID = m_pConfig->getValueString(
ConfigKey(VAMP_CONFIG_KEY, VAMP_ANALYSER_BEAT_PLUGIN_ID));
// At first start config for QM and Vamp does not exist --> set default
// TODO(XXX): This is no longer present in initialise. Remove?
if (library.isEmpty() || library.isNull())
library = "libmixxxminimal";
if (pluginID.isEmpty() || pluginID.isNull())
pluginID="qm-tempotracker:0";
// If the track already has a Beats object then we need to decide whether to
// analyze this track or not.
BeatsPointer pBeats = tio->getBeats();
if (pBeats) {
QString version = pBeats->getVersion();
QString subVersion = pBeats->getSubVersion();
QHash<QString, QString> extraVersionInfo = getExtraVersionInfo(
pluginID, bPreferencesFastAnalysis);
QString newVersion = BeatFactory::getPreferredVersion(
bPreferencesOffsetCorrection);
QString newSubVersion = BeatFactory::getPreferredSubVersion(
bPreferencesFixedTempo, bPreferencesOffsetCorrection,
iMinBpm, iMaxBpm, extraVersionInfo);
if (version == newVersion && subVersion == newSubVersion) {
// If the version and settings have not changed then if the world is
// sane, re-analyzing will do nothing.
qDebug() << "Beat sub-version has not changed since previous analysis so not analyzing.";
return true;
} else if (bPreferencesReanalyzeOldBpm) {
return false;
} else if (pBeats->getBpm() == 0.0) {
qDebug() << "BPM is 0 for track so re-analyzing despite preference settings.";
return false;
} else if (pBeats->findNextBeat(0) <= 0.0) {
qDebug() << "First beat is 0 for grid so analyzing track to find first beat.";
return false;
} else {
qDebug() << "Beat calculation skips analyzing because the track has"
<< "a BPM computed by a previous Mixxx version and user"
<< "preferences indicate we should not change it.";
return true;
}
} else {
// If we got here, we want to analyze this track.
return false;
}
}
void AnalyserBeats::finalise(TrackPointer tio) {
if (m_pVamp == NULL) {
return;
}
// Call End() here, because the number of total samples may have been
// estimated incorrectly.
bool success = m_pVamp->End();
qDebug() << "Beat Calculation" << (success ? "complete" : "failed");
QVector<double> beats = m_pVamp->GetInitFramesVector();
delete m_pVamp;
m_pVamp = NULL;
if (beats.isEmpty()) {
qDebug() << "Could not detect beat positions from Vamp.";
return;
}
QHash<QString, QString> extraVersionInfo = getExtraVersionInfo(
m_pluginId, m_bPreferencesFastAnalysis);
BeatsPointer pBeats = BeatFactory::makePreferredBeats(
tio, beats, extraVersionInfo,
m_bPreferencesFixedTempo, m_bPreferencesOffsetCorrection,
m_iSampleRate, m_iTotalSamples,
m_iMinBpm, m_iMaxBpm);
BeatsPointer pCurrentBeats = tio->getBeats();
// If the track has no beats object then set our newly generated one
// regardless of beat lock.
if (!pCurrentBeats) {
tio->setBeats(pBeats);
return;
}
// If the track received the beat lock while we were analyzing it then we
// abort setting it.
if (tio->hasBpmLock()) {
qDebug() << "Track was BPM-locked as we were analysing it. Aborting analysis.";
return;
}
// If the user prefers to replace old beatgrids with newly generated ones or
// the old beatgrid has 0-bpm then we replace it.
bool zeroCurrentBpm = pCurrentBeats->getBpm() == 0.0f;
if (m_bPreferencesReanalyzeOldBpm || zeroCurrentBpm) {
if (zeroCurrentBpm) {
qDebug() << "Replacing 0-BPM beatgrid with a" << pBeats->getBpm()
<< "beatgrid.";
}
tio->setBeats(pBeats);
return;
}
// If we got here then the user doesn't want to replace the beatgrid but
// since the first beat is zero we'll apply the offset we just detected.
double currentFirstBeat = pCurrentBeats->findNextBeat(0);
double newFirstBeat = pBeats->findNextBeat(0);
if (currentFirstBeat == 0.0 && newFirstBeat > 0) {
pCurrentBeats->translate(newFirstBeat);
}
}
bool BpmControl::syncPhase(EngineBuffer* pOtherEngineBuffer) {
if (!pOtherEngineBuffer) {
return false;
}
TrackPointer otherTrack = pOtherEngineBuffer->getLoadedTrack();
BeatsPointer otherBeats = otherTrack ? otherTrack->getBeats() : BeatsPointer();
// If either track does not have beats, then we can't adjust the phase.
if (!m_pBeats || !otherBeats) {
return false;
}
// Get the file BPM of each song.
//double dThisBpm = m_pBeats->getBpm();
//double dOtherBpm = ControlObject::getControl(
//ConfigKey(pOtherEngineBuffer->getGroup(), "file_bpm"))->get();
// Get the current position of both decks
double dThisPosition = getCurrentSample();
double dOtherLength = ControlObject::getControl(
ConfigKey(pOtherEngineBuffer->getGroup(), "track_samples"))->get();
double dOtherEnginePlayPos = ControlObject::getControl(
ConfigKey(pOtherEngineBuffer->getGroup(), "visual_playposition"))->get();
double dOtherPosition = dOtherLength * dOtherEnginePlayPos;
double dThisPrevBeat = m_pBeats->findPrevBeat(dThisPosition);
double dThisNextBeat = m_pBeats->findNextBeat(dThisPosition);
if (dThisPrevBeat == -1 || dThisNextBeat == -1 ||
dOtherEnginePlayPos == -1 || dOtherLength == 0) {
return false;
}
// Protect against the case where we are sitting exactly on the beat.
if (dThisPrevBeat == dThisNextBeat) {
dThisNextBeat = m_pBeats->findNthBeat(dThisPosition, 2);
}
double dOtherPrevBeat = otherBeats->findPrevBeat(dOtherPosition);
double dOtherNextBeat = otherBeats->findNextBeat(dOtherPosition);
if (dOtherPrevBeat == -1 || dOtherNextBeat == -1) {
return false;
}
// Protect against the case where we are sitting exactly on the beat.
if (dOtherPrevBeat == dOtherNextBeat) {
dOtherNextBeat = otherBeats->findNthBeat(dOtherPosition, 2);
}
double dThisBeatLength = fabs(dThisNextBeat - dThisPrevBeat);
double dOtherBeatLength = fabs(dOtherNextBeat - dOtherPrevBeat);
double dOtherBeatFraction = (dOtherPosition - dOtherPrevBeat) / dOtherBeatLength;
double dNewPlaypos;
bool this_near_next = dThisNextBeat - dThisPosition <= dThisPosition - dThisPrevBeat;
bool other_near_next = dOtherNextBeat - dOtherPosition <= dOtherPosition - dOtherPrevBeat;
// We want our beat fraction to be identical to theirs.
// If the two tracks have similar alignment, adjust phase is straight-
// forward. Use the same fraction for both beats, starting from the previous
// beat. But if This track is nearer to the next beat and the Other track
// is nearer to the previous beat, use This Next beat as the starting point
// for the phase. (ie, we pushed the sync button late). If This track
// is nearer to the previous beat, but the Other track is nearer to the
// next beat, we pushed the sync button early so use the double-previous
// beat as the basis for the adjustment.
//
// This makes way more sense when you're actually mixing.
//
// TODO(XXX) Revisit this logic once we move away from tempo-locked,
// infinite beatgrids because the assumption that findNthBeat(-2) always
// works will be wrong then.
if (this_near_next == other_near_next) {
dNewPlaypos = dThisPrevBeat + dOtherBeatFraction * dThisBeatLength;
} else if (this_near_next && !other_near_next) {
dNewPlaypos = dThisNextBeat + dOtherBeatFraction * dThisBeatLength;
} else { //!this_near_next && other_near_next
dThisPrevBeat = m_pBeats->findNthBeat(dThisPosition, -2);
dNewPlaypos = dThisPrevBeat + dOtherBeatFraction * dThisBeatLength;
}
// We might be seeking outside the loop.
const bool loop_enabled = m_pLoopEnabled->get() > 0.0;
const double loop_start_position = m_pLoopStartPosition->get();
const double loop_end_position = m_pLoopEndPosition->get();
// Cases for sanity:
//
// CASE 1
// Two identical 1-beat loops, out of phase by X samples.
// Other deck is at its loop start.
// This deck is half way through. We want to jump forward X samples to the loop end point.
//
// Two identical 1-beat loop, out of phase by X samples.
// Other deck is
// If sync target is 50% through the beat,
// If we are at the loop end point and hit sync, jump forward X samples.
// TODO(rryan): Revise this with something that keeps a broader number of
// cases in sync. This at least prevents breaking out of the loop.
if (loop_enabled) {
const double loop_length = loop_end_position - loop_start_position;
if (loop_length <= 0.0) {
return false;
}
// TODO(rryan): If loop_length is not a multiple of dThisBeatLength should
// we bail and not sync phase?
// Syncing to after the loop end.
double end_delta = dNewPlaypos - loop_end_position;
if (end_delta > 0) {
int i = end_delta / loop_length;
dNewPlaypos = loop_start_position + end_delta - i * loop_length;
}
// Syncing to before the loop beginning.
double start_delta = loop_start_position - dNewPlaypos;
if (start_delta > 0) {
int i = start_delta / loop_length;
dNewPlaypos = loop_end_position - start_delta + i * loop_length;
}
}
seekAbs(dNewPlaypos);
return true;
}