Merge lp:~jamesh/mediascanner2/folder-coverart into lp:mediascanner2

[James Henstridge]

If a folder contains an image file named {cover,album,albumart,.folder,folder}.{jpeg,jpg,png} use it as album art for songs in preference to online art if the songs do not have embedded art.

Add folder based cover art detection to the MediaFile::getArtUri() method, using a small cache to reduce work when requesting art for multiple files from an album.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:320
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~jamesh/mediascanner2/folder-coverart/+merge/278099/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/199/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-amd64-ci/36
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-armhf-ci/36
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-armhf-ci/36/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-i386-ci/36
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/11
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/11/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-i386-ci/11

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mediascanner2-ci/199/rebuild

review: Needs Fixing (continuous-integration)

[lp:~jamesh/mediascanner2/folder-coverart]

321. By James Henstridge on 2015-11-20

Remove unneeded #define.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:321
http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/200/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-amd64-ci/37
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-armhf-ci/37/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-i386-ci/37
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/12/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-i386-ci/12

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mediascanner2-ci/200/rebuild

review: Needs Fixing (continuous-integration)

[lp:~jamesh/mediascanner2/folder-coverart]

322. By James Henstridge on 2015-11-23

Add new constructor for album, explicitly passing the has_thumbnail boolean.

323. By James Henstridge on 2015-11-23

Add Album::getHasThumbnail() for use by dbus code, and make MediaStore
pass in has_thumbnail to Album.

324. By James Henstridge on 2015-11-23

Add folder artwork support to Album class.

325. By James Henstridge on 2015-11-23

Bump version number to account for API additions.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:325
http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/201/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-amd64-ci/38
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-armhf-ci/38
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-armhf-ci/38/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-vivid-i386-ci/38
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-amd64-ci/13
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/13
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-armhf-ci/13/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-wily-i386-ci/13

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mediascanner2-ci/201/rebuild

review: Approve (continuous-integration)

[Michi Henning (michihenning)]

Looks good! I tested on the phone and, after dropping a folder.jpg file into a dir with songs without artwork, the image was used by the music app.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-11-07 09:13:53 +0000
+++ CMakeLists.txt	2015-11-23 03:14:55 +0000
@@ -1,7 +1,7 @@
 project(mediascanner2 CXX C)
 cmake_minimum_required(VERSION 2.8.9)
 
-set(MEDIASCANNER_VERSION "0.108")
+set(MEDIASCANNER_VERSION "0.109")
 
 execute_process(
   COMMAND /bin/sh ${CMAKE_CURRENT_SOURCE_DIR}/get-soversion.sh
 
=== modified file 'debian/changelog'
--- debian/changelog	2015-11-09 01:56:39 +0000
+++ debian/changelog	2015-11-23 03:14:55 +0000
@@ -1,3 +1,12 @@
+mediascanner2 (0.109-0ubuntu1) UNRELEASED; urgency=medium
+
+  * If a folder contains an image file named
+    {cover,album,albumart,.folder,folder}.{jpeg,jpg,png} use it as album
+    art for songs in preference to online art if the songs do not have
+    embedded art. (LP: #1372000)
+
+ -- James Henstridge <[e-mail]>  Mon, 23 Nov 2015 11:12:59 +0800
+
 mediascanner2 (0.108+16.04.20151109-0ubuntu1) xenial; urgency=medium
 
   * Move the metadata extractor to a separate process to isolate bugs in
 
=== modified file 'debian/libmediascanner-2.0-3.symbols'
--- debian/libmediascanner-2.0-3.symbols	2015-09-21 10:56:50 +0000
+++ debian/libmediascanner-2.0-3.symbols	2015-11-23 03:14:55 +0000
@@ -5,11 +5,13 @@
  (c++)"mediascanner::Album::Album(mediascanner::Album const&)@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::Album(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::Album(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.105+14.10.20140903
+ (c++)"mediascanner::Album::Album(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, bool)@Base" 0replaceme
  (c++)"mediascanner::Album::getArtFile() const@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::getArtist() const@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::getArtUri() const@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::getDate() const@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::getGenre() const@Base" 0.105+14.10.20140903
+ (c++)"mediascanner::Album::getHasThumbnail() const@Base" 0replaceme
  (c++)"mediascanner::Album::getTitle() const@Base" 0.101+14.10.20140613
  (c++)"mediascanner::Album::operator=(mediascanner::Album&&)@Base" 0.105+14.10.20140903
  (c++)"mediascanner::Album::operator=(mediascanner::Album const&)@Base" 0.105+14.10.20140903
 
=== modified file 'debian/libmediascanner-2.0-4.shlibs'
--- debian/libmediascanner-2.0-4.shlibs	2015-09-21 10:20:38 +0000
+++ debian/libmediascanner-2.0-4.shlibs	2015-11-23 03:14:55 +0000
@@ -1,1 +1,1 @@
-libmediascanner-2.0 4 libmediascanner-2.0-4 (>= 0.107)
+libmediascanner-2.0 4 libmediascanner-2.0-4 (>= 0.109)
 
=== modified file 'src/mediascanner/Album.cc'
--- src/mediascanner/Album.cc	2014-09-03 07:00:02 +0000
+++ src/mediascanner/Album.cc	2015-11-23 03:14:55 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "Album.hh"
+#include "internal/FolderArtCache.hh"
 #include "internal/utils.hh"
 
 using namespace std;
@@ -30,13 +31,14 @@
     string date;
     string genre;
     string filename;
+    bool has_thumbnail;
 
     Private() {}
     Private(const string &title, const string &artist,
             const string &date, const string &genre,
-            const string &filename)
+            const string &filename, bool has_thumbnail)
         : title(title), artist(artist), date(date), genre(genre),
-          filename(filename) {}
+          filename(filename), has_thumbnail(has_thumbnail) {}
     Private(const Private &other) {
         *this = other;
     }
@@ -46,13 +48,19 @@
 }
 
 Album::Album(const std::string &title, const std::string &artist)
