1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#include <QPainter>
#include <algorithm>
#include "library/coverartcache.h"
#include "library/coverartdelegate.h"
#include "library/dao/trackschema.h"
#include "library/trackmodel.h"
#include "track/track.h"
#include "util/logger.h"
#include "widget/wlibrarytableview.h"
namespace {
const mixxx::Logger kLogger("BaseCoverArtDelegate");
inline TrackModel* asTrackModel(
QTableView* pTableView) {
auto* pTrackModel =
dynamic_cast<TrackModel*>(pTableView->model());
DEBUG_ASSERT(pTrackModel);
return pTrackModel;
}
} // anonymous namespace
BaseCoverArtDelegate::BaseCoverArtDelegate(QTableView* parent)
: TableItemDelegate(parent),
m_pTrackModel(asTrackModel(parent)),
m_pCache(CoverArtCache::instance()),
m_inhibitLazyLoading(false) {
if (m_pCache) {
connect(m_pCache,
&CoverArtCache::coverFound,
this,
&BaseCoverArtDelegate::slotCoverFound);
} else {
kLogger.warning()
<< "Caching of cover art is not available";
}
}
void BaseCoverArtDelegate::emitRowsChanged(
QList<int>&& rows) {
if (rows.isEmpty()) {
return;
}
// Sort in ascending order...
std::sort(rows.begin(), rows.end());
// ...and then deduplicate...
rows.erase(std::unique(rows.begin(), rows.end()), rows.end());
// ...before emitting the signal.
DEBUG_ASSERT(!rows.isEmpty());
emit rowsChanged(std::move(rows));
}
void BaseCoverArtDelegate::slotInhibitLazyLoading(
bool inhibitLazyLoading) {
m_inhibitLazyLoading = inhibitLazyLoading;
if (m_inhibitLazyLoading || m_cacheMissRows.isEmpty()) {
return;
}
// If we can request non-cache covers now, request updates
// for all rows that were cache misses since the last time.
auto staleRows = m_cacheMissRows;
// Reset the member variable before mutating the aggregated
// rows list (-> implicit sharing) and emitting a signal that
// in turn may trigger new signals for BaseCoverArtDelegate!
m_cacheMissRows = QList<int>();
emitRowsChanged(std::move(staleRows));
}
void BaseCoverArtDelegate::slotCoverFound(
const QObject* pRequestor,
const CoverInfo& coverInfo,
const QPixmap& pixmap,
mixxx::cache_key_t requestedImageHash,
bool coverInfoUpdated) {
Q_UNUSED(pixmap);
if (pRequestor != this) {
return;
}
if (coverInfoUpdated) {
const auto pTrack =
loadTrackByLocation(coverInfo.trackLocation);
if (pTrack) {
kLogger.info()
<< "Updating cover info of track"
<< coverInfo.trackLocation;
pTrack->setCoverInfo(coverInfo);
}
}
QList<int> refreshRows = m_pendingCacheRows.values(requestedImageHash);
m_pendingCacheRows.remove(requestedImageHash);
emitRowsChanged(std::move(refreshRows));
}
TrackPointer BaseCoverArtDelegate::loadTrackByLocation(
const QString& trackLocation) const {
VERIFY_OR_DEBUG_ASSERT(m_pTrackModel) {
return TrackPointer();
}
return m_pTrackModel->getTrackByRef(
TrackRef::fromFileInfo(trackLocation));
}
void BaseCoverArtDelegate::paintItem(
QPainter* painter,
const QStyleOptionViewItem& option,
const QModelIndex& index) const {
paintItemBackground(painter, option, index);
CoverInfo coverInfo = coverInfoForIndex(index);
if (CoverImageUtils::isValidHash(coverInfo.hash)) {
VERIFY_OR_DEBUG_ASSERT(m_pCache) {
return;
}
const double scaleFactor =
getDevicePixelRatioF(static_cast<QWidget*>(parent()));
QPixmap pixmap = m_pCache->tryLoadCover(
this,
coverInfo,
option.rect.width() * scaleFactor,
m_inhibitLazyLoading ? CoverArtCache::Loading::CachedOnly : CoverArtCache::Loading::Default);
if (pixmap.isNull()) {
// Cache miss
if (m_inhibitLazyLoading) {
// We are requesting cache-only covers and got a cache
// miss. Record this row so that when we switch to requesting
// non-cache we can request an update.
m_cacheMissRows.append(index.row());
} else {
// If we asked for a non-cache image and got a null pixmap,
// then our request was queued.
m_pendingCacheRows.insert(coverInfo.hash, index.row());
}
} else {
// Cache hit
pixmap.setDevicePixelRatio(scaleFactor);
painter->drawPixmap(option.rect.topLeft(), pixmap);
return;
}
}
}
|
