[WIP] Livemetadata PR

.gitignore

@@ -57,3 +57,5 @@ lib/*/*.lib
 lib/*/lib/*.lib
 
 lib/qtscript-bytearray/*.cc
+
+*.vscode

build/depends.py

@@ -438,6 +438,7 @@ def configure(self, build, conf):
 class TestHeaders(Dependence):
     def configure(self, build, conf):
         build.env.Append(CPPPATH="#lib/gtest-1.7.0/include")
+        build.env.Append(CPPPATH="#lib/gmock-1.7.0/include")
 
 class FidLib(Dependence):
     def sources(self, build):
@@ -663,6 +664,10 @@ def sources(self, build):
                    "control/controlttrotary.cpp",
                    "control/controlencoder.cpp",
 
+                   "broadcast/metadatabroadcast.cpp",
+                   "broadcast/scrobblingmanager.cpp",
+                   "broadcast/filelistener.cpp",
+
                    "controllers/dlgcontrollerlearning.cpp",
                    "controllers/dlgprefcontroller.cpp",
                    "controllers/dlgprefcontrollers.cpp",
@@ -1093,6 +1098,8 @@ def sources(self, build):
                    "track/trackinfo.cpp",
                    "track/trackrecord.cpp",
                    "track/trackref.cpp",
+                   "track/trackplaytimers.cpp",
+                   "track/tracktiminginfo.cpp",
 
                    "mixer/auxiliary.cpp",
                    "mixer/baseplayer.cpp",

src/broadcast/filelistener.cpp

@@ -0,0 +1,28 @@
+
+#include "broadcast/filelistener.h"
+
+
+FileListener::FileListener(const QString &path) :
+    m_file(path)
+{
+    QFileInfo fileInfo(path);
+    qDebug() << "Absolute path " << fileInfo.absoluteFilePath();
+    qDebug() << "File exists: " << fileInfo.exists();
+    m_file.open(QIODevice::WriteOnly |
+                QIODevice::Text |
+                QIODevice::Unbuffered);
+
+}
+
+void FileListener::broadcastCurrentTrack(TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    QTextStream stream(&m_file);
+    m_file.resize(0);
+    stream << "Now listening " << pTrack->getTitle();
+    stream << " by " << pTrack->getArtist();
+}
+
+void FileListener::scrobbleTrack(TrackPointer pTrack) {
+
+}

src/broadcast/filelistener.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <QFile>
+#include "broadcast/scrobblingservice.h"
+
+class FileListener: public ScrobblingService {
+  public:
+    FileListener(const QString &path);
+    void broadcastCurrentTrack(TrackPointer pTrack) override;
+    void scrobbleTrack(TrackPointer pTrack) override;
+  private:
+    QFile m_file;
+};

src/broadcast/metadatabroadcast.cpp

@@ -0,0 +1,27 @@
+#include "metadatabroadcast.h"
+#include "mixer/playerinfo.h"
+
+MetadataBroadcaster::MetadataBroadcaster(TrackTimers::ElapsedTimer *timer) :
+m_pElapsedTimer(timer)
+{
+
+}
+
+void MetadataBroadcaster::slotReadyToBeScrobbled(TrackPointer pTrack) {
+
+}
+
+void MetadataBroadcaster::slotNowListening(TrackPointer pTrack) {
+    for (auto &service : m_scrobblingServices) {
+        service->broadcastCurrentTrack(pTrack);
+    }
+}
+
+QLinkedList<TrackPointer> MetadataBroadcaster::getTrackedTracks() {
+    return m_trackedTracks;
+}
+
+void MetadataBroadcaster::addNewScrobblingService(ScrobblingService *service) {
+    m_scrobblingServices.push_back(
+        std::move(std::unique_ptr<ScrobblingService>(service)));    
+}

src/broadcast/metadatabroadcast.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QObject>
+#include <QLinkedList>
+#include <list>
+
+#include "broadcast/scrobblingservice.h"
+#include "track/track.h"
+#include "track/trackplaytimers.h"
+
+class MetadataBroadcaster : public QObject {
+    Q_OBJECT
+  public:
+    MetadataBroadcaster(TrackTimers::ElapsedTimer *timer);
+    QLinkedList<TrackPointer> getTrackedTracks();
+    void addNewScrobblingService(ScrobblingService *service);
+
+  public slots:
+    void slotReadyToBeScrobbled(TrackPointer pTrack);
+    void slotNowListening(TrackPointer pTrack);
+  private:
+    QLinkedList<TrackPointer> m_trackedTracks;    
+    std::unique_ptr<TrackTimers::ElapsedTimer> m_pElapsedTimer;
+    std::list<std::unique_ptr<ScrobblingService>> m_scrobblingServices;    
+};

src/broadcast/scrobblingmanager.cpp

@@ -0,0 +1,210 @@
+#include <QObject>
+
+#include "broadcast/scrobblingmanager.h"
+#include "broadcast/filelistener.h"
+#include "control/controlproxy.h"
+#include "engine/enginexfader.h"
+#include "mixer/deck.h"
+#include "mixer/playerinfo.h"
+#include "mixer/playermanager.h"
+
+ScrobblingManager::ScrobblingManager(PlayerManager *manager) :
+m_CPGuiTick("[Master]", "guiTick50ms",this),
+m_CPCrossfader("[Master]","crossfader", this),
+m_CPXFaderCurve(ConfigKey(EngineXfader::kXfaderConfigKey, 
+                "xFaderCurve"),this),
+
+m_CPXFaderCalibration(ConfigKey(EngineXfader::kXfaderConfigKey, 
+                      "xFaderCalibration"),this),
+
+m_CPXFaderMode(ConfigKey(EngineXfader::kXfaderConfigKey, 
+               "xFaderMode"),this),
+
+m_CPXFaderReverse(ConfigKey(EngineXfader::kXfaderConfigKey, 
+                  "xFaderReverse"),this),
+
+m_pManager(manager),
+m_broadcaster(new TrackTimers::ElapsedTimerQt)
+{
+    m_CPGuiTick.connectValueChanged(SLOT(slotGuiTick(double)));
+    connect(&PlayerInfo::instance(),SIGNAL(currentPlayingTrackChanged(TrackPointer)),
+            &m_broadcaster,SLOT(slotNowListening(TrackPointer)));
+    m_broadcaster
+        .addNewScrobblingService(new FileListener("nowListening.txt"));
+    startTimer(1000);
+}
+
+
+void ScrobblingManager::slotTrackPaused(TrackPointer pPausedTrack) {         
+    QMutexLocker locker(&m_mutex);
+    bool allPaused = true;
+    TrackInfo *pausedTrackInfo = nullptr;
+    for (TrackInfo *trackInfo : m_trackList) {
+        if (trackInfo->m_pTrack == pPausedTrack) {
+            pausedTrackInfo = trackInfo;
+            for (QString playerGroup : trackInfo->m_players) {
+                BaseTrackPlayer *player = m_pManager->getPlayer(playerGroup);
+                if (!player->isTrackPaused())
+                    allPaused = false;
+            }
+            break;
+        }                   
+    }
+    if (allPaused && pausedTrackInfo)
+        pausedTrackInfo->m_trackInfo.pausePlayedTime();        
+}
+
+void ScrobblingManager::slotTrackResumed(TrackPointer pResumedTrack) {
+    BaseTrackPlayer *player = qobject_cast<Deck*>(sender());
+    DEBUG_ASSERT(player);    
+    if (player == 0) {
+        qDebug() << "Didn't load track in a deck yet scrobbling "
+                    "received resumed signal.";
+        return;
+    }    
+    if (isTrackAudible(pResumedTrack,player)) {        
+        QMutexLocker locker(&m_mutex);
+        for (TrackInfo *trackInfo : m_trackList) {
+            if (trackInfo->m_pTrack == pResumedTrack) {
+                trackInfo->m_trackInfo.resumePlayedTime();
+                break;
+            }
+        }  
+    }
+}
+
+void ScrobblingManager::slotLoadingTrack(TrackPointer pNewTrack, TrackPointer pOldTrack) {
+    BaseTrackPlayer *sourcePlayer = 
+        qobject_cast<BaseTrackPlayer*>(sender());
+    DEBUG_ASSERT(sourcePlayer);
+    if (pOldTrack) {
+        m_tracksToBeReset.append(TrackToBeReset(pOldTrack,
+            sourcePlayer->getGroup()));
+    }
+}
+
+void ScrobblingManager::slotNewTrackLoaded(TrackPointer pNewTrack) {
+    //Empty player gives a null pointer.
+    if (!pNewTrack)
+        return;          
+    BaseTrackPlayer *player = qobject_cast<BaseTrackPlayer*>(sender());    
+    DEBUG_ASSERT(player);
+    QMutexLocker locker(&m_mutex);    
+    bool trackAlreadyAdded = false;
+    for (TrackInfo *trackInfo : m_trackList) {
+        if (trackInfo->m_pTrack == pNewTrack) {
+            trackInfo->m_players.append(player->getGroup());               
+            trackAlreadyAdded = true;
+            break;
+        }
+    }
+    if (!trackAlreadyAdded) {
+        TrackInfo *newTrackInfo = new TrackInfo(pNewTrack);
+        newTrackInfo->m_players.append(player->getGroup());
+        m_trackList.append(newTrackInfo);                
+        connect(&m_trackList.last()->m_trackInfo,SIGNAL(readyToBeScrobbled(TrackPointer)),
+                &m_broadcaster,SLOT(slotReadyToBeScrobbled(TrackPointer)));
+    }
+    //A new track has been loaded so must unload old one.
+    resetTracks();
+}
+
+void ScrobblingManager::slotPlayerEmpty() {
+    QMutexLocker locker(&m_mutex);
+    resetTracks();
+}
+
+void ScrobblingManager::resetTracks() {
+    for (TrackToBeReset candidateTrack : m_tracksToBeReset) {
+        QLinkedList<TrackInfo*>::Iterator trackListIterator =
+            m_trackList.begin();
+        for (;trackListIterator != m_trackList.end(); ++trackListIterator) {
+            TrackInfo *trackInfo = *trackListIterator;
+            if (trackInfo->m_pTrack == candidateTrack.m_pTrack) {
+                if (!trackInfo->m_players.contains(candidateTrack.
+                    m_playerGroup)) {
+                    qDebug() << "Track doesn't contain player"
+                                "yet is requested for deletion.";
+                    break;
+                }
+                //Load error, stray from engine buffer.
+                BaseTrackPlayer *player = 
+                    m_pManager->getPlayer(candidateTrack.m_playerGroup);
+                if (player->getLoadedTrack() ==
+                    candidateTrack.m_pTrack) 
+                    break;                    
+                QLinkedList<QString>::iterator it = 
+                    trackInfo->m_players.begin();
+                while (it != trackInfo->m_players.end() &&
+                       *it != candidateTrack.m_playerGroup) {                    
+                    ++it;
+                }
+                if (*it == candidateTrack.m_playerGroup) {
+                    trackInfo->m_players.erase(it);
+                }
+                if (trackInfo->m_players.empty()) {
+                    trackInfo->m_trackInfo.pausePlayedTime();
+                    trackInfo->m_trackInfo.resetPlayedTime();
+                    delete trackInfo;
+                    m_trackList.erase(trackListIterator);
+                }
+                break;  
+            }
+        }
+    }
+}
+
+bool ScrobblingManager::isTrackAudible(TrackPointer pTrack, BaseTrackPlayer * pPlayer) {
+    if (pPlayer->getLoadedTrack() != pTrack) {
+        qDebug() << "Track can't be audible because is not in player";
+        return false;
+    }   
+    return getPlayerVolume(pPlayer) >= 0.20;
+}
+
+double ScrobblingManager::getPlayerVolume(BaseTrackPlayer *pPlayer) {
+    double finalVolume;
+    ControlProxy trackPreGain(pPlayer->getGroup(),"pregain",this);
+    double preGain = trackPreGain.get();
+    ControlProxy trackVolume(pPlayer->getGroup(),"volume",this);
+    double volume = trackVolume.get();
+    ControlProxy deckOrientation(pPlayer->getGroup(),"orientation",this);
+    int orientation = deckOrientation.get();    
+
+    double xFaderLeft,xFaderRight;
+
+    EngineXfader::getXfadeGains(m_CPCrossfader.get(),
+                                m_CPXFaderCurve.get(),
+                                m_CPXFaderCalibration.get(),
+                                m_CPXFaderMode.get(),
+                                m_CPXFaderReverse.toBool(),
+                                &xFaderLeft,&xFaderRight);
+    finalVolume = preGain * volume;
+    if (orientation == EngineChannel::LEFT)
+        finalVolume *= xFaderLeft;
+    else if (orientation == EngineChannel::RIGHT) 
+        finalVolume *= xFaderRight;
+    return finalVolume;
+}
+
+void ScrobblingManager::slotGuiTick(double timeSinceLastTick) {
+    for (TrackInfo *trackInfo : m_trackList) {
+        trackInfo->m_trackInfo.slotGuiTick(timeSinceLastTick);
+    }
+}
+
+void ScrobblingManager::timerEvent(QTimerEvent *timerEvent) {
+    for (TrackInfo *trackInfo : m_trackList) {
+        bool inaudible = true;
+        for (QString playerGroup : trackInfo->m_players) {
+            BaseTrackPlayer *player = m_pManager->getPlayer(playerGroup);
+            if (isTrackAudible(trackInfo->m_pTrack,player)) {
+                inaudible = false;
+                break;
+            }
+        }
+        if (inaudible) {
+            trackInfo->m_trackInfo.pausePlayedTime();
+        }
+    }
+}