// static
bool BpmControl::getBeatContext(const BeatsPointer& pBeats,
const double dPosition,
double* dpPrevBeat,
double* dpNextBeat,
double* dpBeatLength,
double* dpBeatPercentage) {
if (!pBeats) {
return false;
}
double dPrevBeat;
double dNextBeat;
if (!pBeats->findPrevNextBeats(dPosition, &dPrevBeat, &dNextBeat)) {
return false;
}
if (dpPrevBeat != NULL) {
*dpPrevBeat = dPrevBeat;
}
if (dpNextBeat != NULL) {
*dpNextBeat = dNextBeat;
}
return getBeatContextNoLookup(dPosition, dPrevBeat, dNextBeat,
dpBeatLength, dpBeatPercentage);
}
void BpmControl::collectFeatures(GroupFeatureState* pGroupFeatures) const {
// Without a beatgrid we don't know any beat details.
SampleOfTrack sot = getSampleOfTrack();
if (!sot.rate || !m_pBeats) {
return;
}
// Get the current position of this deck.
double dThisPrevBeat = m_pPrevBeat->get();
double dThisNextBeat = m_pNextBeat->get();
double dThisBeatLength;
double dThisBeatFraction;
if (getBeatContextNoLookup(sot.current,
dThisPrevBeat, dThisNextBeat,
&dThisBeatLength, &dThisBeatFraction)) {
pGroupFeatures->has_beat_length_sec = true;
// Note: dThisBeatLength is fractional frames count * 2 (stereo samples)
pGroupFeatures->beat_length_sec = dThisBeatLength / kSamplesPerFrame
/ sot.rate / calcRateRatio();
pGroupFeatures->has_beat_fraction = true;
pGroupFeatures->beat_fraction = dThisBeatFraction;
}
}
void BpmControl::collectFeatures(GroupFeatureState* pGroupFeatures) const {
double fileBpm = m_pFileBpm->get();
if (fileBpm > 0) {
pGroupFeatures->has_file_bpm = true;
pGroupFeatures->file_bpm = fileBpm;
}
double bpm = m_pEngineBpm->get();
if (bpm > 0) {
pGroupFeatures->has_bpm = true;
pGroupFeatures->bpm = bpm;
}
// Without a beatgrid we don't know any beat details.
if (!m_pBeats) {
return;
}
// Get the current position of this deck.
double dThisPosition = getCurrentSample();
double dThisPrevBeat = m_pPrevBeat->get();
double dThisNextBeat = m_pNextBeat->get();
double dThisBeatLength;
double dThisBeatFraction;
if (getBeatContextNoLookup(dThisPosition,
dThisPrevBeat, dThisNextBeat,
&dThisBeatLength, &dThisBeatFraction)) {
pGroupFeatures->has_prev_beat = true;
pGroupFeatures->prev_beat = dThisPrevBeat;
pGroupFeatures->has_next_beat = true;
pGroupFeatures->next_beat = dThisNextBeat;
pGroupFeatures->has_beat_length = true;
pGroupFeatures->beat_length = dThisBeatLength;
pGroupFeatures->has_beat_fraction = true;
pGroupFeatures->beat_fraction = dThisBeatFraction;
}
}
double BpmControl::getNearestPositionInPhase(double dThisPosition, bool respectLoops, bool playing) {
// Without a beatgrid, we don't know the phase offset.
if (!m_pBeats) {
return dThisPosition;
}
// Master buffer is always in sync!
if (getSyncMode() == SYNC_MASTER) {
return dThisPosition;
}
// Get the current position of this deck.
double dThisPrevBeat = m_pPrevBeat->get();
double dThisNextBeat = m_pNextBeat->get();
double dThisBeatLength;
if (dThisPosition > dThisNextBeat || dThisPosition < dThisPrevBeat) {
// There's a chance the COs might be out of date, so do a lookup.
// TODO: figure out a way so that quantized control can take care of
// this so this call isn't necessary.
if (!getBeatContext(m_pBeats, dThisPosition,
&dThisPrevBeat, &dThisNextBeat,
&dThisBeatLength, NULL)) {
return dThisPosition;
}
} else {
if (!getBeatContextNoLookup(dThisPosition,
dThisPrevBeat, dThisNextBeat,
&dThisBeatLength, NULL)) {
return dThisPosition;
}
}
double dOtherBeatFraction;
if (getSyncMode() == SYNC_FOLLOWER) {
// If we're a follower, it's easy to get the other beat fraction
dOtherBeatFraction = m_dSyncTargetBeatDistance;
} else {
// If not, we have to figure it out
EngineBuffer* pOtherEngineBuffer = pickSyncTarget();
if (pOtherEngineBuffer == NULL) {
return dThisPosition;
}
if (playing) {
// "this" track is playing, or just starting
// only match phase if the sync target is playing as well
if (pOtherEngineBuffer->getSpeed() == 0.0) {
return dThisPosition;
}
}
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 (!otherBeats) {
return dThisPosition;
}
double dOtherLength = ControlObject::getControl(
ConfigKey(pOtherEngineBuffer->getGroup(), "track_samples"))->get();
double dOtherEnginePlayPos = pOtherEngineBuffer->getVisualPlayPos();
double dOtherPosition = dOtherLength * dOtherEnginePlayPos;
if (!BpmControl::getBeatContext(otherBeats, dOtherPosition,
NULL, NULL, NULL, &dOtherBeatFraction)) {
return dThisPosition;
}
}
bool this_near_next = dThisNextBeat - dThisPosition <= dThisPosition - dThisPrevBeat;
bool other_near_next = dOtherBeatFraction >= 0.5;
// 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.
double dNewPlaypos = (dOtherBeatFraction + m_dUserOffset) * dThisBeatLength;
if (this_near_next == other_near_next) {
dNewPlaypos += dThisPrevBeat;
} else if (this_near_next && !other_near_next) {
dNewPlaypos += dThisNextBeat;
} else { //!this_near_next && other_near_next
dThisPrevBeat = m_pBeats->findNthBeat(dThisPosition, -2);
dNewPlaypos += dThisPrevBeat;
}
if (respectLoops) {
// We might be seeking outside the loop.
const bool loop_enabled = m_pLoopEnabled->toBool();
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 &&
dThisPosition <= loop_end_position) {
const double loop_length = loop_end_position - loop_start_position;
const double end_delta = dNewPlaypos - loop_end_position;
// Syncing to after the loop end.
if (end_delta > 0 && loop_length > 0.0) {
int i = end_delta / loop_length;
dNewPlaypos = loop_start_position + end_delta - i * loop_length;
// Move new position after loop jump into phase as well.
// This is a recursive call, called only twice because of
// respectLoops = false
dNewPlaypos = getNearestPositionInPhase(dNewPlaypos, false, playing);
}
// Note: Syncing to before the loop beginning is allowed, because
// loops are catching
}
}
return dNewPlaypos;
}
