void BpmControl::slotControlBeatSync(double v) { if (!v) return; // If the player is playing, and adjusting its tempo succeeded, adjust its // phase so that it plays in sync. EngineBuffer* pOtherEngineBuffer = pickSyncTarget(); if (syncTempo(pOtherEngineBuffer) && m_pPlayButton->get() > 0) { syncPhase(pOtherEngineBuffer); } }
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; }
bool BpmControl::syncTempo() { EngineBuffer* pOtherEngineBuffer = pickSyncTarget(); if (!pOtherEngineBuffer) { return false; } double fThisBpm = m_pEngineBpm->get(); double fThisLocalBpm = m_pLocalBpm->get(); double fOtherBpm = pOtherEngineBuffer->getBpm(); double fOtherLocalBpm = pOtherEngineBuffer->getLocalBpm(); //qDebug() << "this" << "bpm" << fThisBpm << "filebpm" << fThisFileBpm; //qDebug() << "other" << "bpm" << fOtherBpm << "filebpm" << fOtherFileBpm; //////////////////////////////////////////////////////////////////////////// // Rough proof of how syncing works -- rryan 3/2011 // ------------------------------------------------ // // Let this and other denote this deck versus the sync-target deck. // // The goal is for this deck's effective BPM to equal the other decks. // // thisBpm = otherBpm // // The overall rate is the product of range, direction, and scale plus 1: // // rate = 1.0 + rateDir * rateRange * rateScale // // An effective BPM is the file-bpm times the rate: // // bpm = fileBpm * rate // // So our goal is to tweak thisRate such that this equation is true: // // thisFileBpm * (1.0 + thisRate) = otherFileBpm * (1.0 + otherRate) // // so rearrange this equation in terms of thisRate: // // thisRate = (otherFileBpm * (1.0 + otherRate)) / thisFileBpm - 1.0 // // So the new rateScale to set is: // // thisRateScale = ((otherFileBpm * (1.0 + otherRate)) / thisFileBpm - 1.0) / (thisRateDir * thisRateRange) if (fOtherBpm > 0.0 && fThisBpm > 0.0) { // The desired rate is the other decks effective rate divided by this // deck's file BPM. This gives us the playback rate that will produce an // effective BPM equivalent to the other decks. double desiredRate = fOtherBpm / fThisLocalBpm; // Test if this buffer's bpm is the double of the other one, and adjust // the rate scale. I believe this is intended to account for our BPM // algorithm sometimes finding double or half BPMs. This avoids drastic // scales. float fFileBpmDelta = fabs(fThisLocalBpm - fOtherLocalBpm); if (fabs(fThisLocalBpm * 2.0 - fOtherLocalBpm) < fFileBpmDelta) { desiredRate /= 2.0; } else if (fabs(fThisLocalBpm - 2.0 * fOtherLocalBpm) < fFileBpmDelta) { desiredRate *= 2.0; } // Subtract the base 1.0, now fDesiredRate is the percentage // increase/decrease in playback rate, not the playback rate. double desiredRateShift = desiredRate - 1.0; // Ensure the rate is within resonable boundaries. Remember, this is the // percent to scale the rate, not the rate itself. If fDesiredRate was -1, // that would mean the deck would be completely stopped. If fDesiredRate // is 1, that means it is playing at 2x speed. This limit enforces that // we are scaled between 0.5x and 2x. if (desiredRateShift < 1.0 && desiredRateShift > -0.5) { m_pEngineBpm->set(m_pLocalBpm->get() * desiredRate); // Adjust the rateScale. We have to divide by the range and // direction to get the correct rateScale. double desiredRateSlider = desiredRateShift / (m_pRateRange->get() * m_pRateDir->get()); // And finally, set the slider m_pRateSlider->set(desiredRateSlider); return true; } } return false; }
void KeyControl::slotSyncKey(double v) { if (v > 0) { EngineBuffer* pOtherEngineBuffer = pickSyncTarget(); syncKey(pOtherEngineBuffer); } }
void BpmControl::slotControlBeatSyncTempo(double v) { if (!v) return; EngineBuffer* pOtherEngineBuffer = pickSyncTarget(); syncTempo(pOtherEngineBuffer); }