-    : Album(title, artist, "", "", "") {
+    : Album(title, artist, "", "", "", false) {
 }
 
 Album::Album(const std::string &title, const std::string &artist,
              const std::string &date, const std::string &genre,
              const std::string &filename)
-    : p(new Private(title, artist, date, genre, filename)) {
+    : Album(title, artist, date, genre, filename, !filename.empty()) {
+}
+
+Album::Album(const std::string &title, const std::string &artist,
+             const std::string &date, const std::string &genre,
+             const std::string &filename, bool has_thumbnail)
+    : p(new Private(title, artist, date, genre, filename, has_thumbnail)) {
 }
 
 Album::Album(const Album &other) : p(new Private(*other.p)) {
@@ -100,11 +108,19 @@
     return p->filename;
 }
 
+bool Album::getHasThumbnail() const noexcept {
+    return p->has_thumbnail;
+}
+
 std::string Album::getArtUri() const {
-    if (p->filename.empty()) {
+    if (p->has_thumbnail) {
+        return make_thumbnail_uri(getUri(p->filename));
+    } else {
+        auto standalone = FolderArtCache::get().get_art_for_file(p->filename);
+        if (!standalone.empty()) {
+            return make_thumbnail_uri(getUri(standalone));
+        }
         return make_album_art_uri(p->artist, p->title);
-    } else {
-        return make_thumbnail_uri(getUri(p->filename));
     }
 }
 
@@ -113,7 +129,8 @@
         p->artist == other.p->artist &&
         p->date == other.p->date &&
         p->genre == other.p->genre &&
-        p->filename == other.p->filename;
+        p->filename == other.p->filename &&
+        p->has_thumbnail == other.p->has_thumbnail;
 }
 
 bool Album::operator!=(const Album &other) const {
 
=== modified file 'src/mediascanner/Album.hh'
--- src/mediascanner/Album.hh	2014-09-03 07:00:02 +0000
+++ src/mediascanner/Album.hh	2015-11-23 03:14:55 +0000
@@ -32,6 +32,9 @@
     Album(const std::string &title, const std::string &artist,
           const std::string &date, const std::string &genre,
           const std::string &filename);
+    Album(const std::string &title, const std::string &artist,
+          const std::string &date, const std::string &genre,
+          const std::string &filename, bool has_thumbnail);
     Album(const Album &other);
     Album(Album &&other);
     ~Album();
@@ -44,6 +47,7 @@
     const std::string& getDate() const noexcept;
     const std::string& getGenre() const noexcept;
     const std::string& getArtFile() const noexcept;
+    bool getHasThumbnail() const noexcept;
     std::string getArtUri() const;
     bool operator==(const Album &other) const;
     bool operator!=(const Album &other) const;
 
=== modified file 'src/mediascanner/CMakeLists.txt'
--- src/mediascanner/CMakeLists.txt	2015-07-14 08:59:01 +0000
+++ src/mediascanner/CMakeLists.txt	2015-11-23 03:14:55 +0000
@@ -6,6 +6,7 @@
   Album.cc
   MediaStore.cc
   MediaStoreBase.cc
+  FolderArtCache.cc
   utils.cc
   mozilla/fts3_porter.c
   mozilla/Normalize.c
 
=== added file 'src/mediascanner/FolderArtCache.cc'
--- src/mediascanner/FolderArtCache.cc	1970-01-01 00:00:00 +0000
+++ src/mediascanner/FolderArtCache.cc	2015-11-23 03:14:55 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "internal/FolderArtCache.hh"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <dirent.h>
+#include <memory>
+#include <stdexcept>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+using namespace std;
+
+namespace {
+
+const int CACHE_SIZE = 50;
+
+string detect_albumart(string directory) {
+    static const array<const char*, 5> art_basenames = {
+        "cover",
+        "album",
+        "albumart",
+        ".folder",
+        "folder",
+    };
+    static const array<const char*, 3> art_extensions = {
+        "jpeg",
+        "jpg",
+        "png",
+    };
+    if (!directory.empty() && directory[directory.size()-1] != '/') {
+        directory += "/";
+    }
+    unique_ptr<DIR, decltype(&closedir)> dir(
+        opendir(directory.c_str()), &closedir);
+    if (!dir) {
+        return "";
+    }
+
+    const int dirent_size = sizeof(dirent) + fpathconf(dirfd(dir.get()), _PC_NAME_MAX) + 1;
+    unique_ptr<struct dirent, decltype(&free)> entry(
+        reinterpret_cast<struct dirent*>(malloc(dirent_size)), &free);
+
+    string detected;
+    int best_score = 0;
+    struct dirent *de = nullptr;
+    while (readdir_r(dir.get(), entry.get(), &de) == 0 && de) {
+        const string filename(de->d_name);
+        auto dot = filename.rfind('.');
+        // Ignore files with no extension
+        if (dot == string::npos) {
+            continue;
+        }
+        auto basename = filename.substr(0, dot);
+        auto extension = filename.substr(dot+1);
+
+        // Does the file name match one of the required names when
+        // converted to lower case?
+        transform(basename.begin(), basename.end(),
+                  basename.begin(), ::tolower);
+        transform(extension.begin(), extension.end(),
+                  extension.begin(), ::tolower);
+        auto base_pos = find(art_basenames.begin(), art_basenames.end(), basename);
+        if (base_pos == art_basenames.end()) {
+            continue;
+        }
+        auto ext_pos = find(art_extensions.begin(), art_extensions.end(), extension);
+        if (ext_pos == art_extensions.end()) {
+            continue;
+        }
+
+        int score = (base_pos - art_basenames.begin()) * art_basenames.size() +
+            (ext_pos - art_extensions.begin());
+        if (detected.empty() || score < best_score) {
+            detected = filename;
+            best_score = score;
+        }
+    }
+    if (detected.empty()) {
+        return detected;
+    }
+    return directory + detected;
+}
+
+}
+
+namespace mediascanner {
+
+FolderArtCache::FolderArtCache() = default;
+FolderArtCache::~FolderArtCache() = default;
+
+// Get a singleton instance of the cache
+FolderArtCache& FolderArtCache::get() {
+    static FolderArtCache cache;
+    return cache;
+}
+
+string FolderArtCache::get_art_for_directory(const string &directory) {
+    struct stat s;
+    if (lstat(directory.c_str(), &s) < 0) {
+        return "";
+    }
+    if (!S_ISDIR(s.st_mode)) {
+        return "";
+    }
+    FolderArtInfo info;
+    bool update = false;
+    try {
+        info = cache_.at(directory);
+    } catch (const out_of_range &) {
+        // Fall back to checking the previous iteration of the cache
+        try {
+            info = old_cache_.at(directory);
+            update = true;
+        } catch (const out_of_range &) {
+        }
+    }
+
+    if (info.dir_mtime.tv_sec != s.st_mtim.tv_sec ||
+        info.dir_mtime.tv_nsec != s.st_mtim.tv_nsec) {
+        info.art = detect_albumart(directory);
+        info.dir_mtime = s.st_mtim;
+        update = true;
+    }
+
+    if (update) {
+        cache_[directory] = info;
+        // Start new cache generation if we've exceeded the size.
+        if (cache_.size() > CACHE_SIZE) {
+            old_cache_ = move(cache_);
+            cache_.clear();
+        }
+    }
+    return info.art;
+}
+
+string FolderArtCache::get_art_for_file(const string &filename) {
+    auto slash = filename.rfind('/');
+    if (slash == string::npos) {
+        return "";
+    }
+    auto directory = filename.substr(0, slash + 1);
+    return get_art_for_directory(directory);
+}
+
+}
 
=== modified file 'src/mediascanner/MediaFile.cc'
--- src/mediascanner/MediaFile.cc	2015-07-07 04:36:02 +0000
+++ src/mediascanner/MediaFile.cc	2015-11-23 03:14:55 +0000
@@ -20,6 +20,7 @@
 #include "MediaFile.hh"
 #include "MediaFileBuilder.hh"
 #include "internal/MediaFilePrivate.hh"
+#include "internal/FolderArtCache.hh"
 #include "internal/utils.hh"
 #include <stdexcept>
 
@@ -155,12 +156,17 @@
 
 std::string MediaFile::getArtUri() const {
     switch (p->type) {
-    case AudioMedia:
+    case AudioMedia: {
         if (p->has_thumbnail) {
             return make_thumbnail_uri(getUri());
-        } else {
-            return make_album_art_uri(getAuthor(), getAlbum());
-        }
+        }
+        auto standalone = FolderArtCache::get().get_art_for_file(p->filename);
+        if(!standalone.empty()) {
+            return make_thumbnail_uri(mediascanner::getUri(standalone));
+        }
+        return make_album_art_uri(getAuthor(), getAlbum());
+    }
+
     default:
         return make_thumbnail_uri(getUri());
     }
 
=== modified file 'src/mediascanner/MediaStore.cc'
--- src/mediascanner/MediaStore.cc	2015-10-07 06:49:12 +0000
+++ src/mediascanner/MediaStore.cc	2015-11-23 03:14:55 +0000
@@ -604,7 +604,7 @@
     const string genre = query.getText(3);
     const string filename = query.getText(4);
     const bool has_thumbnail = query.getInt(5);
-    return Album(album, album_artist, date, genre, has_thumbnail ? filename : "");
+    return Album(album, album_artist, date, genre, filename, has_thumbnail);
 }
 
 static vector<Album> collect_albums(Statement &query) {
 
=== added file 'src/mediascanner/internal/FolderArtCache.hh'
--- src/mediascanner/internal/FolderArtCache.hh	1970-01-01 00:00:00 +0000
+++ src/mediascanner/internal/FolderArtCache.hh	2015-11-23 03:14:55 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef FOLDERARTCACHE_HH
+#define FOLDERARTCACHE_HH
+
+#include <cstdint>
+#include <ctime>
+#include <map>
+#include <string>
+
+namespace mediascanner {
+
+struct FolderArtInfo {
+    std::string art;
+    struct timespec dir_mtime {0, 0};
+};
+
+class FolderArtCache final {
+public:
+    FolderArtCache();
+    ~FolderArtCache();
+
+    FolderArtCache(const FolderArtCache &other) = delete;
+    FolderArtCache& operator=(const FolderArtCache &other) = delete;
+
+    // Get a singleton instance of the cache
+    static FolderArtCache& get();
+
+    std::string get_art_for_directory(const std::string &directory);
+    std::string get_art_for_file(const std::string &filename);
+private:
+    std::map<std::string, FolderArtInfo> cache_;
+    std::map<std::string, FolderArtInfo> old_cache_;
+};
+
+}
+
+#endif
 
=== modified file 'src/ms-dbus/dbus-codec.cc'
--- src/ms-dbus/dbus-codec.cc	2015-07-07 05:00:16 +0000
+++ src/ms-dbus/dbus-codec.cc	2015-11-23 03:14:55 +0000
@@ -104,14 +104,16 @@
     core::dbus::encode_argument(w, album.getDate());
     core::dbus::encode_argument(w, album.getGenre());
     core::dbus::encode_argument(w, album.getArtFile());
+    core::dbus::encode_argument(w, album.getHasThumbnail());
     out.close_structure(std::move(w));
 }
 
 void Codec<Album>::decode_argument(Message::Reader &in, Album &album) {
     auto r = in.pop_structure();
     string title, artist, date, genre, art_file;
-    r >> title >> artist >> date >> genre >> art_file;
-    album = Album(title, artist, date, genre, art_file);
+    bool has_thumbnail;
+    r >> title >> artist >> date >> genre >> art_file >> has_thumbnail;
+    album = Album(title, artist, date, genre, art_file, has_thumbnail);
 }
 
 void Codec<Filter>::encode_argument(Message::Writer &out, const Filter &filter) {
 
=== modified file 'src/ms-dbus/dbus-codec.hh'
--- src/ms-dbus/dbus-codec.hh	2015-07-07 05:00:16 +0000
+++ src/ms-dbus/dbus-codec.hh	2015-11-23 03:14:55 +0000
@@ -82,7 +82,7 @@
         return true;
     }
     static const std::string &signature() {
-        static const std::string s = "(sssss)";
+        static const std::string s = "(sssssb)";
         return s;
     }
 };
 
=== modified file 'test/test_dbus.cc'
--- test/test_dbus.cc	2015-07-07 05:00:16 +0000
+++ test/test_dbus.cc	2015-11-23 03:14:55 +0000
@@ -53,10 +53,10 @@
 }
 
 TEST_F(MediaStoreDBusTests, album_codec) {
-    mediascanner::Album album("title", "artist", "date", "genre", "art_file");
+    mediascanner::Album album("title", "artist", "date", "genre", "art_file", true);
     message->writer() << album;
 
-    EXPECT_EQ("(sssss)", message->signature());
+    EXPECT_EQ("(sssssb)", message->signature());
     EXPECT_EQ(core::dbus::helper::TypeMapper<mediascanner::Album>::signature(), message->signature());
 
     mediascanner::Album album2;
@@ -66,6 +66,7 @@
     EXPECT_EQ("date", album2.getDate());
     EXPECT_EQ("genre", album2.getGenre());
     EXPECT_EQ("art_file", album2.getArtFile());
+    EXPECT_EQ(true, album2.getHasThumbnail());
     EXPECT_EQ(album, album2);
 }
 
 
