CmrtGroupingService/TrackDAO/WTrackMenu: Add Make Canonical CMRT manual re-election.

Author: Swarnadip-Kar

src/library/dao/trackdao.cpp

@@ -22,6 +22,7 @@
 #include "library/library_prefs.h"
 #include "library/queryutil.h"
 #include "moc_trackdao.cpp"
+#include "musicbrainz/cmrtgroupingservice.h"
 #include "sources/soundsourceproxy.h"
 #include "track/beats.h"
 #include "track/globaltrackcache.h"
@@ -1864,6 +1865,11 @@ TrackPointer TrackDAO::getCmrtCanonicalTrack(TrackId trackId, double* pOffsetSec
     return pCanonical;
 }
 
+bool TrackDAO::promoteCmrtCanonical(TrackId trackId) const {
+    mixxx::CmrtGroupingService groupingService(m_fingerprintDao, m_pConfig);
+    return groupingService.promoteToCanonical(trackId);
+}
+
 void TrackDAO::applyCmrtOverlayToLoadedTrack(const TrackPointer& pTrack) const {
     applyCmrtOverlayIfConfigured(pTrack);
 }

src/library/dao/trackdao.h

@@ -124,6 +124,11 @@ class TrackDAO : public QObject, public virtual DAO, public virtual GlobalTrackC
 
     TrackPointer getCmrtCanonicalTrack(TrackId trackId, double* pOffsetSeconds) const;
 
+    // the same re-election CmrtGroupingService::handleMatchedCandidate()
+    // already runs automatically when a fresh AcoustID match's quality score
+    // beats the existing canonical, just triggered by user choice
+    bool promoteCmrtCanonical(TrackId trackId) const;
+
     bool clearMusicBrainzData(TrackId trackId) const;
 
   signals:

src/musicbrainz/cmrtgroupingservice.cpp

@@ -6,6 +6,7 @@
 #include "analyzer/qualityscorer.h"
 #include "library/library_prefs.h"
 #include "track/globaltrackcache.h"
