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
144
145
146
147
148
149
150
151
152
|
#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 requestedCacheKey,
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(requestedCacheKey);
m_pendingCacheRows.remove(requestedCacheKey);
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 (coverInfo.hasImage()) {
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.cacheKey(), index.row());
}
} else {
// Cache hit
pixmap.setDevicePixelRatio(scaleFactor);
painter->drawPixmap(option.rect.topLeft(), pixmap);
return;
}
}
// Fallback: Use the (background) color as a placeholder:
// - while the cover art is loaded asynchronously in the background
// - if the audio file with embedded cover art is missing
// - if the external image file with custom cover art is missing
// Since the background color is calculated from the cover art image
// it is optional and may not always be available
if (coverInfo.color) {
painter->fillRect(option.rect, mixxx::RgbColor::toQColor(coverInfo.color));
}
}
|
