path: root/src/engine/sync/enginesync.cpp

#include "engine/sync/enginesync.h"

#include <QStringList>

#include "engine/channels/enginechannel.h"
#include "engine/enginebuffer.h"
#include "engine/sync/internalclock.h"
#include "util/assert.h"
#include "util/logger.h"

namespace {
const mixxx::Logger kLogger("EngineSync");
} // namespace

EngineSync::EngineSync(UserSettingsPointer pConfig)
        : BaseSyncableListener(pConfig) {
}

EngineSync::~EngineSync() {
}

Syncable* EngineSync::pickMaster(Syncable* enabling_syncable) {
    // If there is an explicit master, and it is playing, keep it.
    if (m_pMasterSyncable && m_pMasterSyncable->getSyncMode() == SYNC_MASTER_EXPLICIT) {
        return m_pMasterSyncable;
    }

    Syncable* first_stopped_deck = nullptr;
    Syncable* first_playing_deck = nullptr;
    int stopped_deck_count = 0;
    int playing_deck_count = 0;

    for (const auto& pSyncable : m_syncables) {
        if (pSyncable->getBaseBpm() <= 0.0) {
            continue;
        }

        if (pSyncable != enabling_syncable) {
            if (!pSyncable->getChannel()->isPrimaryDeck()) {
                continue;
            }
            if (!pSyncable->isSynchronized()) {
                continue;
            }
        }

        if (pSyncable->isPlaying()) {
            if (playing_deck_count == 0) {
                first_playing_deck = pSyncable;
            }
            playing_deck_count++;
        } else {
            if (stopped_deck_count == 0) {
                first_stopped_deck = pSyncable;
            }
            stopped_deck_count++;
        }
    }

    if (playing_deck_count == 1) {
        return first_playing_deck;
    } else if (playing_deck_count > 1) {
        return m_pInternalClock;
    }

    // No valid playing sync decks
    if (stopped_deck_count == 1) {
        return first_stopped_deck;
    } else if (stopped_deck_count > 1) {
        return m_pInternalClock;
    }

    // No valid stopped sync decks
    return nullptr;
}

void EngineSync::requestSyncMode(Syncable* pSyncable, SyncMode mode) {
    if (kLogger.traceEnabled()) {
        kLogger.trace() << "EngineSync::requestSyncMode" << pSyncable->getGroup() << mode;
    }
    // Based on the call hierarchy I don't think this is possible. (Famous last words.)
    VERIFY_OR_DEBUG_ASSERT(pSyncable) {
        return;
    }

    if (mode == SYNC_MASTER_EXPLICIT) {
        // Note: we enable master unconditionally. If it has no valid
        // tempo, the tempo of the old master remains until we know better
        activateMaster(pSyncable, true);
        if (pSyncable->getBaseBpm() > 0) {
            setMasterParams(pSyncable, pSyncable->getBeatDistance(),
                            pSyncable->getBaseBpm(), pSyncable->getBpm());
        }
    } else if (mode == SYNC_FOLLOWER ||
            mode == SYNC_MASTER_SOFT ||
            pSyncable == m_pInternalClock) {
        // Note: SYNC_MASTER_SOFT and SYNC_FOLLOWER cannot be set explicitly,
        // they are calculated by pickMaster.
        // Internal clock cannot be disabled, it is always listening
        if (m_pMasterSyncable == pSyncable) {
            // This Syncable was master before. Hand off.
            m_pMasterSyncable = nullptr;
            pSyncable->setSyncMode(SYNC_FOLLOWER);
        }
        Syncable* newMaster = pickMaster(pSyncable);
        if (newMaster) {
            activateMaster(newMaster, false);
        }
        if (pSyncable != newMaster) {
            activateFollower(pSyncable);
        }
    } else {
        deactivateSync(pSyncable);
    }
    checkUniquePlayingSyncable();
}