+#include "track/track.h"
 
 namespace mixxx {
 
@@ -154,6 +155,48 @@ void CmrtGroupingService::processTrack(
     createNewGroup(trackId, *pFpRow, qualityScore);
 }
 
+bool CmrtGroupingService::promoteToCanonical(TrackId trackId) {
+    if (sDebugCmrtGroupingService) {
+        qDebug() << "CmrtGroupingService -> [promoteToCanonical] -> entry"
+                 << "trackId:" << trackId;
+    }
+
+    auto pMember = m_fingerprintDao.getCmrtMemberByTrackId(trackId);
+    if (!pMember) {
+        if (sDebugCmrtGroupingService) {
+            qDebug() << "CmrtGroupingService -> [promoteToCanonical] -> "
+                        "not a cmrt_members row, skipping"
+                     << "trackId:" << trackId;
+        }
+        return false;
+    }
+
+    auto pGroup = m_fingerprintDao.getCmrtGroup(pMember->groupId);
+    if (!pGroup) {
+        qWarning() << "CmrtGroupingService -> [promoteToCanonical] -> "
+                      "member row references missing group"
+                   << pMember->groupId << "for track" << trackId;
+        return false;
+    }
+
+    if (pGroup->canonicalTrackId == trackId) {
+        if (sDebugCmrtGroupingService) {
+            qDebug() << "CmrtGroupingService -> [promoteToCanonical] -> "
+                        "trackId is already canonical, skipping"
+                     << trackId;
+        }
+        return false;
+    }
+
+    replaceCanonical(pMember->groupId,
+            pGroup->canonicalTrackId,
+            trackId,
+            pMember->offsetFromCanonical,
+            pMember->qualityScore,
+            pMember->matchScore);
+    return true;
+}
+
 void CmrtGroupingService::assignToExistingGroup(
         TrackId trackId,
         int groupId,
@@ -307,15 +350,26 @@ void CmrtGroupingService::replaceCanonical(int groupId,
     // 1. Point the group at the new canonical track.
     m_fingerprintDao.updateCanonicalTrack(groupId, newCanonicalId);
 
-    // 2. Add the new track as a member at offset 0 and mark it canonical.
-    CmrtMember newMember;
-    newMember.groupId = groupId;
-    newMember.trackId = newCanonicalId;
-    newMember.offsetFromCanonical = 0.0;
-    newMember.qualityScore = newCanonicalQualityScore;
-    newMember.addedAt = QDateTime::currentDateTimeUtc();
-    m_fingerprintDao.addCmrtMember(newMember);
-    m_fingerprintDao.updateCmrtGroupTrackCount(groupId, +1);
+    // 2. If already a member, update its offset to 0 and mark it canonical.
+    // If not, add the new track as a member at offset 0 and mark it canonical.
+    bool newCanonicalWasUsingCmrtData = false;
+    if (auto pExistingMember = m_fingerprintDao.getCmrtMemberByTrackId(newCanonicalId)) {
+        newCanonicalWasUsingCmrtData = pExistingMember->useCmrtData;
+        m_fingerprintDao.updateMemberOffset(newCanonicalId, 0.0);
+        if (newCanonicalWasUsingCmrtData) {
+            m_fingerprintDao.updateMemberUseCmrtData(newCanonicalId, false);
+        }
+    } else {
+        // 2
+        CmrtMember newMember;
+        newMember.groupId = groupId;
+        newMember.trackId = newCanonicalId;
+        newMember.offsetFromCanonical = 0.0;
+        newMember.qualityScore = newCanonicalQualityScore;
+        newMember.addedAt = QDateTime::currentDateTimeUtc();
+        m_fingerprintDao.addCmrtMember(newMember);
+        m_fingerprintDao.updateCmrtGroupTrackCount(groupId, +1);
+    }
 
     if (auto pNewMeta = m_fingerprintDao.getFingerprintMetadata(newCanonicalId)) {
         pNewMeta->cmrtGroupId = groupId;
@@ -343,6 +397,13 @@ void CmrtGroupingService::replaceCanonical(int groupId,
     const QVector<quint32> newCanonicalFp =
             chromaBytesToVector(m_fingerprintDao.loadChromaFile(newCanonicalId));
 
+    // Looked up once -- every overlaying member below hands the same
+    // pointer to applyCmrtOverlay(). Null if the new canonical isn't
+    // currently loaded anywhere, in which case there's nothing live to
+    // push the update onto (handled per-member below).
+    const TrackPointer pNewCanonicalTrack =
+            GlobalTrackCacheLocker().lookupTrackById(newCanonicalId);
+
     for (const CmrtMember& member : existingMembers) {
         if (member.trackId == oldCanonicalId || member.trackId == newCanonicalId) {
             continue;
@@ -359,28 +420,40 @@ void CmrtGroupingService::replaceCanonical(int groupId,
             pMemberMeta->cmrtOffsetSeconds = offsetSeconds;
             m_fingerprintDao.saveFingerprintMetadata(*pMemberMeta);
         }
+
+        if (!member.useCmrtData) {
+            continue;
+        }
+        // This member's *live* Track object (if it has one -- e.g.
+        // loaded on a deck) is still overlaying the demoted
+        // oldCanonicalId, and will keep doing so Push the new canonical
+        // the freshly-recalculated offset onto it directly instead.
+        if (TrackPointer pOverlayingMember =
+                        GlobalTrackCacheLocker().lookupTrackById(member.trackId)) {
+            if (pNewCanonicalTrack) {
+                pOverlayingMember->applyCmrtOverlay(pNewCanonicalTrack,
+                        offsetSeconds,
+                        pOverlayingMember->getSampleRate());
+            } else {
+                GlobalTrackCacheLocker().purgeTrackId(member.trackId);
+            }
+        }
+        // Not currently loaded anywhere: nothing live to refresh. The
+        // next getTrackById() picks it up naturally, since
+        // applyCmrtOverlayIfConfigured() always reads current DB state.
     }
 
     if (sDebugCmrtGroupingService) {
         qDebug() << "CmrtGroupingService -> [replaceCanonical] -> done, recalculated"
                  << existingMembers.size() << "other member offset(s)";
     }
 
-    // any member with use_cmrt_data=true was overlaying
-    // (via Track::applyCmrtOverlay()) a TrackPointer to the now-demoted
-    // oldCanonicalId. GlobalTrackCacheLocker().purgeTrackId() on each
-    // overlaying member forces the next getTrackById() to reconstruct the
-    // Track from scratch, which re-runs applyCmrtOverlayIfConfigured()
-    // against the new canonical
-    for (const CmrtMember& member : existingMembers) {
-        if (member.useCmrtData) {
-            GlobalTrackCacheLocker().purgeTrackId(member.trackId);
-        }
-    }
-    if (newMember.useCmrtData) {
-        // Shouldn't normally be true for a track that just became
-        // canonical (there's nothing to overlay onto itself), but purge
-        // defensively in case the flag was set before this election ran.
+    if (newCanonicalWasUsingCmrtData) {
+        // newCanonicalId's own overlay flag was just cleared in step 2
+        // above -- purge it too so a live, already-loaded Track object
+        // for it (if any) reconstructs on next load with its own real
+        // cues/beats instead of the stale overlay snapshot it was
+        // showing back when it was still a member.
         GlobalTrackCacheLocker().purgeTrackId(newCanonicalId);
     }
 }

src/musicbrainz/cmrtgroupingservice.h

@@ -22,6 +22,8 @@ class CmrtGroupingService {
 
     void processTrack(TrackId trackId, const QString& musicbrainzRecordingId);
 
+    bool promoteToCanonical(TrackId trackId);
+
   private:
     void assignToExistingGroup(TrackId trackId,
             int groupId,

src/widget/wtrackmenu.cpp

@@ -240,6 +240,8 @@ void WTrackMenu::createMenus() {
     if (featureIsEnabled(Feature::Analyze)) {
         m_pAnalyzeMenu = make_parented<QMenu>(this);
         m_pAnalyzeMenu->setTitle(tr("Analyze"));
+        // Required to show CMRT-disabled tooltip.
+        m_pAnalyzeMenu->setToolTipsVisible(true);
     }
 
     if (featureIsEnabled(Feature::SearchRelated)) {
@@ -610,6 +612,13 @@ void WTrackMenu::createActions() {
                 &QAction::triggered,
                 this,
                 &WTrackMenu::slotAnalyzeFingerprint);
+
+        m_pMakeCmrtCanonicalAction =
+                make_parented<QAction>(tr("Make Canonical (CMRT)"), this);
+        connect(m_pMakeCmrtCanonicalAction,
+                &QAction::triggered,
+                this,
+                &WTrackMenu::slotMakeCmrtCanonical);
     }
 
     // This action is only usable when m_deckGroup is set. That is true only
@@ -792,6 +801,8 @@ void WTrackMenu::setupActions() {
         m_pAnalyzeMenu->addAction(m_pReanalyzeVarBpmAction);
         m_pAnalyzeMenu->addSeparator();
         m_pAnalyzeMenu->addAction(m_pAnalyzeFingerprintAction.get());
+        m_pAnalyzeMenu->addSeparator();
+        m_pAnalyzeMenu->addAction(m_pMakeCmrtCanonicalAction);
         addMenu(m_pAnalyzeMenu);
     }
 
@@ -936,6 +947,32 @@ void WTrackMenu::copyOrAddCmrtHotcuesForSelection(bool replaceExisting) {
     }
 }
 
+void WTrackMenu::slotMakeCmrtCanonical() {
+    promoteSelectionToCmrtCanonical();
+}
+
+void WTrackMenu::promoteSelectionToCmrtCanonical() {
+    const TrackIdList trackIds = getTrackIds();
+    if (trackIds.isEmpty()) {
+        return;
+    }
+
+    TrackDAO& trackDao = m_pLibrary->trackCollectionManager()
+                                 ->internalCollection()
+                                 ->getTrackDAO();
+
+    bool anyPromoted = false;
+    for (const TrackId& id : std::as_const(trackIds)) {
+        if (trackDao.promoteCmrtCanonical(id)) {
+            anyPromoted = true;
+        }
+    }
+
+    if (anyPromoted) {
+        emit m_pLibrary->trackCollectionManager()->cmrtDataChanged();
+    }
+}
+
 int WTrackMenu::getCommonTrackRating() const {
     VERIFY_OR_DEBUG_ASSERT(!isEmpty()) {
         return 0;
@@ -1261,6 +1298,24 @@ void WTrackMenu::updateMenus() {
         // https://github.com/mixxxdj/mixxx/pull/10931#issuecomment-1262559750
         m_pReanalyzeConstBpmAction->setVisible(!useFixedTempo);
         m_pReanalyzeVarBpmAction->setVisible(useFixedTempo);
+
+        const bool anyOverlayActive = anySelectedTrackUsesCmrtOverlay();
+        const bool anyPromotable =
+                !anyOverlayActive && anySelectedTrackIsCmrtMember();
+        m_pMakeCmrtCanonicalAction->setEnabled(anyPromotable);
+        m_pMakeCmrtCanonicalAction->setToolTip(anyPromotable
+                        ? tr("Make the selected track(s) the new canonical track(s) of their "
+                             "CMRT groups.\n"
+                             "Offsets of other members in the group are recalculated with "
+                             "respect to the new canonical track.")
+                        : anyOverlayActive
+                        ? tr("Disabled while \"Use CMRT Data\" is "
+                             "checked. Uncheck it first.")
+                        : tr("Disabled: the selected track(s) are "
+                             "either already the canonical (CMRT) "
+                             "track for their group, or aren't "
+                             "linked to a CMRT group with another "
+                             "track to compare against."));
     }
 
     const auto applyCmrtRestriction = [cmrtActive, &cmrtDisabledTooltip](QAction* pAction) {

src/widget/wtrackmenu.h

@@ -176,6 +176,7 @@ class WTrackMenu : public QMenu {
     void slotSortHotcuesByPosition(HotcueSortMode sortMode);
     void slotCopyCmrtHotcues();
     void slotAddCmrtHotcues();
+    void slotMakeCmrtCanonical();
 
     // Info and metadata
     void slotUpdateReplayGainFromPregain();
@@ -265,6 +266,7 @@ class WTrackMenu : public QMenu {
     // Whether any currently selected track is a non-canonical member of
     // a CMRT group (use: has a canonical track to copy/add hotcues from).
     bool anySelectedTrackIsCmrtMember() const;
+    void promoteSelectionToCmrtCanonical();
     void lockBpm(bool lock);
 
 #ifdef __STEM__
@@ -399,6 +401,7 @@ class WTrackMenu : public QMenu {
     parented_ptr<QAction> m_pSortHotcuesByPositionCompressAction{};
     parented_ptr<QAction> m_pCopyCmrtHotcuesAction{};
     parented_ptr<QAction> m_pAddCmrtHotcuesAction{};
+    parented_ptr<QAction> m_pMakeCmrtCanonicalAction{};
 
     const UserSettingsPointer m_pConfig;
     Library* const m_pLibrary;