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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
|
#include <gtest/gtest.h>
#include <QStringBuilder>
#include <QFileInfo>
#include "sources/soundsourceproxy.h"
#include "library/coverartcache.h"
#include "library/coverartutils.h"
#include "test/librarytest.h"
namespace {
const QDir kTestDir(QDir::current().absoluteFilePath("src/test/id3-test-data"));
const QString kReferencePNGLocationTest(kTestDir.absoluteFilePath("reference_cover.png"));
const QString kReferenceJPGLocationTest(kTestDir.absoluteFilePath("cover_test.jpg"));
bool isSupportedFileExtension(const QString& fileExtension) {
return 0 < SoundSourceProxy::getSupportedFileExtensions().count(fileExtension);
}
void extractEmbeddedCover(
const QString& trackLocation,
const SecurityTokenPointer& pToken,
const QImage& expectedImage) {
const QImage actualImage(
CoverArtUtils::extractEmbeddedCover(trackLocation, pToken));
ASSERT_FALSE(actualImage.isNull());
EXPECT_EQ(expectedImage, actualImage);
}
} // anonymous namespace
// first inherit from MixxxTest to construct a QApplication to be able to
// construct the default QPixmap in CoverArtCache
class CoverArtUtilTest : public LibraryTest, public CoverArtCache {
protected:
void SetUp() override {
}
void TearDown() override {
// make sure we clean up the db
QSqlQuery query(dbConnection());
query.prepare("DELETE FROM " % DIRECTORYDAO_TABLE);
ASSERT_TRUE(query.exec());
query.prepare("DELETE FROM library");
ASSERT_TRUE(query.exec());
query.prepare("DELETE FROM track_locations");
ASSERT_TRUE(query.exec());
}
};
TEST_F(CoverArtUtilTest, extractEmbeddedCover) {
QImage cover;
QImage referencePNGImage = QImage(kReferencePNGLocationTest);
QImage referenceJPGImage = QImage(kReferenceJPGLocationTest);
// We never need to acquire security tokens for tests since we don't run
// them in a sandboxed environment.
SecurityTokenPointer pToken;
if (isSupportedFileExtension("aiff")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.aiff"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("flac")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.flac"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("m4a")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.m4a"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("mp3")) {
// PNG
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test-png.mp3"), pToken, referencePNGImage);
// JPEG
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test-jpg.mp3"), pToken, referenceJPGImage);
}
if (isSupportedFileExtension("ogg")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.ogg"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("opus")) {
// opus
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.opus"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("wav")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.wav"), pToken, referencePNGImage);
}
if (isSupportedFileExtension("wv")) {
extractEmbeddedCover(
kTestDir.absoluteFilePath("cover-test.wv"), pToken, referencePNGImage);
}
}
TEST_F(CoverArtUtilTest, searchImage) {
// creating a temp track directory
QString trackdir(QDir::tempPath() % "/TrackDir");
ASSERT_FALSE(QDir().exists(trackdir)); // it must start empty
ASSERT_TRUE(QDir().mkpath(trackdir));
const QString kTrackLocationTest(kTestDir.absoluteFilePath("cover-test-png.mp3"));
TrackPointer pTrack(Track::newTemporary(kTrackLocationTest));
SoundSourceProxy(pTrack).loadTrackMetadata();
QLinkedList<QFileInfo> covers;
CoverInfo res;
// looking for cover in an empty directory
res = CoverArtUtils::selectCoverArtForTrack(*pTrack, covers);
CoverInfo expected1;
expected1.source = CoverInfo::GUESSED;
expected1.trackLocation = pTrack->getLocation();
EXPECT_EQ(expected1, res);
// Looking for a track with embedded cover.
pTrack = TrackPointer(Track::newTemporary(kTrackLocationTest));
SoundSourceProxy(pTrack).loadTrackMetadataAndCoverArt();
CoverInfo result = pTrack->getCoverInfo();
EXPECT_EQ(result.type, CoverInfo::METADATA);
EXPECT_EQ(result.source, CoverInfo::GUESSED);
EXPECT_EQ(result.coverLocation, QString());
EXPECT_NE(result.hash, CoverInfoRelative().hash);
const char* format("jpg");
const QString qFormat(format);
// Since we already parsed this image from the metadata in
// kTrackLocationTest, hang on to it since we use it as a template for
// stuff below.
result.trackLocation = kTrackLocationTest;
const QImage img = CoverArtUtils::loadCover(result);
EXPECT_EQ(img.isNull(), false);
QString trackBaseName = "cover-test";
QString trackAlbum = "album_name";
// Search Strategy
// 0. If we have just one file, we will get it.
// 1. %track-file-base%.jpg in the track directory for %track-file-base%.mp3
// 2. %album%.jpg
// 3. cover.jpg
// 4. front.jpg
// 5. album.jpg
// 6. folder.jpg
// 7. if just one file exists take that otherwise none.
// All the following expect the same image/hash to be selected.
CoverInfoRelative expected2;
expected2.hash = CoverInfoRelative().hash;
// All the following expect FILE and GUESSED.
expected2.type = CoverInfo::FILE;
expected2.source = CoverInfo::GUESSED;
// 0. saving just one cover in our temp track dir
QString cLoc_foo = QString(trackdir % "/" % "foo." % qFormat);
EXPECT_TRUE(img.save(cLoc_foo, format));
// looking for cover in an directory with one image will select that one.
expected2.coverLocation = "foo.jpg";
expected2.hash = CoverArtUtils::calculateHash(QImage(cLoc_foo));
covers << QFileInfo(cLoc_foo);
CoverInfoRelative res2 = CoverArtUtils::selectCoverArtForTrack(
trackBaseName, trackAlbum, covers);
EXPECT_EQ(expected2, res2);
QFile::remove(cLoc_foo);
QStringList extraCovers;
// adding some extra images (bigger) just to populate the track dir.
QString cLoc_big1 = QString(trackdir % "/" % "big1." % qFormat);
EXPECT_TRUE(img.scaled(1000,1000).save(cLoc_big1, format));
extraCovers << cLoc_big1;
QString cLoc_big2 = QString(trackdir % "/" % "big2." % qFormat);
EXPECT_TRUE(img.scaled(900,900).save(cLoc_big2, format));
extraCovers << cLoc_big2;
QString cLoc_big3 = QString(trackdir % "/" % "big3." % qFormat);
EXPECT_TRUE(img.scaled(800,800).save(cLoc_big3, format));
extraCovers << cLoc_big3;
// saving more covers using the preferred names in the right order
QLinkedList<QFileInfo> prefCovers;
// 1. track_filename.jpg
QString cLoc_filename = QString(trackdir % "/cover-test." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_filename, format));
prefCovers << QFileInfo(cLoc_filename);
// 2. album_name.jpg
QString cLoc_albumName = QString(trackdir % "/album_name." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_albumName, format));
prefCovers << QFileInfo(cLoc_albumName);
// 3. cover.jpg
QString cLoc_cover = QString(trackdir % "/" % "cover." % qFormat);
EXPECT_TRUE(img.scaled(400,400).save(cLoc_cover, format));
prefCovers << QFileInfo(cLoc_cover);
// 4. front.jpg
QString cLoc_front = QString(trackdir % "/" % "front." % qFormat);
EXPECT_TRUE(img.scaled(300,300).save(cLoc_front, format));
prefCovers << QFileInfo(cLoc_front);
// 5. album.jpg
QString cLoc_album = QString(trackdir % "/" % "album." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_album, format));
prefCovers << QFileInfo(cLoc_album);
// 6. folder.jpg
QString cLoc_folder = QString(trackdir % "/" % "folder." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_folder, format));
prefCovers << QFileInfo(cLoc_folder);
// 8. other1.jpg
QString cLoc_other1 = QString(trackdir % "/" % "other1." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other1, format));
prefCovers << QFileInfo(cLoc_other1);
// 7. other2.jpg
QString cLoc_other2 = QString(trackdir % "/" % "other2." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other2, format));
prefCovers <<
|