=== modified file 'test/test_mfbuilder.cc'
--- test/test_mfbuilder.cc	2015-07-07 08:21:29 +0000
+++ test/test_mfbuilder.cc	2015-11-23 03:14:55 +0000
@@ -17,26 +17,60 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include<gtest/gtest.h>
-#include"mediascanner/MediaFile.hh"
-#include"mediascanner/MediaFileBuilder.hh"
-#include<stdexcept>
+#include "test_config.h"
+#include "mediascanner/Album.hh"
+#include "mediascanner/MediaFile.hh"
+#include "mediascanner/MediaFileBuilder.hh"
+
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <cstdlib>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdexcept>
+#include <thread>
+#include <vector>
 
 using namespace mediascanner;
 
 class MFBTest : public ::testing::Test {
- protected:
-  MFBTest() {
-  }
-
-  virtual ~MFBTest() {
-  }
-
-  virtual void SetUp() {
-  }
-
-  virtual void TearDown() {
-  }
+protected:
+    MFBTest() = default;
+    virtual ~MFBTest() = default;
+
+    virtual void SetUp() override {
+        tmpdir = TEST_DIR "/mfbuilder-test.XXXXXX";
+        ASSERT_NE(nullptr, mkdtemp(&tmpdir[0]));
+    }
+
+    virtual void TearDown() override {
+        if (!tmpdir.empty()) {
+            std::string cmd = "rm -rf " + tmpdir;
+            ASSERT_EQ(0, system(cmd.c_str()));
+        }
+    }
+
+    void touch(const std::string &fname, bool sleep=false) {
+        if (sleep) {
+            // Ensure time stamps change
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+        int fd = open(fname.c_str(), O_CREAT, 0600);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    void remove(const std::string &fname, bool sleep=false) {
+        if (sleep) {
+            // Ensure time stamps change
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+        ASSERT_EQ(0, unlink(fname.c_str()));
+    }
+
+    std::string tmpdir;
 };
 
 TEST_F(MFBTest, basic) {
@@ -209,6 +243,120 @@
     EXPECT_EQ("image://thumbnailer/file:///foo/bar/baz.mp4", mf.getArtUri());
 }
 
+TEST_F(MFBTest, folder_art) {
+    std::string fname = tmpdir + "/dummy.mp3";
+    MediaFile media = MediaFileBuilder(fname)
+        .setType(AudioMedia)
+        .setTitle("Title")
+        .setAuthor("Artist")
+        .setAlbum("Album");
+
+    EXPECT_EQ("image://albumart/artist=Artist&album=Album", media.getArtUri());
+    touch(tmpdir + "/folder.jpg", true);
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    remove(tmpdir + "/folder.jpg", true);
+    EXPECT_EQ("image://albumart/artist=Artist&album=Album", media.getArtUri());
+}
+
+TEST_F(MFBTest, folder_art_case_insensitive) {
+   std::string fname = tmpdir + "/dummy.mp3";
+    MediaFile media = MediaFileBuilder(fname)
+        .setType(AudioMedia)
+        .setTitle("Title")
+        .setAuthor("Artist")
+        .setAlbum("Album");
+
+    touch(tmpdir + "/FOLDER.JPG");
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/FOLDER.JPG")) << media.getArtUri();
+}
+
+TEST_F(MFBTest, folder_art_precedence) {
+    std::string fname = tmpdir + "/dummy.mp3";
+    MediaFile media = MediaFileBuilder(fname)
+        .setType(AudioMedia)
+        .setTitle("Title")
+        .setAuthor("Artist")
+        .setAlbum("Album");
+
+    touch(tmpdir + "/cover.jpg");
+    touch(tmpdir + "/album.jpg");
+    touch(tmpdir + "/albumart.jpg");
+    touch(tmpdir + "/.folder.jpg");
+    touch(tmpdir + "/folder.jpeg");
+    touch(tmpdir + "/folder.jpg");
+    touch(tmpdir + "/folder.png");
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/cover.jpg")) << media.getArtUri();
+    remove(tmpdir + "/cover.jpg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/album.jpg")) << media.getArtUri();
+    remove(tmpdir + "/album.jpg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/albumart.jpg")) << media.getArtUri();
+    remove(tmpdir + "/albumart.jpg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/.folder.jpg")) << media.getArtUri();
+    remove(tmpdir + "/.folder.jpg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpeg")) << media.getArtUri();
+    remove(tmpdir + "/folder.jpeg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    remove(tmpdir + "/folder.jpg", true);
+
+    EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.png")) << media.getArtUri();
+}
+
+TEST_F(MFBTest, folder_art_cache_coverage) {
+    std::vector<MediaFile> files;
+    for (int i = 0; i < 100; i++) {
+        std::string directory = tmpdir + "/" + std::to_string(i);
+        ASSERT_EQ(0, mkdir(directory.c_str(), 0700));
+        touch(directory + "/folder.jpg");
+
+        std::string fname = directory + "/dummy.mp3";
+        files.emplace_back(MediaFileBuilder(fname)
+                           .setType(AudioMedia)
+                           .setTitle("Title")
+                           .setAuthor("Artist")
+                           .setAlbum("Album"));
+    }
+
+    // Check art for a number of files smaller than the cache size twice
+    for (int i = 0; i < 10; i++) {
+        const auto &media = files[i];
+        EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    }
+    for (int i = 0; i < 10; i++) {
+        const auto &media = files[i];
+        EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    }
+
+    // Now check a larger number of files twice
+    for (const auto &media : files) {
+        EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    }
+    for (const auto &media : files) {
+        EXPECT_NE(std::string::npos, media.getArtUri().find("/folder.jpg")) << media.getArtUri();
+    }
+}
+
+TEST_F(MFBTest, album_art) {
+    std::string fname = tmpdir + "/dummy.mp3";
+
+    // File with embedded art
+    Album album("Album", "Artist", "2015-11-23", "Rock", fname, true);
+    EXPECT_NE(std::string::npos, album.getArtUri().find("/dummy.mp3")) << album.getArtUri();
+
+    // No embedded art
+    album = Album("Album", "Artist", "2015-11-23", "Rock", fname, false);
+    EXPECT_EQ("image://albumart/artist=Artist&album=Album", album.getArtUri());
+
+    // No embedded art, but folder art available
+    touch(tmpdir + "/folder.jpg", true);
+    EXPECT_NE(std::string::npos, album.getArtUri().find("/folder.jpg")) << album.getArtUri();
+}
+
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 
=== modified file 'test/test_util.cc'
--- test/test_util.cc	2014-05-09 14:04:48 +0000
+++ test/test_util.cc	2015-11-23 03:14:55 +0000
@@ -19,6 +19,9 @@
 
 #include <gtest/gtest.h>
 #include"../src/mediascanner/internal/utils.hh"
+#include"../src/mediascanner/MediaFile.hh"
+#include"../src/mediascanner/MediaFileBuilder.hh"
+
 #include "test_config.h"
 
 using namespace mediascanner;