Syncable* EngineSync::findBpmMatchTarget(Syncable* requester) {
    Syncable* pStoppedTarget = nullptr;

    for (const auto& pOtherSyncable : qAsConst(m_syncables)) {
        if (pOtherSyncable == requester) {
            continue;
        }
        // Skip non-master decks, like preview decks.
        if (!pOtherSyncable->getChannel()->isMasterEnabled()) {
            continue;
        }
        if (!pOtherSyncable->getChannel()->isPrimaryDeck()) {
            continue;
        }
        if (pOtherSyncable->getBaseBpm() == 0.0) {
            continue;
        }

        // If the other deck is playing we stop looking immediately. Otherwise continue looking
        // for a playing deck with bpm > 0.0.
        if (pOtherSyncable->isPlaying()) {
            return pOtherSyncable;
        }

        // The target is not playing. If this is the first one we have seen,
        // record it. If we never find a playing target, we'll return
        // this one as a fallback.
        if (!pStoppedTarget && !requester->isPlaying()) {
            pStoppedTarget = pOtherSyncable;
        }
    }

    return pStoppedTarget;
}

void EngineSync::requestEnableSync(Syncable* pSyncable, bool bEnabled) {
    if (kLogger.traceEnabled()) {
        kLogger.trace() << "EngineSync::requestEnableSync " << pSyncable->getGroup() << bEnabled;
    }
    // Sync disable request, hand off to a different function
    if (!bEnabled) {
        // Already disabled?  Do nothing.
        if (!pSyncable->isSynchronized()) {
            return;
        }
        deactivateSync(pSyncable);
        return;
    }

    // Already enabled?  Do nothing.
    if (pSyncable->isSynchronized()) {
        return;
    }

    // Now go through and possible pick a new master deck if we can find one.
    Syncable* newMaster = pickMaster(pSyncable);

    // The syncable that will be used to initialize the master params, if needed
    Syncable* pParamsSyncable = nullptr;

    if (newMaster == m_pInternalClock) {
        // This happens if we had a single master before
        if (m_pMasterSyncable != m_pInternalClock) {
            if (pSyncable->isPlaying()) {
                // We are already playing, only change speed if
                // the old master is playing as well
                if (m_pMasterSyncable && m_pMasterSyncable->isPlaying()) {
                    // Adopt value from the old master if it is still playing
                    pParamsSyncable = m_pMasterSyncable;
                } else {
                    DEBUG_ASSERT(pSyncable->getBaseBpm() > 0);
                    pParamsSyncable = pSyncable;
                }
            } else {
                if (m_pMasterSyncable) {
                    pParamsSyncable = m_pMasterSyncable;
                } else {
                    // Can this ever happen?
                    DEBUG_ASSERT(false);
                    pParamsSyncable = pSyncable;
                }
            }
        }
    } else if (newMaster == pSyncable) {
        // There is no other synced deck. If any other deck is playing we will
        // match the first available bpm -- sync won't be enabled on these decks,
        // otherwise there would have been a master.
        pParamsSyncable = findBpmMatchTarget(pSyncable);
        if (pParamsSyncable == nullptr) {
            // We weren't able to find anything to match to, so set ourselves as the
            // target.  That way we'll use our own params when we setMasterParams below.
            pParamsSyncable = pSyncable;
        }
    } else if (newMaster) {
        // This happens if this Deck has no valid BPM
        // avoid that other decks are adjusted
        pParamsSyncable = newMaster;
    } else {
        // This happens if there is no other SyncDeck around and this has no valid BPM
        // nothing to do.
    }

    if (newMaster != nullptr && newMaster != m_pMasterSyncable) {
        activateMaster(newMaster, false);
    }

    if (newMaster != pSyncable) {
        pSyncable->setSyncMode(SYNC_FOLLOWER);
    }

    if (pParamsSyncable != nullptr) {
        setMasterParams(pParamsSyncable,
                pParamsSyncable->getBeatDistance(),
                pParamsSyncable->getBaseBpm(),
                pParamsSyncable->getBpm());
        pSyncable->setInstantaneousBpm(pParamsSyncable->getBpm());
        if (pParamsSyncable != pSyncable) {
            pSyncable->requestSync();
        }
    }
}

void EngineSync::notifyPlaying(Syncable* pSyncable, bool playing) {
    Q_UNUSED(playing);
    if (kLogger.traceEnabled()) {
        kLogger.trace() << "EngineSync::notifyPlaying" << pSyncable->getGroup() << playing;
    <