library: display hotcues on overview waveform

src/library/overviewcache.cpp

@@ -3,10 +3,15 @@
 #include <QFutureWatcher>
 #include <QPixmapCache>
 #include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlRecord>
 #include <QtConcurrentRun>
 
 #include "library/dao/analysisdao.h"
+#include "library/dao/cuedao.h"
+#include "library/dao/trackschema.h"
 #include "moc_overviewcache.cpp"
+#include "track/cueinfo.h"
 #include "util/db/dbconnectionpooled.h"
 #include "util/db/dbconnectionpooler.h"
 #include "util/logger.h"
@@ -93,9 +98,14 @@ QPixmap OverviewCache::requestCachedOverview(
 QPixmap OverviewCache::requestUncachedOverview(
         mixxx::OverviewType type,
         const WaveformSignalColors& signalColors,
-        TrackId trackId,
+        TrackPointer pTrack,
         const QObject* pRequester,
         QSize desiredSize) {
+    if (!pTrack) {
+        return QPixmap();
+    }
+
+    TrackId trackId = pTrack->getId();
     if (!trackId.isValid()) {
         return QPixmap();
     }
@@ -108,8 +118,6 @@ QPixmap OverviewCache::requestUncachedOverview(
         return QPixmap();
     }
 
-    // kLogger.info() << "requestUncachedOverview()" << trackId << pRequester << desiredSize;
-
     const QString cacheKey = pixmapCacheKey(trackId, desiredSize, type);
     QPixmap pixmap;
     // Maybe it has been cached since the request for cached image?
@@ -127,7 +135,7 @@ QPixmap OverviewCache::requestUncachedOverview(
             m_pDbConnectionPool,
             type,
             signalColors,
-            trackId,
+            pTrack,
             pRequester,
             desiredSize);
     connect(watcher,
@@ -145,40 +153,55 @@ OverviewCache::FutureResult OverviewCache::prepareOverview(
         const mixxx::DbConnectionPoolPtr pDbConnectionPool,
         mixxx::OverviewType type,
         const WaveformSignalColors& signalColors,
-        TrackId trackId,
+        TrackPointer pTrack,
         const QObject* pRequester,
         QSize desiredSize) {
-    // kLogger.warning() << "prepareOverview" << trackId;
     FutureResult result;
-    result.trackId = trackId;
+    result.trackId = pTrack ? pTrack->getId() : TrackId();
     result.type = type;
     result.requester = pRequester;
     result.image = QImage();
     result.resizedToSize = desiredSize;
 
-    if (!trackId.isValid() || desiredSize.isEmpty()) {
+    if (!pTrack || !result.trackId.isValid() || desiredSize.isEmpty()) {
         return result;
     }
 
     mixxx::DbConnectionPooler dbConnectionPooler(pDbConnectionPool);
+    QSqlDatabase database = mixxx::DbConnectionPooled(pDbConnectionPool);
 
     AnalysisDao analysisDao(pConfig);
-    analysisDao.initialize(mixxx::DbConnectionPooled(pDbConnectionPool));
+    analysisDao.initialize(database);
 
     QList<AnalysisDao::AnalysisInfo> analyses =
             analysisDao.getAnalysesForTrackByType(
-                    trackId, AnalysisDao::AnalysisType::TYPE_WAVESUMMARY);
+                    result.trackId, AnalysisDao::AnalysisType::TYPE_WAVESUMMARY);
 
     if (!analyses.isEmpty()) {
         ConstWaveformPointer pLoadedTrackWaveformSummary = ConstWaveformPointer(
                 WaveformFactory::loadWaveformFromAnalysis(analyses.first()));
 
         if (!pLoadedTrackWaveformSummary.isNull()) {
+            // get track duration and cue info from the Track object
+            const double trackDurationMillis = pTrack->getDuration() * 1000.0;
+            const mixxx::audio::SampleRate sampleRate = pTrack->getSampleRate();
+
+            // convert cue points to cue infos
+            QList<mixxx::CueInfo> cueInfos;
+            const QList<CuePointer> cuePoints = pTrack->getCuePoints();
+            for (const auto& pCue : cuePoints) {
+                if (pCue) {
+                    cueInfos.append(pCue->getCueInfo(sampleRate));
+                }
+            }
+
             QImage image = waveformOverviewRenderer::render(
                     pLoadedTrackWaveformSummary,
                     type,
                     signalColors,
-                    true /* mono, bottom-aligned */);
+                    true /* mono, bottom-aligned */,
+                    cueInfos,
+                    trackDurationMillis);
 
             if (!image.isNull()) {
                 image = resizeImageSize(image, desiredSize);

src/library/overviewcache.h

@@ -4,6 +4,7 @@
 
 #include "analyzer/analyzerprogress.h"
 #include "preferences/usersettings.h"
+#include "track/track.h"
 #include "track/trackid.h"
 #include "util/db/dbconnectionpool.h"
 #include "util/singleton.h"
@@ -24,7 +25,7 @@ class OverviewCache : public QObject, public Singleton<OverviewCache> {
     QPixmap requestUncachedOverview(
             mixxx::OverviewType type,
             const WaveformSignalColors& signalColors,
-            TrackId trackId,
+            TrackPointer pTrack,
             const QObject* pRequester,
             QSize desiredSize);
 
@@ -63,7 +64,7 @@ class OverviewCache : public QObject, public Singleton<OverviewCache> {
             mixxx::DbConnectionPoolPtr pDbConnectionPool,
             mixxx::OverviewType type,
             const WaveformSignalColors& signalColors,
-            TrackId trackId,
+            TrackPointer pTrack,
             const QObject* pRequester,
             QSize desiredSize);
 

src/library/tabledelegates/overviewdelegate.cpp

@@ -157,17 +157,24 @@ void OverviewDelegate::paintItem(QPainter* painter,
             // non-cache we can request an update.
             m_cacheMissIds.insert(trackId);
         } else {
-            pixmap = m_pCache->requestUncachedOverview(m_type,
-                    m_signalColors,
-                    trackId,
-                    this,
-                    option.rect.size() * scaleFactor);
+            // get track to access cues and duration
+            TrackPointer pTrack = m_pTrackModel->getTrack(index);
+            if (pTrack) {
+                pixmap = m_pCache->requestUncachedOverview(m_type,
+                        m_signalColors,
+                        pTrack,
+                        this,
+                        option.rect.size() * scaleFactor);
+            }
         }
         paintItemBackground(painter, option, index);
     } else {
         // We have a cached pixmap, paint it
         pixmap.setDevicePixelRatio(scaleFactor);
+        // disable smooth transform to preserve marker opacity
+        painter->setRenderHint(QPainter::SmoothPixmapTransform, false);
         painter->drawPixmap(option.rect, pixmap);
+        painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
     }
 
     // Draw a border if the cover art cell has focus

src/waveform/renderers/waveformoverviewrenderer.cpp

@@ -2,8 +2,10 @@
 
 #include <QPainter>
 
+#include "util/color/color.h"
 #include "util/colorcomponents.h"
 #include "util/math.h"
+#include "util/painterscope.h"
 #include "util/timer.h"
 #include "waveform/renderers/waveformsignalcolors.h"
 
@@ -12,7 +14,9 @@ namespace waveformOverviewRenderer {
 QImage render(ConstWaveformPointer pWaveform,
         mixxx::OverviewType type,
         const WaveformSignalColors& signalColors,
-        bool mono) {
+        bool mono,
+        const QList<mixxx::CueInfo>& cueInfos,
+        double trackDurationMillis) {
     const int dataSize = pWaveform->getDataSize();
     if (dataSize <= 0) {
         return QImage();
@@ -47,6 +51,8 @@ QImage render(ConstWaveformPointer pWaveform,
                 mono);
     }
 
+    // markers are drawn after normalization for maximum visibility
+
     // Evaluate waveform ratio peak
     float peak = 1;
     for (int i = 0; i < dataSize; i += 2) {
@@ -73,6 +79,90 @@ QImage render(ConstWaveformPointer pWaveform,
             Qt::IgnoreAspectRatio,
             Qt::SmoothTransformation);
 
+    // now draw markers on the final normalized image for maximum visibility
+    if (trackDurationMillis > 0) {
+        // ensure image format supports proper alpha channel handling
+        if (normImage.format() != QImage::Format_ARGB32_Premultiplied) {
+            normImage = normImage.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+        }
+
+        QPainter markerPainter(&normImage);
+        markerPainter.setRenderHint(QPainter::Antialiasing, false);
+        const int imageWidth = normImage.width();
+        const int imageHeight = normImage.height();
+
+        // draw minute markers - make them taller and brighter
+        const int markerHeight = static_cast<int>(imageHeight * 0.2);
+        const int lowerMarkerYPos = static_cast<int>(imageHeight * 0.8);
+
+        // use pure opaque white
+        QColor minuteColor(255, 255, 255, 255);
+
+        for (double currentMarkerMillis = 60000; currentMarkerMillis < trackDurationMillis;
+                currentMarkerMillis += 60000) {
+            const int x = static_cast<int>(
+                    (currentMarkerMillis / trackDurationMillis) * imageWidth);
+
+            if (x >= 0 && x < imageWidth) {
+                // draw 2px wide for visibility
+                markerPainter.setCompositionMode(QPainter::CompositionMode_Source);
+                markerPainter.fillRect(x, 0, 2, markerHeight, minuteColor);
+                markerPainter.fillRect(x,
+                        lowerMarkerYPos,
+                        2,
+                        imageHeight - lowerMarkerYPos,
+                        minuteColor);
+                markerPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+            }
+        }
+
+        // draw hotcue markers
+        if (!cueInfos.isEmpty()) {
+            PainterScope painterScope(&markerPainter);
+            for (const auto& cueInfo : cueInfos) {
+                if (cueInfo.getType() != mixxx::CueType::HotCue) {
+                    continue;
+                }
+
+                auto positionMillis = cueInfo.getStartPositionMillis();
+                if (!positionMillis.has_value()) {
+                    continue;
+                }
+
+                // allow negative positions (preroll)
+                if (*positionMillis > trackDurationMillis) {
+                    continue;
+                }
+
+                const int x = static_cast<int>(
+                        (*positionMillis / trackDurationMillis) * imageWidth);
+
+                if (x < 0 || x >= imageWidth) {
+                    continue;
+                }
+
+                // use same rendering style as deck overview:
+                // contrasting border line + bright fill line
+                auto color = cueInfo.getColor();
+                if (!color.has_value()) {
+                    continue;
+                }
+
+                QColor fillColor = QColor::fromRgb(*color).lighter(110);
+                QColor borderColor = Color::chooseContrastColor(
+                        QColor::fromRgb(*color), 120);
+
+                // draw border/shadow line (1px wide, offset by -1)
+                markerPainter.setPen(borderColor);
+                markerPainter.drawLine(x - 1, 0, x - 1, imageHeight);
+
+                // draw main bright marker line (1px wide)
+                markerPainter.setPen(fillColor);
+                markerPainter.drawLine(x, 0, x, imageHeight);
+            }
+        }
+    }
+
     return normImage;
 }
 

src/waveform/renderers/waveformoverviewrenderer.h

@@ -2,19 +2,25 @@
 
 #include <QColor>
 
+#include "track/cueinfo.h"
 #include "waveform/overviewtype.h"
 #include "waveform/waveform.h"
 
 class QPainter;
 class WaveformSignalColors;
 
 namespace waveformOverviewRenderer {
+
+// MARK: MAIN RENDER FUNCTION
+
 /// This returns the normalized fullsize image
 /// for the library's overview column.
 QImage render(ConstWaveformPointer pWaveform,
         mixxx::OverviewType type,
         const WaveformSignalColors& signalColors,
-        bool mono = false);
+        bool mono = false,
+        const QList<mixxx::CueInfo>& cueInfos = QList<mixxx::CueInfo>(),
+        double trackDurationMillis = 0.0);
 
 /// These paint methods return the fullsize image
 /// They allow "mono" rendering (mono-mixdown, bottom-aligned).