Merge lp:~jpakkane/thumbnailer/fix-1319698 into lp:thumbnailer

[Jussi Pakkanen]

SRU backport of patch to make file names with chinese characters work.

SRU backport of patch to make file names with chinese characters work.

[lp:~jpakkane/thumbnailer/fix-1319698]

15. By Jussi Pakkanen on 2015-02-05

Added bzr-builddeb conf file to make this branch citrain ready.

Unmerged revisions

15. By Jussi Pakkanen on 2015-02-05

Added bzr-builddeb conf file to make this branch citrain ready.

14. By Jussi Pakkanen on 2015-02-04

Backport patch for filenames with chinese characters.

13. By PS Jenkins bot on 2014-04-01

[ Michal Hruby ]
Provide virtual thumbnailer package.

12. By PS Jenkins bot on 2014-03-31

[ Jussi Pakkanen ]
New minor release.

11. By PS Jenkins bot on 2014-03-27

[ Jussi Pakkanen ]
Obey the TMPDIR. (LP: #1296987)

10. By PS Jenkins bot on 2014-03-19

[ Jussi Pakkanen ]
Prevent crash if exif entry is null. (LP: #1294274)

9. By PS Jenkins bot on 2014-03-07

[ Jussi Pakkanen ]
* Added visibility info to prevent accidental ABI breakages.
* Reorient images manually to work around a bug in GdkPixbuf.

8. By PS Jenkins bot on 2014-03-04

[ CI bot ]
* Resync trunk

[ Ugo Riboni ]
* Add a new nonstandard thumbnail size (360) needed by gallery-app To
  test from QML you will need this MR as well:
  https://code.launchpad.net/~amanzi-team/ubuntu-ui-toolkit/ubuntu-ui-
  toolkit-xlarge-thumbnails/+merge/207500 (LP: #1221968)

[ Jussi Pakkanen ]
* Error condition checking and error messages.
* Fix image orientation.

7. By PS Jenkins bot on 2014-02-18

[ Ricardo Salveti de Araujo ]
* vs-thumb: give pipeline at least 3 seconds to preroll

[ Jussi Pakkanen ]
* Created a unique_gobj class for managing gobject based resources.
* Fix use of #includes. (LP: #1237045)
* A bunch of fixes to make the project compile on precise.
* Removed accidentally added file.
* Invalidate cached images when source has changed.

6. By PS Jenkins bot on 2013-10-11

[ Jussi Pakkanen ]
* Fix install directory of vs-thumb. (LP: #1235325)
* Wait for child process to die when killing it with SIGKILL.

[ Ubuntu daily release ]
* Automatic snapshot from revision 58

=== added file 'CMakeLists.txt'
--- CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,53 @@
+project(thumbnailer C CXX)
+cmake_minimum_required(VERSION 2.8.7)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra")
+
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag(-std=c++11 HAS_C11)
+# Precise's GCC is too old to have -std=c++11
+if(HAS_C11)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+else()
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Dfinal=")
+endif()
+
+set(SO_VERSION_MAJOR "1")
+set(SO_VERSION_MINOR "1")
+set(SO_VERSION_PATCH "0")
+
+set(SO_VERSION "${SO_VERSION_MAJOR}.${SO_VERSION_MINOR}.${SO_VERSION_PATCH}")
+
+# Increment this manually whenever breaking ABI.
+# http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html#AEN135
+set(ABI_VERSION 0)
+
+include(cmake/coverage.cmake)
+
+include(GNUInstallDirs)
+set(LIBDIR ${CMAKE_INSTALL_LIBDIR})
+set(SHARE_PRIV_DIR ${CMAKE_INSTALL_LIBDIR}/thumbnailer)
+set(SHARE_PRIV_ABS ${CMAKE_INSTALL_PREFIX}/${SHARE_PRIV_DIR})
+
+find_package(Threads REQUIRED)
+find_package(Qt5Core REQUIRED)
+include(FindPkgConfig)
+pkg_check_modules(GST_DEPS REQUIRED gstreamer-1.0 gstreamer-plugins-base-1.0 gstreamer-pbutils-1.0 gstreamer-app-1.0)
+pkg_check_modules(GIO_DEPS REQUIRED gio-2.0 gio-unix-2.0)
+pkg_check_modules(IMG_DEPS REQUIRED gdk-pixbuf-2.0 libexif)
+pkg_check_modules(SOUP_DEPS REQUIRED libsoup-2.4)
+pkg_check_modules(XML_DEPS REQUIRED libxml-2.0)
+
+include_directories(${GST_DEPS_INCLUDE_DIRS})
+include_directories(${GIO_DEPS_INCLUDE_DIRS})
+include_directories(${IMG_DEPS_INCLUDE_DIRS})
+include_directories(${SOUP_DEPS_INCLUDE_DIRS})
+include_directories(${XML_DEPS_INCLUDE_DIRS})
+include_directories(include)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
+
+enable_testing()
+add_subdirectory(src)
+add_subdirectory(plugins/Ubuntu/Thumbnailer)
+add_subdirectory(tests)
+add_subdirectory(tools)
+add_subdirectory(include)

=== renamed file 'CMakeLists.txt' => 'CMakeLists.txt.moved'
=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2015-02-04 08:57:20 +0000
@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

=== renamed file 'COPYING' => 'COPYING.moved'
=== added directory 'cmake'
=== renamed directory 'cmake' => 'cmake.moved'
=== added file 'cmake/coverage.cmake'
--- cmake/coverage.cmake	1970-01-01 00:00:00 +0000
+++ cmake/coverage.cmake	2015-02-04 08:57:20 +0000
@@ -0,0 +1,34 @@
+if (CMAKE_BUILD_TYPE MATCHES coverage)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} --coverage")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+
+  find_program(GCOVR_EXECUTABLE gcovr HINTS ${GCOVR_ROOT} "${GCOVR_ROOT}/bin")
+  if (NOT GCOVR_EXECUTABLE)
+    message(STATUS "Gcovr binary was not found, can not generate XML coverage info.")
+  else ()
+    message(STATUS "Gcovr found, can generate XML coverage info.")
+    add_custom_target (coverage-xml
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+      COMMAND "${GCOVR_EXECUTABLE}" --exclude="test.*" -x -r "${CMAKE_SOURCE_DIR}" 
+      --object-directory=${CMAKE_BINARY_DIR} -o coverage.xml)
+  endif()
+
+  find_program(LCOV_EXECUTABLE lcov HINTS ${LCOV_ROOT} "${GCOVR_ROOT}/bin")
+  find_program(GENHTML_EXECUTABLE genhtml HINTS ${GENHTML_ROOT})
+  if (NOT LCOV_EXECUTABLE)
+    message(STATUS "Lcov binary was not found, can not generate HTML coverage info.")
+  else ()
+    if(NOT GENHTML_EXECUTABLE)
+      message(STATUS "Genthml binary not found, can not generate HTML coverage info.")
+    else()
+      message(STATUS "Lcov and genhtml found, can generate HTML coverage info.")
+      add_custom_target (coverage-html
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND "${LCOV_EXECUTABLE}" --directory ${CMAKE_BINARY_DIR} --capture --output-file coverage.info --no-checksum
+        COMMAND "${GENHTML_EXECUTABLE}" --prefix ${CMAKE_BINARY_DIR} --output-directory coveragereport --title "Code Coverage" --legend --show-details coverage.info
+        )
+    endif()
+  endif()
+endif()

=== added directory 'debian'
=== renamed directory 'debian' => 'debian.moved'
=== added file 'debian/changelog'
--- debian/changelog	1970-01-01 00:00:00 +0000
+++ debian/changelog	2015-02-04 08:57:20 +0000
@@ -0,0 +1,128 @@
+thumbnailer (1.1+14.04.20140401.1-0ubuntu1) trusty; urgency=low
+
+  [ Michal Hruby ]
+  * Provide virtual thumbnailer package.
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 01 Apr 2014 22:45:34 +0000
+
+thumbnailer (1.1+14.04.20140331-0ubuntu1) trusty; urgency=medium
+
+  [ Jussi Pakkanen ]
+  * New minor release.
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 31 Mar 2014 09:08:36 +0000
+
+thumbnailer (1.0+14.04.20140327-0ubuntu1) trusty; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Obey the TMPDIR. (LP: #1296987)
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 27 Mar 2014 08:36:59 +0000
+
+thumbnailer (1.0+14.04.20140319-0ubuntu1) trusty; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Prevent crash if exif entry is null. (LP: #1294274)
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 19 Mar 2014 20:16:40 +0000
+
+thumbnailer (1.0+14.04.20140307-0ubuntu1) trusty; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Added visibility info to prevent accidental ABI breakages.
+  * Reorient images manually to work around a bug in GdkPixbuf.
+
+ -- Ubuntu daily release <[e-mail]>  Fri, 07 Mar 2014 15:41:18 +0000
+
+thumbnailer (1.0+14.04.20140304-0ubuntu1) trusty; urgency=low
+
+  [ CI bot ]
+  * Resync trunk
+
+  [ Ugo Riboni ]
+  * Add a new nonstandard thumbnail size (360) needed by gallery-app To
+    test from QML you will need this MR as well:
+    https://code.launchpad.net/~amanzi-team/ubuntu-ui-toolkit/ubuntu-ui-
+    toolkit-xlarge-thumbnails/+merge/207500 (LP: #1221968)
+
+  [ Jussi Pakkanen ]
+  * Error condition checking and error messages.
+  * Fix image orientation.
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 04 Mar 2014 10:09:12 +0000
+
+thumbnailer (1.0+14.04.20140218-0ubuntu1) trusty; urgency=low
+
+  [ Ricardo Salveti de Araujo ]
+  * vs-thumb: give pipeline at least 3 seconds to preroll
+
+  [ Jussi Pakkanen ]
+  * Created a unique_gobj class for managing gobject based resources.
+  * Fix use of #includes. (LP: #1237045)
+  * A bunch of fixes to make the project compile on precise.
+  * Removed accidentally added file.
+  * Invalidate cached images when source has changed.
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 18 Feb 2014 23:01:31 +0000
+
+thumbnailer (1.0+13.10.20131011-0ubuntu1) saucy; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Fix install directory of vs-thumb. (LP: #1235325)
+  * Wait for child process to die when killing it with SIGKILL.
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 58
+
+ -- Ubuntu daily release <[e-mail]>  Fri, 11 Oct 2013 05:41:32 +0000
+
+thumbnailer (1.0+13.10.20131008-0ubuntu1) saucy; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Fix off by one error. (LP: #1235444)
+  * Disable use of in-process GStreamer because we use 1.0, which
+    clashes with 0.10. (LP: #1235484)
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 55
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 08 Oct 2013 12:49:51 +0000
+
+thumbnailer (1.0+13.10.20131007-0ubuntu1) saucy; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Write files into cache atomically.
+  * Guard against a frozen worker process.
+  * Document the public interface.
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 52
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 07 Oct 2013 10:52:14 +0000
+
+thumbnailer (1.0+13.10.20131003-0ubuntu1) saucy; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Run gstreamer video pipelines in an external process.
+  * Get helper path from config.h.
+  * Use helper binary from build dir when running tests.
+  * Adds support for full resolution thumbnails.
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 48
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 03 Oct 2013 03:26:49 +0000
+
+thumbnailer (1.0+13.10.20131002-0ubuntu1) saucy; urgency=low
+
+  [ Jussi Pakkanen ]
+  * Initial release.
+  * Typo fix.
+
+  [ Łukasz 'sil2100' Zemczak ]
+  * Automatic snapshot from revision 41 (bootstrap)
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 43
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 02 Oct 2013 02:34:38 +0000

=== added file 'debian/compat'
--- debian/compat	1970-01-01 00:00:00 +0000
+++ debian/compat	2015-02-04 08:57:20 +0000
@@ -0,0 +1,1 @@
+9

=== added file 'debian/control'
--- debian/control	1970-01-01 00:00:00 +0000
+++ debian/control	2015-02-04 08:57:20 +0000
@@ -0,0 +1,74 @@
+Source: thumbnailer
+Section: libdevel
+Priority: optional
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Standards-Version: 3.9.4
+Build-Depends: cmake,
+               debhelper (>= 9),
+               gstreamer1.0-plugins-good,
+               libexif-dev,
+               libgdk-pixbuf2.0-dev,
+               libgstreamer1.0-dev,
+               libgstreamer-plugins-base1.0-dev,
+               libgtest-dev,
+               libsoup2.4-dev,
+               libxml2-dev,
+               qt5-default,
+               qtbase5-dev,
+               qtbase5-dev-tools,
+               qtdeclarative5-dev,
+               shared-mime-info,
+Homepage: https://launchpad.net/thumbnailer
+# if you don't have have commit access to this branch but would like to upload
+# directly to Ubuntu, don't worry: your changes will be merged back into the
+# upstream branch
+Vcs-Bzr: lp:thumbnailer
+
+Package: libthumbnailer0
+Architecture: any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends},
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: generate thumbnails from files
+ Thumbnailer is a shared library that generates
+ thumbnail images for multiple file types such
+ as video and audio files.
+
+Package: libthumbnailer-dev
+Architecture: any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends},
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         gstreamer1.0-plugins-base,
+         gstreamer1.0-plugins-good,
+         libthumbnailer0 (= ${binary:Version}),
+Description: development files for thumbnailer
+ This package contains development files
+ for the thumbnailer package.
+
+Package: thumbnailer-service
+Architecture: any
+Multi-Arch: foreign
+Pre-Depends: ${misc:Pre-Depends},
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         libthumbnailer0 (= ${binary:Version}),
+Description: D-Bus service for out of process thumbnailing
+ This package provides a D-Bus service that can provide thumbnails on
+ behalf of another process.
+
+Package: qtdeclarative5-ubuntu-thumbnailer0.1
+Architecture: any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends},
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         libthumbnailer0 (= ${binary:Version}),
+Provides: ubuntu-thumbnailer-impl,
+          ubuntu-thumbnailer-impl-0,
+Recommends: thumbnailer-service (= ${binary:Version}),
+Description: QML interface for the thumbnailer.
+ This package provides image providers that allow access to the
+ thumbnailer from Qt Quick 2 / QML applications.

=== added file 'debian/copyright'
--- debian/copyright	1970-01-01 00:00:00 +0000
+++ debian/copyright	2015-02-04 08:57:20 +0000
@@ -0,0 +1,19 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: thumbnailer
+Source: https://launchpad.net/thumbnailer
+
+Files: *
+Copyright: 2013 Canonical ltd
+License: LGPL-3
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of version 3 of the GNU Lesser General Public
+ License 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 General Public License for more details.
+ .
+ On Debian systems, the full text of the GNU Lesser General Public
+ License version 3 can be found in the file
+ `/usr/share/common-licenses/LGPL-3'

=== added file 'debian/libthumbnailer-dev.install'
--- debian/libthumbnailer-dev.install	1970-01-01 00:00:00 +0000
+++ debian/libthumbnailer-dev.install	2015-02-04 08:57:20 +0000
@@ -0,0 +1,3 @@
+usr/include/*
+usr/lib/*/lib*.so
+usr/lib/*/pkgconfig/*

=== added file 'debian/libthumbnailer0.install'
--- debian/libthumbnailer0.install	1970-01-01 00:00:00 +0000
+++ debian/libthumbnailer0.install	2015-02-04 08:57:20 +0000
@@ -0,0 +1,2 @@
+usr/lib/*/libthumb*.so.*
+usr/lib/*/thumbnailer/vs-thumb

=== added file 'debian/libthumbnailer0.symbols'
--- debian/libthumbnailer0.symbols	1970-01-01 00:00:00 +0000
+++ debian/libthumbnailer0.symbols	2015-02-04 08:57:20 +0000
@@ -0,0 +1,6 @@
+libthumbnailer.so.0 libthumbnailer0 #MINVER#
+ (c++)"Thumbnailer::get_thumbnail(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, ThumbnailSize)@Base" 1.0
+ (c++)"Thumbnailer::get_thumbnail(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, ThumbnailSize, ThumbnailPolicy)@Base" 1.0
+ (c++)"Thumbnailer::get_album_art(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, ThumbnailSize, ThumbnailPolicy)@Base" 1.0
+ (c++)"Thumbnailer::Thumbnailer()@Base" 1.0
+ (c++)"Thumbnailer::~Thumbnailer()@Base" 1.0

=== added file 'debian/qtdeclarative5-ubuntu-thumbnailer0.1.install'
--- debian/qtdeclarative5-ubuntu-thumbnailer0.1.install	1970-01-01 00:00:00 +0000
+++ debian/qtdeclarative5-ubuntu-thumbnailer0.1.install	2015-02-04 08:57:20 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/qt5/qml/Ubuntu/Thumbnailer.0.1/*

=== added file 'debian/rules'
--- debian/rules	1970-01-01 00:00:00 +0000
+++ debian/rules	2015-02-04 08:57:20 +0000
@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+# -*- makefile -*-
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+export DPKG_GENSYMBOLS_CHECK_LEVEL=4
+
+# http://ccache.samba.org/manual.html#_precompiled_headers
+export CCACHE_SLOPPINESS=time_macros
+
+%:
+	dh $@ --parallel --fail-missing

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2015-02-04 08:57:20 +0000
@@ -0,0 +1,1 @@
+1.0

=== added file 'debian/thumbnailer-service.install'
--- debian/thumbnailer-service.install	1970-01-01 00:00:00 +0000
+++ debian/thumbnailer-service.install	2015-02-04 08:57:20 +0000
@@ -0,0 +1,2 @@
+usr/lib/*/thumbnailer/thumbnailer-service
+usr/share/dbus-1/services/com.canonical.Thumbnailer.service

=== added directory 'include'
=== renamed directory 'include' => 'include.moved'
=== added file 'include/CMakeLists.txt'
--- include/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,12 @@
+add_subdirectory(internal)
+
+install(FILES thumbnailer.h DESTINATION include)
+
+# Build and install a pkg-config file
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix ${prefix}/bin)
+set(libdir ${prefix}/${LIBDIR})
+set(includedir ${prefix}/include)
+set(pkg-name "lib${COL_LIB_BASENAME}")
+configure_file(thumbnailer.pc.in thumbnailer.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/thumbnailer.pc DESTINATION ${LIBDIR}/pkgconfig)

=== added directory 'include/internal'
=== added file 'include/internal/CMakeLists.txt'
--- include/internal/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/internal/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,1 @@
+configure_file(config.h.in config.h @ONLY)

=== added file 'include/internal/audioimageextractor.h'
--- include/internal/audioimageextractor.h	1970-01-01 00:00:00 +0000
+++ include/internal/audioimageextractor.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef AUDIOIMAGEEXTRACTOR_H_
+#define AUDIOIMAGEEXTRACTOR_H_
+
+#include<string>
+
+class AudioImageExtractorPrivate;
+
+class AudioImageExtractor final {
+public:
+    AudioImageExtractor();
+    ~AudioImageExtractor();
+
+    AudioImageExtractor(const AudioImageExtractor &t) = delete;
+    AudioImageExtractor & operator=(const AudioImageExtractor &t) = delete;
+
+    bool extract(const std::string &ifname, const std::string &ofname);
+
+private:
+    AudioImageExtractorPrivate *p;
+};
+
+
+#endif

=== added file 'include/internal/config.h.in'
--- include/internal/config.h.in	1970-01-01 00:00:00 +0000
+++ include/internal/config.h.in	2015-02-04 08:57:20 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef THUMBNAILER_CONFIG_H
+#define THUMBNAILER_CONFIG_H
+
+#cmakedefine SHARE_PRIV_ABS "@SHARE_PRIV_ABS@"
+
+#endif

=== added file 'include/internal/gobj_memory.h'
--- include/internal/gobj_memory.h	1970-01-01 00:00:00 +0000
+++ include/internal/gobj_memory.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef GOBJ_MEMORY_H_
+#define GOBJ_MEMORY_H_
+
+#include<glib-object.h>
+#include<stdexcept>
+
+/**
+ * This class is meant for automatically managing the lifetime of C objects derived
+ * from gobject. Its API perfectly mirrors the API of unique_ptr except that you
+ * can't define your own deleter function as it is always g_object_unref.
+ *
+ * API/ABI stability is not guaranteed. If you need to pass the object across an ABI
+ * boundary, pass the plain gobject.
+ *
+ * This is how you would use unique_gobj 99% of the time:
+ *
+ * unique_gobj<GSomeType> o(g_some_type_new(...));
+ *
+ * More specifically, the object will decrement the gobject reference count
+ * of the object it points to when it goes out of scope. It will never increment it.
+ * Thus you should only assign to it when already holding a reference. unique_gobj
+ * will then take ownership of that particular reference.
+ *
+ * Floating gobjects can not be put in this container as they are meant to be put
+ * into native gobject aware containers immediately upon construction. Trying to insert
+ * a floating gobject into a unique_gobj will throw an invalid_argument exception. To
+ * prevent accidental memory leaks, the floating gobject is unreffed in this case.
+ */
+template<typename T>
+class unique_gobj final {
+private:
+  T* u;
+
+  void validate_float(T *t) {
+      if(t != nullptr && g_object_is_floating(G_OBJECT(t))) {
+          throw std::invalid_argument("Tried to add a floating gobject into a unique_gobj.");
+      }
+  }
+
+public:
+  typedef T element_type;
+  typedef T* pointer;
+  typedef decltype(g_object_unref) deleter_type;
+
+  constexpr unique_gobj() noexcept : u(nullptr) {}
+  explicit unique_gobj(T *t) : u(t) {
+      // What should we do if validate throws? Unreffing unknown objs
+      // is dodgy but not unreffing runs the risk of
+      // memory leaks. Currently unrefs as u is destroyed
+      // when this exception is thrown.
+      validate_float(t);
+  }
+  constexpr unique_gobj(std::nullptr_t) noexcept : u(nullptr) {};
+  unique_gobj(unique_gobj &&o) noexcept { u = o.u; o.u = nullptr; }
+  unique_gobj(const unique_gobj &o) = delete;
+  unique_gobj& operator=(unique_gobj &o) = delete;
+  ~unique_gobj() { reset(); }
+
+  deleter_type& get_deleter() noexcept { return g_object_unref; }
+  const deleter_type& get_deleter() const noexcept { return g_object_unref; }
+
+  void swap(unique_gobj<T> &o) noexcept { T*tmp = u; u = o.u; o.u = tmp; }
+  void reset(pointer p = pointer()) {
+      if(u!=nullptr) {
+          g_object_unref(G_OBJECT(u));
+          u = nullptr;
+      }
+      // Same throw dilemma as in pointer constructor.
+      u = p;
+      validate_float(p);
+  }
+
+  T* release() noexcept { T* r = u; u=nullptr; return r; }
+  T* get() const noexcept { return u; }
+
+  T& operator*() const { return *u; }
+  T* operator->() const noexcept { return u; }
+  explicit operator bool() const noexcept { return u != nullptr; }
+
+  unique_gobj& operator=(unique_gobj &&o) noexcept { reset(); u = o.u; o.u = nullptr; return *this; }
+  unique_gobj& operator=(std::nullptr_t) noexcept { reset(); return *this; }
+  bool operator==(const unique_gobj<T> &o) const noexcept { return u == o.u; }
+  bool operator!=(const unique_gobj<T> &o) const noexcept { return u != o.u; }
+  bool operator<(const unique_gobj<T> &o) const noexcept { return u < o.u; }
+  bool operator<=(const unique_gobj<T> &o) const noexcept { return u <= o.u; }
+  bool operator>(const unique_gobj<T> &o) const noexcept { return u > o.u; }
+  bool operator>=(const unique_gobj<T> &o) const noexcept { return u >= o.u; }
+};
+
+template<typename T>
+void ::std::swap(unique_gobj<T> &f, unique_gobj<T> &s) noexcept { f.swap(s); }
+
+
+#endif

=== added file 'include/internal/httpdownloader.h'
--- include/internal/httpdownloader.h	1970-01-01 00:00:00 +0000
+++ include/internal/httpdownloader.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef HTTPDOWNLOADER_H
+#define HTTPDOWNLOADER_H
+
+#include<string>
+
+class HttpDownloader {
+public:
+    virtual std::string download(const std::string &url) = 0;
+    virtual ~HttpDownloader() {};
+};
+
+
+#endif

=== added file 'include/internal/imagescaler.h'
--- include/internal/imagescaler.h	1970-01-01 00:00:00 +0000
+++ include/internal/imagescaler.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef IMAGESCALER_H_
+#define IMAGESCALER_H_
+
+#include<thumbnailer.h>
+#include<string>
+
+class ImageScalerPrivate;
+
+class ImageScaler final {
+public:
+    ImageScaler();
+    ~ImageScaler();
+
+    ImageScaler(const ImageScaler &t) = delete;
+    ImageScaler & operator=(const ImageScaler &t) = delete;
+
+    bool scale(const std::string &ifilename, const std::string &ofilename,
+            ThumbnailSize wanted, const std::string &original_location) const;
+
+private:
+    ImageScalerPrivate *p;
+};
+
+
+#endif

=== added file 'include/internal/lastfmdownloader.h'
--- include/internal/lastfmdownloader.h	1970-01-01 00:00:00 +0000
+++ include/internal/lastfmdownloader.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef LASTFM_DOWNLOADER_H
+#define LASTFM_DOWNLOADER_H
+
+#include<string>
+#include<memory>
+#include<internal/httpdownloader.h>
+
+class LastFMDownloader final {
+public:
+    LastFMDownloader();
+    LastFMDownloader(HttpDownloader *o); // Takes ownership.
+    ~LastFMDownloader();
+    LastFMDownloader(const LastFMDownloader &o) = delete;
+    LastFMDownloader& operator=(const LastFMDownloader &o) = delete;
+
+    bool download(const std::string &artist, const std::string &album,
+            const std::string &fname);
+private:
+    std::string parseXML(const std::string &xml);
+    std::unique_ptr<HttpDownloader> dl;
+};
+
+#endif

=== added file 'include/internal/mediaartcache.h'
--- include/internal/mediaartcache.h	1970-01-01 00:00:00 +0000
+++ include/internal/mediaartcache.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2013-2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef MEDIAARTCACHE_H
+#define MEDIAARTCACHE_H
+
+#include<string>
+
+/*
+ * A class to store thumbnails for files according to
+ * https://wiki.gnome.org/MediaArtStorageSpec
+ *
+ * As this class deals mostly with the filesystem, all
+ * errors are reported with runtime_error exceptions.
+ */
+
+
+class MediaArtCache {
+private:
+    std::string root_dir;
+
+    std::string compute_base_name(const std::string &artist, const std::string &album) const;
+    std::string get_full_filename(const std::string &artist, const std::string & album) const;
+
+public:
+    static const unsigned int MAX_SIZE = 200;
+
+    MediaArtCache();
+    bool has_art(const std::string &artist, const std::string &album) const;
+    void add_art(const std::string &artist, const std::string &album,
+            const char *data, unsigned int datalen);
+    std::string get_art_file(const std::string &artist, const std::string &album) const;
+    std::string get_art_uri(const std::string &artist, const std::string &album) const;
+    void clear() const;
+    void prune();
+    std::string get_cache_dir() const { return root_dir; }
+};
+
+#endif

=== added file 'include/internal/soupdownloader.h'
--- include/internal/soupdownloader.h	1970-01-01 00:00:00 +0000
+++ include/internal/soupdownloader.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef SOUPDOWNLOADER_H
+#define SOUPDOWNLOADER_H
+
+#include<internal/httpdownloader.h>
+
+typedef struct _SoupSession SoupSession;
+
+class SoupDownloader final : public HttpDownloader {
+
+private:
+    SoupSession *session;
+
+public:
+    SoupDownloader();
+    virtual ~SoupDownloader();
+    SoupDownloader(const SoupDownloader &o) = delete;
+    SoupDownloader& operator=(const SoupDownloader &o) = delete;
+
+    std::string download(const std::string &url) override;
+};
+
+#endif

=== added file 'include/internal/thumbnailcache.h'
--- include/internal/thumbnailcache.h	1970-01-01 00:00:00 +0000
+++ include/internal/thumbnailcache.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef THUMBNAILCACHE_H_
+#define THUMBNAILCACHE_H_
+
+#include<thumbnailer.h>
+#include<string>
+
+class ThumbnailCachePrivate;
+
+class ThumbnailCache final {
+public:
+    ThumbnailCache();
+    ~ThumbnailCache();
+
+    ThumbnailCache(const ThumbnailCache &t) = delete;
+    ThumbnailCache & operator=(const ThumbnailCache &t) = delete;
+
+    std::string get_if_exists(const std::string &abs_path, ThumbnailSize desired_size) const;
+    std::string get_cache_file_name(const std::string &as_path, ThumbnailSize desired_size) const;
+    void clear();
+    void prune();
+
+private:
+    ThumbnailCachePrivate *p;
+};
+
+
+#endif

=== added file 'include/internal/videoscreenshotter.h'
--- include/internal/videoscreenshotter.h	1970-01-01 00:00:00 +0000
+++ include/internal/videoscreenshotter.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef VIDEOSCREENSHOTTER_H_
+#define VIDEOSCREENSHOTTER_H_
+
+#include<string>
+
+class VideoScreenshotterPrivate;
+
+class VideoScreenshotter final {
+public:
+    VideoScreenshotter();
+    ~VideoScreenshotter();
+
+    VideoScreenshotter(const VideoScreenshotter &t) = delete;
+    VideoScreenshotter & operator=(const VideoScreenshotter &t) = delete;
+
+    bool extract(const std::string &ifname, const std::string &ofname);
+
+};
+
+
+#endif

=== added file 'include/thumbnailer.h'
--- include/thumbnailer.h	1970-01-01 00:00:00 +0000
+++ include/thumbnailer.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef THUMBNAILER_H_
+#define THUMBNAILER_H_
+
+#include<string>
+
+class ThumbnailerPrivate;
+
+enum ThumbnailSize {
+    TN_SIZE_SMALL,   // maximum dimension 128 pixels
+    TN_SIZE_LARGE,   // maximum dimension 256 pixels
+    TN_SIZE_XLARGE,  // maximum dimension 512 pixels
+    TN_SIZE_ORIGINAL // Whatever the original size was, e.g. 1920x1080 for FullHD video
+};
+
+enum ThumbnailPolicy {
+    TN_LOCAL,  // Use only local information
+    TN_REMOTE, // Use remote services (e.g. album art downloading)
+};
+
+/**
+ * This class provides a way to generate and access
+ * thumbnails of video, audio and image files.
+ *
+ * All methods are blocking.
+ *
+ * All methods are thread safe.
+ *
+ * Errors are reported as exceptions.
+ */
+
+class Thumbnailer {
+public:
+    Thumbnailer();
+    ~Thumbnailer();
+
+    /**
+     * Gets a thumbnail of the given input file in the requested size.
+     *
+     * Return value is a string pointing to the thumbnail file. If
+     * the thumbnail could not be generated and empty string is returned.
+     *
+     * Applications should treat the returned file as read only. They should _not_
+     * delete it.
+     *
+     * In case of unexpected problems, the function throws a
+     * std::runtime_error.
+     */
+    std::string get_thumbnail(const std::string &filename, ThumbnailSize desired_size,
+            ThumbnailPolicy policy);
+    /**
+     * Deprecated. Do not use!
+     */
+    std::string get_thumbnail(const std::string &filename, ThumbnailSize desired_size);
+
+    std::string get_album_art(const std::string &artist, const std::string &album,
+            ThumbnailSize desiredSize, ThumbnailPolicy policy);
+private:
+    Thumbnailer(const Thumbnailer &t);
+    Thumbnailer & operator=(const Thumbnailer &t);
+
+    ThumbnailerPrivate *p;
+};
+
+#endif

=== added file 'include/thumbnailer.pc.in'
--- include/thumbnailer.pc.in	1970-01-01 00:00:00 +0000
+++ include/thumbnailer.pc.in	2015-02-04 08:57:20 +0000
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: thumbnailer
+Description: Thumbnail generator for multiple file types.
+Version: @SO_VERSION@
+Libs: -L${libdir} -lthumbnailer
+Cflags: -I${includedir}

=== added directory 'plugins'
=== renamed directory 'plugins' => 'plugins.moved'
=== added directory 'plugins/Ubuntu'
=== added directory 'plugins/Ubuntu/Thumbnailer'
=== added file 'plugins/Ubuntu/Thumbnailer/CMakeLists.txt'
--- plugins/Ubuntu/Thumbnailer/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,22 @@
+
+set(QML_PLUGIN_DIR "${CMAKE_INSTALL_LIBDIR}/qt5/qml/Ubuntu/Thumbnailer.0.1")
+
+add_library(thumbnailer-qml MODULE
+  plugin.cpp
+  albumartgenerator.cpp
+  thumbnailgenerator.cpp
+)
+
+set_target_properties(thumbnailer-qml PROPERTIES AUTOMOC TRUE)
+qt5_use_modules(thumbnailer-qml Qml Quick DBus)
+target_link_libraries(thumbnailer-qml thumbnailer)
+
+install(
+  TARGETS thumbnailer-qml
+  LIBRARY DESTINATION ${QML_PLUGIN_DIR}
+)
+
+install(
+  FILES qmldir
+  DESTINATION ${QML_PLUGIN_DIR}
+)

=== added file 'plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp'
--- plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: Jussi Pakkanen <[e-mail]>
+ *          James Henstridge <[e-mail]>
+*/
+
+#include "albumartgenerator.h"
+#include <stdexcept>
+#include <QDebug>
+#include <QFile>
+#include <QUrlQuery>
+#include <QDBusUnixFileDescriptor>
+#include <QDBusReply>
+
+static const char DEFAULT_ALBUM_ART[] = "/usr/share/unity/icons/album_missing.png";
+
+static const char BUS_NAME[] = "com.canonical.Thumbnailer";
+static const char BUS_PATH[] = "/com/canonical/Thumbnailer";
+static const char THUMBNAILER_IFACE[] = "com.canonical.Thumbnailer";
+static const char GET_ALBUM_ART[] = "GetAlbumArt";
+
+AlbumArtGenerator::AlbumArtGenerator()
+    : QQuickImageProvider(QQuickImageProvider::Image, QQmlImageProviderBase::ForceAsynchronousImageLoading),
+      iface(BUS_NAME, BUS_PATH, THUMBNAILER_IFACE) {
+}
+
+static QImage fallbackImage(QSize *realSize) {
+    QImage fallback;
+    fallback.load(DEFAULT_ALBUM_ART);
+    *realSize = fallback.size();
+    return fallback;
+}
+
+QImage AlbumArtGenerator::requestImage(const QString &id, QSize *realSize,
+        const QSize &requestedSize) {
+    QUrlQuery query(id);
+    if (!query.hasQueryItem("artist") || !query.hasQueryItem("album")) {
+        qWarning() << "Invalid albumart uri:" << id;
+        return fallbackImage(realSize);
+    }
+
+    const QString artist = query.queryItemValue("artist", QUrl::FullyDecoded);
+    const QString album = query.queryItemValue("album", QUrl::FullyDecoded);
+
+    QString desiredSize = "original";
+    int size = requestedSize.width() > requestedSize.height() ? requestedSize.width() : requestedSize.height();
+    if (size < 128) {
+        desiredSize = "small";
+    } else if (size < 256) {
+        desiredSize = "large";
+    } else if (size < 512) {
+        desiredSize = "xlarge";
+    }
+
+    // perform dbus call
+    QDBusReply<QDBusUnixFileDescriptor> reply = iface.call(
+        GET_ALBUM_ART, artist, album, desiredSize);
+    if (!reply.isValid()) {
+        qWarning() << "D-Bus error: " << reply.error().message();
+        return fallbackImage(realSize);
+    }
+
+    try {
+        QFile file;
+        file.open(reply.value().fileDescriptor(), QIODevice::ReadOnly);
+        QImage image;
+        image.load(&file, NULL);
+        *realSize = image.size();
+        return image;
+    } catch (const std::exception &e) {
+        qDebug() << "Album art loader failed: " << e.what();
+    } catch (...) {
+        qDebug() << "Unknown error when generating image.";
+    }
+
+    return fallbackImage(realSize);
+}

=== added file 'plugins/Ubuntu/Thumbnailer/albumartgenerator.h'
--- plugins/Ubuntu/Thumbnailer/albumartgenerator.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/albumartgenerator.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: Jussi Pakkanen <[e-mail]>
+ *          James Henstridge <[e-mail]>
+*/
+
+#ifndef ALBUMART_GENERATOR_H
+#define ALBUMART_GENERATOR_H
+
+#include <QDBusInterface>
+#include <QQuickImageProvider>
+
+class AlbumArtGenerator: public QQuickImageProvider
+{
+private:
+    QDBusInterface iface;
+
+public:
+    AlbumArtGenerator();
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
+};
+
+#endif

=== added file 'plugins/Ubuntu/Thumbnailer/plugin.cpp'
--- plugins/Ubuntu/Thumbnailer/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/plugin.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+*/
+
+#include "plugin.h"
+#include "albumartgenerator.h"
+#include "thumbnailgenerator.h"
+
+void ThumbnailerPlugin::registerTypes(const char *uri) {
+    qmlRegisterTypeNotAvailable(
+        uri, 0, 1, "__ThumbnailerIgnoreMe",
+        "Ignore this: QML plugins must contain at least one type");
+}
+
+void ThumbnailerPlugin::initializeEngine(QQmlEngine *engine, const char *uri) {
+    QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    try {
+        engine->addImageProvider("albumart", new AlbumArtGenerator());
+    } catch (const std::exception &e) {
+        qWarning() << "Failed to register albumart image provider:" << e.what();
+    } catch (...) {
+        qWarning() << "Failed to register albumart image provider.";
+    }
+
+    try {
+        engine->addImageProvider("thumbnailer", new ThumbnailGenerator());
+    } catch (const std::exception &e) {
+        qWarning() << "Failed to register thumbnailer image provider:" << e.what();
+    } catch (...) {
+        qWarning() << "Failed to register thumbnailer image provider.";
+    }
+}

=== added file 'plugins/Ubuntu/Thumbnailer/plugin.h'
--- plugins/Ubuntu/Thumbnailer/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/plugin.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: James Henstridge <[e-mail]>
+*/
+
+#ifndef THUMBNAILER_PLUGIN_H
+#define THUMBNAILER_PLUGIN_H
+
+#include <QtQml>
+
+class ThumbnailerPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    virtual void registerTypes(const char *uri) override;
+    virtual void initializeEngine(QQmlEngine *engine, const char *uri) override;
+};
+
+#endif

=== added file 'plugins/Ubuntu/Thumbnailer/qmldir'
--- plugins/Ubuntu/Thumbnailer/qmldir	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/qmldir	2015-02-04 08:57:20 +0000
@@ -0,0 +1,2 @@
+module Ubuntu.Thumbnailer
+plugin thumbnailer-qml

=== added file 'plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp'
--- plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: Jussi Pakkanen <[e-mail]>
+*/
+
+#include "thumbnailgenerator.h"
+#include <stdexcept>
+#include <QDebug>
+#include <QMimeDatabase>
+#include <QUrl>
+
+static const char *DEFAULT_VIDEO_ART = "/usr/share/unity/icons/video_missing.png";
+static const char *DEFAULT_ALBUM_ART = "/usr/share/unity/icons/album_missing.png";
+
+ThumbnailGenerator::ThumbnailGenerator() : QQuickImageProvider(QQuickImageProvider::Image,
+        QQmlImageProviderBase::ForceAsynchronousImageLoading) {
+
+}
+
+QImage ThumbnailGenerator::requestImage(const QString &id, QSize *realSize,
+        const QSize &requestedSize) {
+    /* Allow appending a query string (e.g. ?something=timestamp)
+     * to the id and then ignore it.
+     * This is workaround to force reloading a thumbnail when it has
+     * the same file name on disk but we know the content has changed.
+     * It is necessary because in such a situation the QML image cache
+     * will kick in and this ImageProvider will never get called.
+     * The only "solution" is setting Image.cache = false, but in some
+     * cases we don't want to do that for performance reasons, so this
+     * is the only way around the issue for now. */
+    std::string src_path(QUrl(id).path().toUtf8().data());
+    std::string tgt_path;
+    try {
+        ThumbnailSize desiredSize;
+        const int xlarge_cutoff = 512;
+        const int large_cutoff = 256;
+        const int small_cutoff = 128;
+        if(requestedSize.width() > xlarge_cutoff || requestedSize.height() > xlarge_cutoff) {
+            desiredSize = TN_SIZE_ORIGINAL;
+        } if(requestedSize.width() > large_cutoff || requestedSize.height() > large_cutoff) {
+                desiredSize = TN_SIZE_XLARGE;
+        } else if(requestedSize.width() > small_cutoff || requestedSize.height() > small_cutoff) {
+            desiredSize = TN_SIZE_LARGE;
+        } else {
+            desiredSize = TN_SIZE_SMALL;
+        }
+        tgt_path = tn.get_thumbnail(src_path, desiredSize);
+        if(!tgt_path.empty()) {
+            QString tgt(tgt_path.c_str());
+            QImage image;
+            image.load(tgt);
+            *realSize = image.size();
+            return image;
+        }
+    } catch(std::runtime_error &e) {
+        qDebug() << "Thumbnail generator failed: " << e.what();
+    }
+    return getFallbackImage(id, realSize, requestedSize);
+}
+
+QImage ThumbnailGenerator::getFallbackImage(const QString &id, QSize *size,
+        const QSize &requestedSize) {
+    Q_UNUSED(requestedSize);
+    QMimeDatabase db;
+    QMimeType mime = db.mimeTypeForFile(id);
+    QImage result;
+    if(mime.name().contains("audio")) {
+        result.load(DEFAULT_ALBUM_ART);
+    } else if(mime.name().contains("video")) {
+        result.load(DEFAULT_VIDEO_ART);
+    }
+    *size = result.size();
+    return result;
+}

=== added file 'plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h'
--- plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ *
+ * Authors: Jussi Pakkanen <[e-mail]>
+*/
+
+#ifndef THUMBNAIL_GENERATOR_H
+#define THUMBNAIL_GENERATOR_H
+
+#include <QQuickImageProvider>
+#include <thumbnailer.h>
+
+class ThumbnailGenerator: public QQuickImageProvider
+{
+private:
+    Thumbnailer tn;
+
+public:
+    ThumbnailGenerator();
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
+    QImage getFallbackImage(const QString &id, QSize *size, const QSize &requestedSize);
+};
+
+#endif

=== added directory 'src'
=== renamed directory 'src' => 'src.moved'
=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,41 @@
+add_library(thumbnailer SHARED
+#audioimageextractor.cpp
+imagescaler.cpp
+lastfmdownloader.cpp
+mediaartcache.cpp
+soupdownloader.cpp
+thumbnailcache.cpp
+thumbnailer.cpp
+videoscreenshotter.cpp
+)
+
+set(symbol_map "${CMAKE_CURRENT_SOURCE_DIR}/libthumbnailer.map")
+
+target_link_libraries(thumbnailer #${GST_DEPS_LDFLAGS}
+ ${GLIB_DEPS_LDFLAGS}
+ ${GIO_DEPS_LDFLAGS}
+ ${IMG_DEPS_LDFLAGS}
+ ${XML_DEPS_LDFLAGS}
+ ${SOUP_DEPS_LDFLAGS})
+set_target_properties(thumbnailer PROPERTIES VERSION ${SO_VERSION} SOVERSION ${ABI_VERSION})
+set_target_properties(thumbnailer PROPERTIES
+                      LINK_FLAGS "${ldflags} -Wl,--version-script,${symbol_map}")
+set_target_properties(thumbnailer PROPERTIES LINK_DEPENDS ${symbol_map})
+
+install(
+  TARGETS thumbnailer
+  ARCHIVE DESTINATION ${LIBDIR}
+  RUNTIME DESTINATION bin
+  LIBRARY DESTINATION ${LIBDIR}
+)
+
+add_executable(vs-thumb vs-thumb.cpp)
+target_link_libraries(vs-thumb ${GST_DEPS_LDFLAGS} ${IMG_DEPS_LDFLAGS})
+install(
+  TARGETS vs-thumb
+  ARCHIVE DESTINATION ${SHARE_PRIV_DIR}
+  RUNTIME DESTINATION ${SHARE_PRIV_DIR}
+  LIBRARY DESTINATION ${SHARE_PRIV_DIR}
+)
+
+add_subdirectory(service)

=== added file 'src/audioimageextractor.cpp'
--- src/audioimageextractor.cpp	1970-01-01 00:00:00 +0000
+++ src/audioimageextractor.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<cstdio>
+#include<internal/audioimageextractor.h>
+#include<unistd.h>
+#include<stdexcept>
+#include<memory>
+#include <gst/pbutils/pbutils.h>
+
+using namespace std;
+
+class GstInitializer {
+public:
+    GstInitializer() { gst_init(nullptr, nullptr); };
+};
+
+class AudioImageExtractorPrivate {
+};
+
+static bool has_tag(const GstTagList *tlist, const gchar *tagname) {
+  const GValue *val = gst_tag_list_get_value_index(tlist, tagname, 0);
+  return val;
+}
+
+static void extract_image(const GstTagList *tlist, FILE *outf) {
+  const GValue *val = gst_tag_list_get_value_index(tlist, GST_TAG_IMAGE, 0);
+  GstSample *sample = (GstSample*)g_value_get_boxed(val);
+  GstBuffer *buf = gst_sample_get_buffer(sample);
+
+  for(guint i=0; i<gst_buffer_n_memory(buf); i++) {
+    GstMemory *mem = gst_buffer_peek_memory(buf, i);
+    GstMapInfo mi;
+    gst_memory_map(mem, &mi, GST_MAP_READ);
+    fwrite(mi.data, 1, mi.size, outf);
+    gst_memory_unmap(mem, &mi);
+  }
+}
+
+AudioImageExtractor::AudioImageExtractor() {
+    static GstInitializer i; // C++ standard guarantees this to be lazy and thread safe.
+    p = new AudioImageExtractorPrivate();
+}
+
+AudioImageExtractor::~AudioImageExtractor() {
+    delete p;
+}
+
+
+bool AudioImageExtractor::extract(const string &ifname, const string &ofname) {
+    string uri("file://");
+    if(ifname[0] != '/') {
+        uri += getcwd(nullptr, 0);
+        uri += '/';
+    }
+    uri += ifname;
+    GError *err = nullptr;
+    unique_ptr<GstDiscoverer, void(*)(GstDiscoverer*)> dsc(
+            gst_discoverer_new(GST_SECOND, &err),
+            [](GstDiscoverer *t) {g_object_unref(G_OBJECT(t));});
+    if(err) {
+        string msg(err->message);
+        g_error_free(err);
+        throw runtime_error(msg);
+    }
+    unique_ptr<GstDiscovererInfo, void(*)(GstDiscovererInfo*)> info(
+            gst_discoverer_discover_uri(dsc.get(), uri.c_str(), &err),
+            [](GstDiscovererInfo *t) {g_object_unref(G_OBJECT(t));});
+    if(err) {
+        string msg(err->message);
+        g_error_free(err);
+        throw runtime_error(msg);
+    }
+    const GstTagList *tlist = gst_discoverer_info_get_tags(info.get());
+    if(!tlist) {
+        return false;
+    }
+    if(!has_tag(tlist, GST_TAG_IMAGE)) {
+        return false;
+    }
+    FILE *outfile = fopen(ofname.c_str(), "wb");
+    extract_image(tlist, outfile);
+    fclose(outfile);
+    return true;
+}

=== added file 'src/imagescaler.cpp'
--- src/imagescaler.cpp	1970-01-01 00:00:00 +0000
+++ src/imagescaler.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/imagescaler.h>
+#include<internal/gobj_memory.h>
+#include<gdk-pixbuf/gdk-pixbuf.h>
+#include<libexif/exif-loader.h>
+#include<memory>
+#include<stdexcept>
+#include<sys/stat.h>
+#include<cassert>
+#include<random>
+#include<cstring>
+
+using namespace std;
+
+static void determine_new_size(const int w, const int h, int &neww, int &newh,
+        const ThumbnailSize wanted) {
+    if(wanted == TN_SIZE_ORIGINAL) {
+        neww = w;
+        newh = h;
+    } else {
+        int max_dim = ((wanted == TN_SIZE_SMALL) ? 128 : ((wanted == TN_SIZE_LARGE) ? 256 : 512));
+        if(w > h) {
+            neww = max_dim;
+            newh = ((double)(max_dim))*h/w;
+            if (newh == 0)
+                newh = 1;
+        } else {
+            newh = max_dim;
+            neww = ((double)(max_dim))*w/h;
+            if(neww == 0)
+                neww = 1;
+        }
+    }
+}
+
+static GdkPixbuf* fix_orientation(const char *infile, GdkPixbuf *src) {
+    ExifLoader *l;
+    l = exif_loader_new();
+    ExifData *ed;
+    exif_loader_write_file(l, infile);
+    ed = exif_loader_get_data(l);
+    exif_loader_unref(l);
+    GdkPixbuf *rot = nullptr;
+    // Have to do this manually because of
+    // https://bugzilla.gnome.org/show_bug.cgi?id=725582
+    if(ed) {
+      ExifEntry *e = exif_data_get_entry(ed, EXIF_TAG_ORIENTATION);
+      if(e) {
+          int orientation = exif_get_short(e->data, exif_data_get_byte_order(ed));
+          if(orientation == 6) {
+              rot = gdk_pixbuf_rotate_simple(src, GDK_PIXBUF_ROTATE_CLOCKWISE);
+          } else if (orientation == 8) {
+              rot = gdk_pixbuf_rotate_simple(src, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
+          } else if (orientation == 3) {
+              rot = gdk_pixbuf_rotate_simple(src, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
+          } else {
+              // We don't do mirrored images, at least not yet.
+          }
+      }
+    }
+    if(!rot) {
+        // This entire function should only contain this call, really.
+      rot = gdk_pixbuf_apply_embedded_orientation(src);
+    }
+    exif_data_unref(ed);
+    return rot;
+}
+
+class ImageScalerPrivate {
+};
+
+ImageScaler::ImageScaler() {
+    p = new ImageScalerPrivate();
+}
+
+ImageScaler::~ImageScaler() {
+    delete p;
+}
+
+bool ImageScaler::scale(const std::string &ifilename, const std::string &ofilename, ThumbnailSize wanted,
+        const std::string &original_location) const {
+    random_device rnd;
+    assert(ifilename[0] == '/');
+    assert(ofilename[0] == '/');
+    GError *err = nullptr;
+    string ofilename_tmp = ofilename;
+    ofilename_tmp += ".tmp." + to_string(rnd());
+    unique_gobj<GdkPixbuf> orig(gdk_pixbuf_new_from_file(ifilename.c_str(), &err));
+    if(err) {
+        string msg = err->message;
+        g_error_free(err);
+        throw runtime_error(msg);
+    }
+    unique_gobj<GdkPixbuf> src(fix_orientation(ifilename.c_str(), orig.get()));
+    if(!src) {
+        throw runtime_error("Unknown error reorienting image.");
+    }
+    const int w = gdk_pixbuf_get_width(src.get());
+    const int h = gdk_pixbuf_get_height(src.get());
+    if(w == 0 || h == 0) {
+        throw runtime_error("Invalid image resolution.");
+    }
+
+    int neww, newh;
+    determine_new_size(w, h, neww, newh, wanted);
+    unique_gobj<GdkPixbuf> dst(gdk_pixbuf_scale_simple(src.get(), neww, newh, GDK_INTERP_BILINEAR));
+    gboolean save_ok;
+    if(original_location.empty()) {
+        save_ok = gdk_pixbuf_save(dst.get(), ofilename_tmp.c_str(), "png", &err, NULL);
+    } else {
+        assert(original_location[0] == '/');
+        time_t mtime;
+        string uri = "file://" + original_location;
+        struct stat sbuf;
+        if(stat(original_location.c_str(), &sbuf) != 0) {
+            mtime = 0;
+        } else {
+            mtime = sbuf.st_mtim.tv_sec;
+        }
+        string mtime_str = to_string(mtime);
+        save_ok = gdk_pixbuf_save(dst.get(), ofilename_tmp.c_str(), "png", &err,
+                "tEXt::Thumb::URI", uri.c_str(), "tEXt::Thumb::MTime", mtime_str.c_str(), NULL);
+        if(!save_ok) {
+            // Sigh. PNG text chunks are encoded in ISO-8859-1 but this is impossible if
+            // the file name contains e.g. Chinese characters. Fall back to writing the
+            // thumbnail without metadata. This does not conform to the thumbnailing standard
+            // but at least it will give us a working thumbnail.
+            g_error_free(err);
+            err = nullptr;
+            save_ok = gdk_pixbuf_save(dst.get(), ofilename_tmp.c_str(), "png", &err, NULL);
+        }
+    }
+    if(!save_ok) {
+        string msg = err->message;
+        g_error_free(err);
+        throw runtime_error(msg);
+    }
+    if(rename(ofilename_tmp.c_str(), ofilename.c_str()) <0) {
+        string msg("Could not rename temp file to actual file: ");
+        msg += strerror(errno);
+        unlink(ofilename_tmp.c_str()); // Nothing we can do if it fails.
+        throw runtime_error(msg);
+    }
+    return true;
+}

=== added file 'src/lastfmdownloader.cpp'
--- src/lastfmdownloader.cpp	1970-01-01 00:00:00 +0000
+++ src/lastfmdownloader.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/lastfmdownloader.h>
+#include<internal/soupdownloader.h>
+#include<internal/gobj_memory.h>
+#include<memory>
+#include <libxml/parser.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/xpath.h>
+
+const char *NOTFOUND_IMAGE = "http://cdn.last.fm/flatness/catalogue/noimage/2/default_album_medium.png";
+
+using namespace std;
+
+LastFMDownloader::LastFMDownloader() : dl(new SoupDownloader()){
+}
+
+LastFMDownloader::LastFMDownloader(HttpDownloader *o) : dl(o) {
+}
+
+LastFMDownloader::~LastFMDownloader() {
+}
+
+string LastFMDownloader::parseXML(const string &xml) {
+    string node = "/album/coverart/large";
+    unique_ptr<xmlDoc, void(*)(xmlDoc*)> doc(
+            xmlReadMemory(xml.c_str(), xmlStrlen ((xmlChar*) xml.c_str()), NULL, NULL,
+                          XML_PARSE_RECOVER | XML_PARSE_NOBLANKS), xmlFreeDoc);
+     if (!doc) {
+       return "";
+     }
+     unique_ptr<xmlXPathContext, void(*)(xmlXPathContext*)> cntx(
+             xmlXPathNewContext(doc.get()), xmlXPathFreeContext);
+
+     unique_ptr<xmlXPathObject, void(*)(xmlXPathObject *)> path(
+             xmlXPathEvalExpression((xmlChar *) node.c_str(),  cntx.get()),
+             xmlXPathFreeObject);
+     if (!path) {
+       return "";
+     }
+
+     char *imageurl;
+     if (path->nodesetval->nodeTab) {
+       imageurl = (char *) xmlNodeListGetString(doc.get(),
+               path->nodesetval->nodeTab[0]->xmlChildrenNode, 1);
+     }
+     string url(imageurl);
+     xmlFree(imageurl);
+     return url;
+}
+
+bool LastFMDownloader::download(const std::string &artist,
+        const std::string &album, const std::string &fname) {
+    const char *lastfmTemplate = "http://ws.audioscrobbler.com/1.0/album/%s/%s/info.xml";
+    const int bufsize = 1024;
+    char buf[bufsize];
+    snprintf(buf, bufsize, lastfmTemplate, artist.c_str(), album.c_str());
+    string xml(dl->download(buf));
+    string parsed = parseXML(xml);
+    if(parsed.empty() ||
+       parsed == NOTFOUND_IMAGE) {
+        fprintf(stderr, "Could not find album art.\n");
+        return false;
+    }
+
+    string image(dl->download(parsed));
+    FILE *f = fopen(fname.c_str(), "w");
+    fwrite(image.c_str(), 1, image.length(), f);
+    fclose(f);
+    return true;
+}

=== added file 'src/libthumbnailer.map'
--- src/libthumbnailer.map	1970-01-01 00:00:00 +0000
+++ src/libthumbnailer.map	2015-02-04 08:57:20 +0000
@@ -0,0 +1,14 @@
+{
+global:
+    extern "C++" {
+        "Thumbnailer::Thumbnailer()";
+        "Thumbnailer::~Thumbnailer()";
+        "Thumbnailer::get_thumbnail(std::string const&, ThumbnailSize)";
+        "Thumbnailer::get_thumbnail(std::string const&, ThumbnailSize, ThumbnailPolicy)";
+        "Thumbnailer::get_album_art(std::string const&, std::string const&, ThumbnailSize, ThumbnailPolicy)";
+    };
+local:
+    extern "C++" {
+        *;
+    };
+};

=== added file 'src/mediaartcache.cpp'
--- src/mediaartcache.cpp	1970-01-01 00:00:00 +0000
+++ src/mediaartcache.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2012-2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/mediaartcache.h>
+
+#include<dirent.h>
+#include<sys/stat.h>
+#include<fcntl.h>
+#include<unistd.h>
+#include<errno.h>
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<assert.h>
+#include<utime.h>
+
+#include<glib.h>
+
+#include<vector>
+#include<algorithm>
+#include<stdexcept>
+
+using namespace std;
+
+static string md5(const string &str) {
+    const unsigned char *buf = (const unsigned char *)str.c_str();
+    char *normalized = g_utf8_normalize((const gchar*)buf, str.size(), G_NORMALIZE_ALL);
+    string final;
+    gchar *result;
+
+    if(normalized) {
+        buf = (const unsigned char*)normalized;
+    }
+
+    result = g_compute_checksum_for_data(G_CHECKSUM_MD5, buf, strlen((const char*)buf));
+    final = result;
+    g_free((gpointer)normalized);
+    g_free(result);
+    return final;
+}
+
+MediaArtCache::MediaArtCache() {
+    string xdg_base = g_get_user_cache_dir();
+
+    if (xdg_base == "") {
+        string s("Could not determine cache dir.");
+        throw runtime_error(s);
+    }
+    int ec = mkdir(xdg_base.c_str(), S_IRUSR | S_IWUSR | S_IXUSR);
+    if (ec < 0 && errno != EEXIST) {
+        string s("Could not create base dir.");
+        throw runtime_error(s);
+    }
+    root_dir = xdg_base + "/media-art";
+    ec = mkdir(root_dir.c_str(), S_IRUSR | S_IWUSR | S_IXUSR);
+    if (ec < 0 && errno != EEXIST) {
+        string s("Could not create cache dir.");
+        throw runtime_error(s);
+    }
+}
+
+bool MediaArtCache::has_art(const std::string &artist, const std::string &album) const {
+    string fname = get_art_file(artist, album);
+    return access(fname.c_str(), R_OK) == 0;
+}
+
+void MediaArtCache::add_art(const std::string &artist, const std::string &album,
+        const char *data, unsigned int datalen) {
+    string abs_fname = get_full_filename(artist, album);
+    GError *err = nullptr;
+    if(!g_file_set_contents(abs_fname.c_str(), data, datalen, &err)) {
+        string e("Could not write file ");
+        e += abs_fname;
+        e += ": ";
+        e += err->message;
+        g_error_free(err);
+        throw runtime_error(e);
+    }
+}
+
+string MediaArtCache::get_art_file(const std::string &artist, const std::string &album) const {
+    string abs_fname = get_full_filename(artist, album);
+
+    if (access(abs_fname.c_str(), R_OK) == 0) {
+        utime(abs_fname.c_str(), nullptr); // update access times to current time
+        return abs_fname;
+    }
+    return "";
+}
+
+string MediaArtCache::get_art_uri(const string &artist, const string &album) const
+{
+    std::string filename = get_art_file(artist, album);
+
+    if (filename == "") {
+        return "";
+    }
+
+    GError *err = nullptr;
+    char *c_uri = g_filename_to_uri(filename.c_str(), "", &err);
+    if (!c_uri) {
+        string e("Could not convert file name ");
+        e += filename;
+        e += " to URI: ";
+        e += err->message;
+        g_error_free(err);
+        throw runtime_error(e);
+    }
+
+    std::string uri = c_uri;
+    g_free(c_uri);
+    return uri;
+}
+
+std::string MediaArtCache::get_full_filename(const std::string &artist, const std::string & album) const {
+    return root_dir + "/" + compute_base_name(artist, album);
+}
+
+
+std::string MediaArtCache::compute_base_name(const std::string &artist, const std::string &album) const {
+    string type = "album";
+    string h1 = md5(artist);
+    string h2 = md5(album);
+    return type + "-" + h1 + "-" + h2 + ".jpg";
+}
+
+
+void MediaArtCache::clear() const {
+    DIR *d = opendir(root_dir.c_str());
+    if(!d) {
+        string s = "Something went wrong.";
+        throw runtime_error(s);
+    }
+    struct dirent *entry, *de;
+    entry = (dirent*)malloc(sizeof(dirent) + NAME_MAX + 1);
+    while(readdir_r(d, entry, &de) == 0 && de) {
+        string basename = entry->d_name;
+        if (basename == "." || basename == "..")
+            continue;
+        string fname = root_dir + "/" + basename;
+        if(remove(fname.c_str()) < 0) {
+            // This is not really an error worth
+            // halting everything for.
+            fprintf(stderr, "Could not delete file %s: %s.\n", fname.c_str(),
+                    strerror(errno));
+        }
+    }
+    free(entry);
+    closedir(d);
+}
+
+void MediaArtCache::prune() {
+    vector<pair<double, string>> mtimes;
+    DIR *d = opendir(root_dir.c_str());
+    if(!d) {
+        string s = "Something went wrong.";
+        throw runtime_error(s);
+    }
+    struct dirent *entry, *de;
+    entry = (dirent*)malloc(sizeof(dirent) + NAME_MAX + 1);
+    while(readdir_r(d, entry, &de) == 0 && de) {
+        string basename = entry->d_name;
+        if (basename == "." || basename == "..")
+            continue;
+        string fname = root_dir + "/" + basename;
+        struct stat sbuf;
+        if(stat(fname.c_str(), &sbuf) != 0) {
+            continue;
+        }
+        // Use mtime because atime is not guaranteed to work if, for example
+        // the filesystem is mounted with noatime or relatime.
+        mtimes.push_back(make_pair(sbuf.st_mtim.tv_sec + sbuf.st_mtim.tv_nsec/1000000000.0, fname));
+    }
+    free(entry);
+    closedir(d);
+    if (mtimes.size() <= MAX_SIZE)
+        return;
+    sort(mtimes.begin(), mtimes.end());
+    for(size_t i=0; i < mtimes.size()-MAX_SIZE; i++) {
+        if(remove(mtimes[i].second.c_str()) < 0) {
+            fprintf(stderr, "Could not remove file %s: %s.\n",
+                    mtimes[i].second.c_str(), strerror(errno));
+        }
+    }
+}
+

=== added directory 'src/service'
=== added file 'src/service/CMakeLists.txt'
--- src/service/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/service/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,34 @@
+add_definitions(${THUMBNAILER_CFLAGS})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+add_executable(thumbnailer-service
+  main.cpp
+  dbusinterface.cpp
+  dbus-generated.c
+)
+
+target_link_libraries(thumbnailer-service thumbnailer)
+
+install(
+  TARGETS thumbnailer-service
+  RUNTIME DESTINATION ${SHARE_PRIV_DIR}
+)
+
+find_program(gdbus_codegen gdbus-codegen)
+if(NOT gdbus_codegen)
+  msg(FATAL_ERROR "Could not locate gdbus-codegen")
+endif()
+
+add_custom_command(
+  OUTPUT dbus-generated.c dbus-generated.h
+  COMMAND ${gdbus_codegen} --interface-prefix=com.canonical. --generate-c-code dbus-generated --c-namespace TN ${CMAKE_CURRENT_SOURCE_DIR}/dbus-interface.xml
+  MAIN_DEPENDENCY dbus-interface.xml
+)
+
+# Install the service file.
+configure_file(com.canonical.Thumbnailer.service.in com.canonical.Thumbnailer.service)
+
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.Thumbnailer.service
+  DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services
+)

=== added file 'src/service/com.canonical.Thumbnailer.service.in'
--- src/service/com.canonical.Thumbnailer.service.in	1970-01-01 00:00:00 +0000
+++ src/service/com.canonical.Thumbnailer.service.in	2015-02-04 08:57:20 +0000
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=com.canonical.Thumbnailer
+Exec=@SHARE_PRIV_ABS@/thumbnailer-service
+

=== added file 'src/service/dbus-interface.xml'
--- src/service/dbus-interface.xml	1970-01-01 00:00:00 +0000
+++ src/service/dbus-interface.xml	2015-02-04 08:57:20 +0000
@@ -0,0 +1,17 @@
+<node>
+  <interface name="com.canonical.Thumbnailer">
+    <method name="GetAlbumArt">
+      <arg direction="in" type="s" name="artist" />
+      <arg direction="in" type="s" name="album" />
+      <!-- possible values are "small", "large", "xlarge" and "original" -->
+      <arg direction="in" type="s" name="desiredSize" />
+      <arg direction="out" type="h" name="fd" />
+      <annotation name="org.gtk.GDBus.C.UnixFD" value="true" />
+    </method>
+
+    <!-- Note: if adding additional thumbnailing methods that take a
+         file name as input, ensure that the calling process has
+         permission to read said file.  Otherwise we will leak
+         information to confined applications. -->
+  </interface>
+</node>

=== added file 'src/service/dbusinterface.cpp'
--- src/service/dbusinterface.cpp	1970-01-01 00:00:00 +0000
+++ src/service/dbusinterface.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library 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 General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dbusinterface.h"
+
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+#include <gio/gunixfdlist.h>
+#include <thumbnailer.h>
+
+#include <internal/gobj_memory.h>
+#include "dbus-generated.h"
+
+using namespace std;
+
+static const char BUS_NAME[] = "com.canonical.MediaScanner2";
+static const char ART_ERROR[] = "com.canonical.MediaScanner2.Error.Failed";
+
+static const char MISSING_ALBUM_ART[] = "/usr/share/unity/icons/album_missing.png";
+
+struct DBusInterfacePrivate {
+    const std::string bus_path;
+    unique_gobj<GDBusConnection> bus;
+    unique_gobj<TNThumbnailer> iface;
+    unsigned int handler_id;
+    std::shared_ptr<Thumbnailer> thumbnailer;
+
+    DBusInterfacePrivate(GDBusConnection *g_bus, const std::string& bus_path)
+        : bus_path(bus_path),
+          bus(static_cast<GDBusConnection*>(g_object_ref(g_bus))),
+          iface(tn_thumbnailer_skeleton_new()),
+          handler_id(0),
+          thumbnailer(std::make_shared<Thumbnailer>()) {
+        handler_id = g_signal_connect(
+            iface.get(), "handle-get-album-art",
+            G_CALLBACK(&DBusInterfacePrivate::handleGetAlbumArt), this);
+
+        GError *error = nullptr;
+        if (!g_dbus_interface_skeleton_export(
+                G_DBUS_INTERFACE_SKELETON(iface.get()), bus.get(),
+                bus_path.c_str(), &error)) {
+            string errortxt(error->message);
+            g_error_free(error);
+
+            string msg = "Failed to export interface: ";
+            msg += errortxt;
+            throw runtime_error(msg);
+        }
+    }
+
+    ~DBusInterfacePrivate() {
+        g_dbus_interface_skeleton_unexport(
+            G_DBUS_INTERFACE_SKELETON(iface.get()));
+        g_signal_handler_disconnect(iface.get(), handler_id);
+    }
+
+    static gboolean handleGetAlbumArt(TNThumbnailer *iface, GDBusMethodInvocation *invocation, GUnixFDList *, const char *artist, const char *album, const char *size, void *user_data) {
+        auto p = static_cast<DBusInterfacePrivate*>(user_data);
+        fprintf(stderr, "Look up cover art for %s/%s at size %s\n", artist, album, size);
+
+        ThumbnailSize desiredSize;
+        if (!strcmp(size, "small")) {
+            desiredSize = TN_SIZE_SMALL;
+        } else if (!strcmp(size, "large")) {
+            desiredSize = TN_SIZE_LARGE;
+        } else if (!strcmp(size, "xlarge")) {
+            desiredSize = TN_SIZE_XLARGE;
+        } else if (!strcmp(size, "original")) {
+            desiredSize = TN_SIZE_ORIGINAL;
+        } else {
+            std::string error("Unknown size: ");
+            error += size;
+            g_dbus_method_invocation_return_dbus_error(
+                invocation, ART_ERROR, error.c_str());
+            return TRUE;
+        }
+
+        try {
+            std::thread t(&getAlbumArt,
+                          unique_gobj<TNThumbnailer>(static_cast<TNThumbnailer*>(g_object_ref(iface))),
+                          unique_gobj<GDBusMethodInvocation>(static_cast<GDBusMethodInvocation*>(g_object_ref(invocation))),
+                          p->thumbnailer,
+                          std::string(artist), std::string(album), desiredSize);
+            t.detach();
+        } catch (const std::exception &e) {
+            g_dbus_method_invocation_return_dbus_error(
+                invocation, ART_ERROR, e.what());
+        }
+        return TRUE;
+    }
+
+    static void getAlbumArt(unique_gobj<TNThumbnailer> iface,
+                            unique_gobj<GDBusMethodInvocation> invocation,
+                            std::shared_ptr<Thumbnailer> thumbnailer,
+                            const std::string artist, const std::string album,
+                            ThumbnailSize desiredSize) {
+        std::string art;
+        try {
+            art = thumbnailer->get_album_art(
+                artist, album, desiredSize, TN_REMOTE);
+        } catch (const std::exception &e) {
+            g_dbus_method_invocation_return_dbus_error(
+                invocation.get(), ART_ERROR, e.what());
+            return;
+        }
+
+        if (art.empty()) {
+            g_dbus_method_invocation_return_dbus_error(
+                invocation.get(), ART_ERROR, "Could not get thumbnail");
+            return;
+        }
+        int fd = open(art.c_str(), O_RDONLY);
+        if (fd < 0) {
+            g_dbus_method_invocation_return_dbus_error(
+                invocation.get(), ART_ERROR, strerror(errno));
+            return;
+        }
+
+        unique_gobj<GUnixFDList> fd_list(g_unix_fd_list_new());
+        GError *error = nullptr;
+        g_unix_fd_list_append(fd_list.get(), fd, &error);
+        close(fd);
+        if (error != nullptr) {
+            g_dbus_method_invocation_return_dbus_error(
+                invocation.get(), ART_ERROR, error->message);
+            g_error_free(error);
+            return;
+        }
+
+        tn_thumbnailer_complete_get_album_art(
+            iface.get(), invocation.get(), fd_list.get(), g_variant_new_handle(0));
+    }
+
+};
+
+DBusInterface::DBusInterface(GDBusConnection *bus, const std::string& bus_path)
+    : p(new DBusInterfacePrivate(bus, bus_path)) {
+}
+
+DBusInterface::~DBusInterface() {
+    delete p;
+}

=== added file 'src/service/dbusinterface.h'
--- src/service/dbusinterface.h	1970-01-01 00:00:00 +0000
+++ src/service/dbusinterface.h	2015-02-04 08:57:20 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library 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 General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DBUSINTERFACE_H
+#define DBUSINTERFACE_H
+
+#include <string>
+
+struct DBusInterfacePrivate;
+typedef struct _GDBusConnection GDBusConnection;
+
+class DBusInterface final {
+public:
+    DBusInterface(GDBusConnection *bus, const std::string& bus_path);
+    ~DBusInterface();
+
+    DBusInterface(const DBusInterface&) = delete;
+    DBusInterface& operator=(DBusInterface&) = delete;
+
+private:
+    DBusInterfacePrivate *p;
+};
+
+#endif

=== added file 'src/service/main.cpp'
--- src/service/main.cpp	1970-01-01 00:00:00 +0000
+++ src/service/main.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,44 @@
+#include <cstdio>
+#include <memory>
+#include <stdexcept>
+#include <glib.h>
+#include <gio/gio.h>
+
+#include "dbusinterface.h"
+
+static const char BUS_NAME[] = "com.canonical.Thumbnailer";
+static const char BUS_PATH[] = "/com/canonical/Thumbnailer";
+
+static std::unique_ptr<GMainLoop,void(*)(GMainLoop*)> main_loop(
+    g_main_loop_new(nullptr, FALSE), g_main_loop_unref);
+
+static void nameLost(GDBusConnection *, const char *, void *) {
+    fprintf(stderr, "Could no acquire D-Bus name %s.  Quitting.\n", BUS_NAME);
+    g_main_loop_quit(main_loop.get());
+}
+
+int main(int argc, char **argv) {
+    GError *error = nullptr;
+    std::unique_ptr<GDBusConnection, void(*)(void*)> bus(
+        g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error),
+        g_object_unref);
+    if (error != nullptr) {
+        fprintf(stderr, "Failed to connect to session bus: %s\n", error->message);
+        g_error_free(error);
+        return 1;
+    }
+
+    DBusInterface dbus(bus.get(), BUS_PATH);
+
+    unsigned int name_id = g_bus_own_name_on_connection(
+        bus.get(), BUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE,
+        nullptr, &nameLost, nullptr, nullptr);
+
+    g_main_loop_run(main_loop.get());
+
+    if (name_id != 0) {
+        g_bus_unown_name(name_id);
+    }
+
+    return 0;
+}

=== added file 'src/soupdownloader.cpp'
--- src/soupdownloader.cpp	1970-01-01 00:00:00 +0000
+++ src/soupdownloader.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/soupdownloader.h>
+#include<libsoup/soup.h>
+#include<internal/gobj_memory.h>
+#include<stdexcept>
+
+SoupDownloader::SoupDownloader() {
+    session = soup_session_sync_new();
+    if(!session) {
+        throw std::runtime_error("Could not create Soup session.");
+    }
+}
+
+SoupDownloader::~SoupDownloader() {
+    g_object_unref(G_OBJECT(session));
+}
+
+std::string SoupDownloader::download(const std::string &url) {
+    unique_gobj<SoupMessage> msg(soup_message_new("GET", url.c_str()));
+    guint status;
+    status = soup_session_send_message(session, msg.get());
+    if(!SOUP_STATUS_IS_SUCCESSFUL(status)) {
+        fprintf(stderr, "Determination failed.\n");
+        return "";
+    }
+    std::string result(msg->response_body->data, msg->response_body->length);
+    return result;
+}
+

=== added file 'src/thumbnailcache.cpp'
--- src/thumbnailcache.cpp	1970-01-01 00:00:00 +0000
+++ src/thumbnailcache.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,300 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#ifndef _POSIX_SOURCE
+#define _POSIX_SOURCE
+#endif
+
+#include<thumbnailer.h>
+#include<internal/thumbnailcache.h>
+#include<stdexcept>
+#include<glib.h>
+#include<sys/stat.h>
+#include<sys/types.h>
+#include<cassert>
+#include<cstdio>
+#include<cstring>
+#include<errno.h>
+#include<fcntl.h>
+#include<unistd.h>
+#include<vector>
+#include<algorithm>
+#include<dirent.h>
+
+using namespace std;
+
+static void cleardir(const string &root_dir) {
+    DIR *d = opendir(root_dir.c_str());
+    if(!d) {
+        string s = "Something went wrong.";
+        throw runtime_error(s);
+    }
+    struct dirent *entry, *de;
+    entry = (dirent*)malloc(sizeof(dirent) + NAME_MAX);
+    while(readdir_r(d, entry, &de) == 0 && de) {
+        string basename = entry->d_name;
+        if (basename == "." || basename == "..")
+            continue;
+        string fname = root_dir + "/" + basename;
+        remove(fname.c_str());
+    }
+    free(entry);
+    closedir(d);
+}
+
+/*
+ * This code is copied from mediaartcache. All tests etc
+ * are there. When we merge the two, remove this and
+ * make both use the same code.
+ */
+static void prune_dir(const string &root_dir, const size_t max_files) {
+    vector<pair<double, string>> mtimes;
+    DIR *d = opendir(root_dir.c_str());
+    if(!d) {
+        string s = "Something went wrong.";
+        throw runtime_error(s);
+    }
+    struct dirent *entry, *de;
+    entry = (dirent*)malloc(sizeof(dirent) + NAME_MAX);
+    while(readdir_r(d, entry, &de) == 0 && de) {
+        string basename = entry->d_name;
+        if (basename == "." || basename == "..")
+            continue;
+        string fname = root_dir + "/" + basename;
+        struct stat sbuf;
+        if(stat(fname.c_str(), &sbuf) != 0) {
+            continue;
+        }
+        // Use mtime because atime is not guaranteed to work if, for example
+        // the filesystem is mounted with noatime or relatime.
+        mtimes.push_back(make_pair(sbuf.st_mtim.tv_sec + sbuf.st_mtim.tv_nsec/1000000000.0, fname));
+    }
+    free(entry);
+    closedir(d);
+    if (mtimes.size() <= max_files)
+        return;
+    sort(mtimes.begin(), mtimes.end());
+    for(size_t i=0; i < mtimes.size()-max_files; i++) {
+        remove(mtimes[i].second.c_str());
+    }
+}
+
+static string get_app_pkg_name() {
+    const int bufsize = 1024;
+    char data[bufsize+1];
+    FILE *f = fopen("/proc/self/attr/current", "r");
+    if(!f) {
+        throw runtime_error("Could not open /proc/self/attr/current.");
+    }
+    size_t numread = fread(data, 1, bufsize, f);
+    fclose(f);
+    if(numread == 0) {
+        throw runtime_error("Could not read from /proc/self/attr/current.");
+    }
+    data[numread] = '\0';
+    string core(data);
+    string::size_type ind = core.find('_');
+    if(ind == string::npos) {
+        throw runtime_error("/proc/self/attr/current malformed, does not have _ in it.");
+    }
+    if(ind == 0) {
+        throw runtime_error("/proc/self/attr/current malformed, starts with '_'.");
+    }
+    return core.substr(0, ind);
+}
+
+class ThumbnailCachePrivate {
+public:
+
+    ThumbnailCachePrivate();
+    string md5(const string &str) const;
+    string get_cache_file_name(const std::string &original, ThumbnailSize desired) const;
+    void clear();
+    void delete_from_cache(const std::string &abs_path);
+    void prune();
+
+private:
+    string tndir;
+    string smalldir;
+    string largedir;
+    string xlargedir;
+    string originaldir;
+    static const size_t MAX_FILES = 200;
+
+};
+
+void ThumbnailCachePrivate::clear() {
+    cleardir(smalldir);
+    cleardir(largedir);
+    cleardir(xlargedir);
+    cleardir(originaldir);
+}
+
+
+void ThumbnailCachePrivate::prune() {
+    prune_dir(smalldir, MAX_FILES);
+    prune_dir(largedir, MAX_FILES);
+    prune_dir(xlargedir, MAX_FILES);
+    prune_dir(originaldir, MAX_FILES);
+}
+
+void ThumbnailCachePrivate::delete_from_cache(const std::string &abs_path) {
+    unlink(get_cache_file_name(abs_path, TN_SIZE_SMALL).c_str());
+    unlink(get_cache_file_name(abs_path, TN_SIZE_LARGE).c_str());
+    unlink(get_cache_file_name(abs_path, TN_SIZE_XLARGE).c_str());
+    unlink(get_cache_file_name(abs_path, TN_SIZE_ORIGINAL).c_str());
+}
+
+static string makedir(const string &base, const string &subdir) {
+    string dirname = base;
+    dirname += "/";
+    dirname += subdir;
+    int ec;
+    errno = 0;
+    ec = mkdir(dirname.c_str(), S_IRUSR | S_IWUSR | S_IXUSR);
+    if (ec < 0 && errno != EEXIST) {
+        string s("Could not create ");
+        s += subdir;
+        s += " - ";
+        s += strerror(errno);
+        throw runtime_error(s);
+    }
+    return dirname;
+}
+
+ThumbnailCachePrivate::ThumbnailCachePrivate() {
+    string xdg_base = g_get_user_cache_dir();
+    if (xdg_base == "") {
+        string s("Could not determine cache dir.");
+        throw runtime_error(s);
+    }
+    int ec = mkdir(xdg_base.c_str(), S_IRUSR | S_IWUSR | S_IXUSR);
+    if (ec < 0 && errno != EEXIST) {
+        string s("Could not create base dir - ");
+        s += strerror(errno);
+        throw runtime_error(s);
+    }
+    // This is where it gets tricky. Desktop apps can write to
+    // cache dir but confined apps only to cache/appname/
+    // First try global cache and fall back to app-specific one.
+    string testfile = xdg_base + "/tncache-write-text.null";
+    int fd = open(testfile.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+    bool use_global = true;
+    if(fd<0) {
+        if(errno == EACCES) {
+            use_global = false;
+        } else {
+            string s("Unknown error when checking cache access: ");
+            s += strerror(errno);
+            throw runtime_error(s);
+        }
+    } else {
+        use_global = true;
+        close(fd);
+        unlink(testfile.c_str());
+    }
+    if(!use_global) {
+        string app_pkgname = get_app_pkg_name();
+        xdg_base  = makedir(xdg_base, app_pkgname);
+    }
+    tndir = xdg_base + "/thumbnails";
+    tndir = makedir(xdg_base, "thumbnails");
+    smalldir = makedir(tndir,"normal");
+    largedir = makedir(tndir, "large");
+    xlargedir = makedir(tndir, "xlarge");
+    originaldir = makedir(tndir, "original");
+}
+
+string ThumbnailCachePrivate::md5(const string &str) const {
+    const unsigned char *buf = (const unsigned char *)str.c_str();
+    char *normalized = g_utf8_normalize((const gchar*)buf, str.size(), G_NORMALIZE_ALL);
+    string final_result;
+    gchar *result;
+
+    if(normalized) {
+        buf = (const unsigned char*)normalized;
+    }
+    gssize bytes = str.length();
+
+    result = g_compute_checksum_for_data(G_CHECKSUM_MD5, buf, bytes);
+    final_result = result;
+    g_free((gpointer)normalized);
+    g_free(result);
+    return final_result;
+}
+
+string ThumbnailCachePrivate::get_cache_file_name(const std::string & abs_original, ThumbnailSize desired) const {
+    assert(abs_original[0] == '/');
+    string path;
+    switch(desired) {
+    case TN_SIZE_SMALL : path = smalldir; break;
+    case TN_SIZE_LARGE : path = largedir; break;
+    case TN_SIZE_XLARGE : path = xlargedir; break;
+    case TN_SIZE_ORIGINAL : path = originaldir; break;
+    default : throw runtime_error("Unreachable code");
+    }
+    path += "/" + md5("file://" + abs_original) + ".png";
+    return path;
+}
+
+ThumbnailCache::ThumbnailCache() : p(new ThumbnailCachePrivate()) {
+}
+
+ThumbnailCache::~ThumbnailCache() {
+    delete p;
+}
+
+std::string ThumbnailCache::get_if_exists(const std::string &abs_path, ThumbnailSize desired_size) const {
+    assert(abs_path[0] == '/');
+    string fname = p->get_cache_file_name(abs_path, desired_size);
+    FILE *f = fopen(abs_path.c_str(), "r");
+    if(!f) {
+        p->delete_from_cache(abs_path);
+        return "";
+    }
+    fclose(f);
+    f = fopen(fname.c_str(), "r");
+    bool existed = false;
+    if(f) {
+        existed = true;
+        fclose(f);
+    }
+    // Has it been changed since the thumbnail was taken?
+    if(existed) {
+        struct stat original, thumbnail;
+        stat(abs_path.c_str(), &original);
+        stat(fname.c_str(), &thumbnail);
+        if(original.st_mtime > thumbnail.st_mtime) {
+            p->delete_from_cache(abs_path);
+            return "";
+        }
+    }
+    return existed ? fname : string("");
+}
+
+std::string ThumbnailCache::get_cache_file_name(const std::string &abs_path, ThumbnailSize desired) const {
+    return p->get_cache_file_name(abs_path, desired);
+}
+
+void ThumbnailCache::clear() {
+    p->clear();
+}
+
+void ThumbnailCache::prune() {
+    p->prune();
+}

=== added file 'src/thumbnailer.cpp'
--- src/thumbnailer.cpp	1970-01-01 00:00:00 +0000
+++ src/thumbnailer.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<thumbnailer.h>
+#include<internal/thumbnailcache.h>
+#include<internal/audioimageextractor.h>
+#include<internal/videoscreenshotter.h>
+#include<internal/imagescaler.h>
+#include<internal/mediaartcache.h>
+#include<internal/lastfmdownloader.h>
+#include<gdk-pixbuf/gdk-pixbuf.h>
+#include<unistd.h>
+#include<gst/gst.h>
+#include<stdexcept>
+#include<random>
+#include<gio/gio.h>
+#include<glib.h>
+#include<memory>
+
+using namespace std;
+
+class ThumbnailerPrivate {
+private:
+    random_device rnd;
+
+    string create_audio_thumbnail(const string &abspath, ThumbnailSize desired_size,
+            ThumbnailPolicy policy);
+    string create_video_thumbnail(const string &abspath, ThumbnailSize desired_size);
+    string create_generic_thumbnail(const string &abspath, ThumbnailSize desired_size);
+
+public:
+    ThumbnailCache cache;
+//    AudioImageExtractor audio;
+    VideoScreenshotter video;
+    ImageScaler scaler;
+    MediaArtCache macache;
+    LastFMDownloader lfm;
+
+    ThumbnailerPrivate() {};
+
+    string create_thumbnail(const string &abspath, ThumbnailSize desired_size,
+            ThumbnailPolicy policy);
+    string create_random_filename();
+};
+
+
+string ThumbnailerPrivate::create_random_filename() {
+    string fname;
+    char *dirbase = getenv("TMPDIR"); // Set when in a confined application.
+    if(dirbase) {
+        fname = dirbase;
+    } else {
+        fname = "/tmp";
+    }
+    fname += "/thumbnailer.";
+    fname += to_string(rnd());
+    fname += ".tmp";
+    return fname;
+}
+
+string ThumbnailerPrivate::create_audio_thumbnail(const string &/*abspath*/,
+        ThumbnailSize /*desired_size*/, ThumbnailPolicy /*policy*/) {
+    // There was a symbol clash between 1.0 and 0.10 versions of
+    // GStreamer on the desktop so we need to disable in-process
+    // usage of gstreamer. Re-enable this once desktop moves to
+    // newer Qt multimedia that has GStreamer 1.0.
+/*
+    try {
+        if(audio.extract(abspath, tmpname)) {
+            extracted = true;
+        }
+    } catch(runtime_error &e) {
+    }
+    if(extracted) {
+        scaler.scale(tmpname, tnfile, desired_size, abspath); // If this throws, let it propagate.
+        unlink(tmpname.c_str());
+        return tnfile;
+    }
+    */
+    return "";
+}
+string ThumbnailerPrivate::create_generic_thumbnail(const string &abspath, ThumbnailSize desired_size) {
+    int tmpw, tmph;
+    string tnfile = cache.get_cache_file_name(abspath, desired_size);
+    // Special case: full size image files are their own preview.
+    if(desired_size == TN_SIZE_ORIGINAL &&
+       gdk_pixbuf_get_file_info(abspath.c_str(), &tmpw, &tmph)) {
+        return abspath;
+    }
+    try {
+        if(scaler.scale(abspath, tnfile, desired_size, abspath))
+            return tnfile;
+    } catch(runtime_error &e) {
+    }
+    return "";
+}
+
+string ThumbnailerPrivate::create_video_thumbnail(const string &abspath, ThumbnailSize desired_size) {
+    string tnfile = cache.get_cache_file_name(abspath, desired_size);
+    string tmpname = create_random_filename();
+    if(video.extract(abspath, tmpname)) {
+        scaler.scale(tmpname, tnfile, desired_size, abspath);
+        unlink(tmpname.c_str());
+        return tnfile;
+    }
+    throw runtime_error("Video extraction failed.");
+}
+
+string ThumbnailerPrivate::create_thumbnail(const string &abspath, ThumbnailSize desired_size,
+        ThumbnailPolicy policy) {
+    // Every now and then see if we have too much stuff and delete them if so.
+    if((rnd() % 100) == 0) { // No, this is not perfectly random. It does not need to be.
+        cache.prune();
+    }
+    std::unique_ptr<GFile, void(*)(void *)> file(
+            g_file_new_for_path(abspath.c_str()), g_object_unref);
+    if(!file) {
+        return "";
+    }
+
+    std::unique_ptr<GFileInfo, void(*)(void *)> info(
+            g_file_query_info(file.get(), G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+                G_FILE_QUERY_INFO_NONE, /* cancellable */ NULL, /* error */NULL),
+            g_object_unref);
+    if(!info) {
+        return "";
+    }
+
+    std::string content_type(g_file_info_get_content_type(info.get()));
+    if (content_type.empty()) {
+        return "";
+    }
+
+    if (content_type.find("audio/") == 0) {
+        return create_audio_thumbnail(abspath, desired_size, policy);
+    }
+
+    if (content_type.find("video/") == 0) {
+        return create_video_thumbnail(abspath, desired_size);
+    }
+
+    return create_generic_thumbnail(abspath, desired_size);
+}
+
+Thumbnailer::Thumbnailer() {
+    g_type_init(); // Unfortunately still needed in precise.
+    p = new ThumbnailerPrivate();
+}
+
+Thumbnailer::~Thumbnailer() {
+    delete p;
+}
+std::string Thumbnailer::get_thumbnail(const std::string &filename, ThumbnailSize desired_size,
+        ThumbnailPolicy policy) {
+    string abspath;
+    if(filename[0] != '/') {
+        abspath += getcwd(nullptr, 0);
+        abspath += "/" + filename;
+    } else {
+        abspath = filename;
+    }
+    std::string estimate = p->cache.get_if_exists(abspath, desired_size);
+    if(!estimate.empty())
+        return estimate;
+    string generated = p->create_thumbnail(abspath, desired_size, policy);
+    if(generated == abspath) {
+        return abspath;
+    }
+    return p->cache.get_if_exists(abspath, desired_size);
+}
+
+string Thumbnailer::get_thumbnail(const string &filename, ThumbnailSize desired_size) {
+    return get_thumbnail(filename, desired_size, TN_LOCAL);
+}
+
+std::string Thumbnailer::get_album_art(const std::string &artist, const std::string &album,
+        ThumbnailSize desired_size, ThumbnailPolicy policy) {
+    if(!p->macache.has_art(artist, album)) {
+        if(policy == TN_LOCAL) {
+            // We don't have it cached and can't access the net
+            // -> nothing to be done.
+            return "";
+        }
+        char filebuf[] = "/tmp/some/long/text/here/so/path/will/fit";
+        std::string tmpname = tmpnam(filebuf);
+        if(!p->lfm.download(artist, album, tmpname)) {
+            return "";
+        }
+        gchar *contents;
+        gsize content_size;
+        GError *err = nullptr;
+        if(!g_file_get_contents(tmpname.c_str(), &contents, &content_size, &err)) {
+            unlink(tmpname.c_str());
+            std::string msg("Error reading file: ");
+            msg += err->message;
+            g_error_free(err);
+            throw std::runtime_error(msg);
+        }
+        unlink(tmpname.c_str());
+        unique_ptr<gchar, void(*)(gpointer)> deleter(contents, g_free);
+        p->macache.add_art(artist, album, contents, content_size);
+    }
+    // At this point we know we have the image in our art cache (unless
+    // someone just deleted it concurrently, in which case we can't
+    // really do anything.
+    std::string original = p->macache.get_art_file(artist, album);
+    if(desired_size == TN_SIZE_ORIGINAL) {
+        return original;
+    }
+    return get_thumbnail(original, desired_size, policy);
+}

=== added file 'src/videoscreenshotter.cpp'
--- src/videoscreenshotter.cpp	1970-01-01 00:00:00 +0000
+++ src/videoscreenshotter.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/config.h>
+#include<internal/videoscreenshotter.h>
+
+#include<unistd.h>
+#include<sys/wait.h>
+#include<stdexcept>
+#include<cstring>
+#include<sys/time.h>
+#include<signal.h>
+#include<time.h>
+
+using namespace std;
+static double timestamp() {
+    struct timeval now;
+    gettimeofday(&now, NULL);
+    return now.tv_sec + now.tv_usec/1000000.0;
+
+}
+
+static bool wait_for_helper(pid_t child) {
+    const double max_wait_time = 10;
+    struct timespec sleep_time;
+    double start = timestamp();
+    sleep_time.tv_sec = 0;
+    sleep_time.tv_nsec = 100000000;
+    int status;
+    while(waitpid(child, &status, WNOHANG) == 0) {
+        struct timespec dummy;
+        double now = timestamp();
+        if(now - start >= max_wait_time) {
+            if(kill(child, SIGKILL) < 0) {
+                string msg("Could not kill child process: ");
+                msg += strerror(errno);
+                throw runtime_error(msg);
+            }
+            waitpid(child, &status, 0);
+            throw runtime_error("Helper process took too long.");
+        }
+        nanosleep(&sleep_time, &dummy);
+    }
+    if(status < 0) {
+        throw runtime_error("Waiting for child process failed.");
+    }
+    if(status == 0) {
+        return true;
+    }
+    if(status == 1) {
+        return false;
+    }
+    if(status == 2) {
+        throw runtime_error("Video extractor pipeline failed");
+    }
+    throw runtime_error("Unknown error when trying to extract video screenshot.");
+}
+
+VideoScreenshotter::VideoScreenshotter() {
+}
+
+VideoScreenshotter::~VideoScreenshotter() {
+}
+
+bool VideoScreenshotter::extract(const std::string &ifname, const std::string &ofname) {
+    // Gstreamer video pipelines are unstable so we need to run an
+    // external helper library.
+    string exe_path;
+    char *utildir = getenv("TN_UTILDIR");
+    exe_path = utildir ? utildir : SHARE_PRIV_ABS;
+    string cmd(exe_path + "/vs-thumb");
+    pid_t child = fork();
+    if(child == -1) {
+        throw runtime_error("Could not spawn worker process.");
+    }
+    if(child  == 0) {
+        execl(cmd.c_str(), cmd.c_str(), ifname.c_str(), ofname.c_str(), (char*) NULL);
+        fprintf(stderr, "Could not execute worker process: %s", strerror(errno));
+        _exit(100);
+    } else {
+        try {
+            return wait_for_helper(child);
+        } catch(...) {
+            unlink(ofname.c_str());
+            throw;
+        }
+    }
+    throw runtime_error("Code that should not have been reached was reached.");
+}
+

=== added file 'src/vs-thumb.cpp'
--- src/vs-thumb.cpp	1970-01-01 00:00:00 +0000
+++ src/vs-thumb.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/gobj_memory.h>
+#include<cstdio>
+#include<memory>
+#include<stdexcept>
+#include<gst/gst.h>
+#include<gst/app/gstappsink.h>
+#include<gdk-pixbuf/gdk-pixbuf.h>
+
+using namespace std;
+
+bool extract(const std::string &ifname, const std::string &ofname) {
+    string caps_string = "video/x-raw,format=RGB,pixel-aspect-ratio=1/1";
+    GstElement *sink;
+    gint64 duration, seek_point;
+    string pipe_cmd = "filesrc location=\"";
+    pipe_cmd += ifname;
+    pipe_cmd += "\" ! decodebin ! videoconvert ! videoscale !";
+    pipe_cmd += "appsink name=sink caps=\"";
+    pipe_cmd += caps_string;
+    pipe_cmd += "\"";
+
+    unique_ptr<GstElement, void(*)(GstElement *t)> pipeline(
+            gst_parse_launch(pipe_cmd.c_str(), nullptr),
+            [](GstElement *t){ gst_object_unref(t);});
+    sink = gst_bin_get_by_name(GST_BIN(pipeline.get()), "sink");
+
+    GstStateChangeReturn ret = gst_element_set_state(pipeline.get(), GST_STATE_PAUSED);
+    switch (ret) {
+        case GST_STATE_CHANGE_FAILURE:
+            throw runtime_error("Fail to start thumbnail pipeline.");
+        case GST_STATE_CHANGE_NO_PREROLL:
+            throw runtime_error("Thumbnail not supported for live sources.");
+        default:
+            break;
+    }
+    // Need to preroll in order to get duration.
+    ret = gst_element_get_state(pipeline.get(), nullptr, nullptr, 3*GST_SECOND);
+    if(ret == GST_STATE_CHANGE_FAILURE) {
+      throw runtime_error("Failed to preroll.");
+    } else if(ret == GST_STATE_CHANGE_ASYNC) {
+        fprintf(stderr, "Problem prerolling, trying to continue anyway.\n");
+    }
+    if(!gst_element_query_duration(pipeline.get(), GST_FORMAT_TIME, &duration)) {
+        fprintf(stderr, "Media backend does not implement query_duration, using fallback time.\n");
+        seek_point = 10*GST_SECOND;
+    } else {
+        seek_point = 2*duration/7;
+    }
+    gst_element_seek_simple(pipeline.get(),
+                            GST_FORMAT_TIME,
+                            static_cast<GstSeekFlags>(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT),
+                            seek_point);
+    GstSample *sample = nullptr;
+    sample = gst_app_sink_pull_preroll(GST_APP_SINK(sink));
+    if(sample == nullptr || !GST_IS_SAMPLE(sample)) {
+        throw runtime_error("Could not create sample. Unsupported or invalid file type?");
+    }
+    GstCaps *caps = gst_sample_get_caps(sample);
+
+    GstBuffer *buf = gst_sample_get_buffer(sample);
+    if (sample) {
+        gint width, height;
+        GstStructure *s = gst_caps_get_structure(caps, 0);
+        gboolean res = gst_structure_get_int(s, "width", &width);
+        res |= gst_structure_get_int (s, "height", &height);
+        if (!res) {
+            throw runtime_error("could not determine snapshot dimension.");
+        }
+        GstMapInfo mi;
+        gst_buffer_map(buf, &mi, GST_MAP_READ);
+        unique_gobj<GdkPixbuf> img(
+                gdk_pixbuf_new_from_data(mi.data, GDK_COLORSPACE_RGB,
+                        false, 8, width, height,
+                        (((width * 3)+3)&~3),
+                        nullptr, nullptr));
+        gst_buffer_unmap(buf, &mi);
+        GError *err = nullptr;
+        if(!gdk_pixbuf_save(img.get(), ofname.c_str(), "jpeg", &err, NULL)) {
+            string msg = err->message;
+            g_error_free(err);
+            throw runtime_error(msg);
+        }
+    } else {
+      throw runtime_error("Pipeline failed.");
+    }
+
+    gst_element_set_state(pipeline.get(), GST_STATE_NULL);
+    return true;
+}
+
+int main(int argc, char **argv) {
+    gst_init(&argc, &argv);
+    if(argc != 3) {
+        printf("%s <source file> <output file>\n", argv[0]);
+        return 1;
+    }
+    string infile(argv[1]);
+    string outfile(argv[2]);
+    bool success;
+    try {
+        success = extract(infile, outfile);
+    } catch(runtime_error &e) {
+        return 2;
+    }
+    if(success) {
+        return 0;
+    }
+    return 1;
+}

=== added directory 'tests'
=== renamed directory 'tests' => 'tests.moved'
=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,41 @@
+if (NOT DEFINED GTEST_ROOT)
+    set(GTEST_ROOT /usr/src/gtest)
+endif()
+
+set(GTEST_SRC_DIR "${GTEST_ROOT}/src")
+set(GTEST_INCLUDE_DIR ${GTEST_ROOT})
+
+add_library(gtest STATIC
+${GTEST_SRC_DIR}/gtest-all.cc
+)
+set_target_properties(gtest PROPERTIES INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR})
+target_link_libraries(gtest ${CMAKE_THREAD_LIBS_INIT})
+
+set(TESTDATADIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+configure_file(testsetup.h.in testsetup.h @ONLY)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+add_executable(basic basic.cpp)
+target_link_libraries(basic thumbnailer gtest)
+add_test(basic basic)
+set_property(TEST basic PROPERTY ENVIRONMENT "XDG_CACHE_HOME=${CMAKE_CURRENT_BINARY_DIR}")
+set_property(TEST basic APPEND PROPERTY ENVIRONMENT "TN_UTILDIR=${CMAKE_BINARY_DIR}/src")
+
+add_executable(mediaartcachetest mediaartcachetest.cpp ../src/mediaartcache.cpp)
+target_link_libraries(mediaartcachetest ${GIO_DEPS_LDFLAGS} gtest)
+add_test(mediaartcache mediaartcachetest)
+set_property(TEST mediaartcache PROPERTY ENVIRONMENT "XDG_CACHE_HOME=${CMAKE_CURRENT_BINARY_DIR}")
+
+add_executable(downloadtest download.cpp ../src/lastfmdownloader.cpp ../src/soupdownloader.cpp)
+target_link_libraries(downloadtest ${XML_DEPS_LDFLAGS} ${SOUP_DEPS_LDFLAGS} gtest)
+add_test(downloadtest downloadtest)
+
+# This is only needed here because GStreamer brings in gobject.
+pkg_check_modules(GOBJ_DEPS REQUIRED gobject-2.0)
+
+include_directories(${GOBJ_DEPS_INCLUDE_DIRS})
+
+add_executable(unique_gobj unique_gobj.cpp)
+target_link_libraries(unique_gobj ${GOBJ_DEPS_LDFLAGS} ${IMG_DEPS_LDFLAGS} gtest)
+add_test(unique_gobj unique_gobj)

=== added file 'tests/basic.cpp'
--- tests/basic.cpp	1970-01-01 00:00:00 +0000
+++ tests/basic.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<thumbnailer.h>
+#include<testsetup.h>
+#include<gtest/gtest.h>
+#include<unistd.h>
+#include<gdk-pixbuf/gdk-pixbuf.h>
+
+#define TESTIMAGE TESTDATADIR "/testimage.jpg"
+#define ROTTESTIMAGE TESTDATADIR "/testrotate.jpg"
+#define TESTVIDEO TESTDATADIR "/testvideo.ogg"
+
+using namespace std;
+
+bool file_exists(const string &s) {
+    FILE *f = fopen(s.c_str(), "r");
+    if(f) {
+        fclose(f);
+        return true;
+    }
+    return false;
+}
+
+void copy_file(const string &src, const string &dst) {
+    FILE* f = fopen(src.c_str(), "r");
+    ASSERT_TRUE(f);
+    fseek(f, 0, SEEK_END);
+    size_t size = ftell(f);
+
+    char* buf = new char[size];
+
+    fseek(f, 0, SEEK_SET);
+    ASSERT_EQ(fread(buf, 1, size, f), size);
+    fclose(f);
+
+    f = fopen(dst.c_str(), "w");
+    ASSERT_TRUE(f);
+    ASSERT_EQ(fwrite(buf, 1, size, f), size);
+    fclose(f);
+    delete[] buf;
+}
+
+TEST(Thumbnailer, trivial) {
+    Thumbnailer tn;
+}
+
+static void file_test(Thumbnailer &tn, string &ifile) {
+    int w, h;
+    ASSERT_TRUE(file_exists(ifile));
+    string thumbfile = tn.get_thumbnail(ifile, TN_SIZE_SMALL, TN_LOCAL);
+    unlink(thumbfile.c_str());
+    ASSERT_FALSE(file_exists(thumbfile));
+    string thumbfile2 = tn.get_thumbnail(ifile, TN_SIZE_SMALL, TN_LOCAL);
+    ASSERT_EQ(thumbfile, thumbfile2);
+    ASSERT_TRUE(file_exists(thumbfile));
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(thumbfile.c_str(), &w, &h));
+    ASSERT_LE(w, 128);
+    ASSERT_LE(h, 128);
+}
+
+TEST(Thumbnailer, image) {
+    Thumbnailer tn;
+    string imfile(TESTIMAGE);
+    file_test(tn, imfile);
+}
+
+TEST(Thumbnailer, video) {
+    Thumbnailer tn;
+    string videofile(TESTVIDEO);
+    file_test(tn, videofile);
+}
+
+TEST(Thumbnailer, rotate) {
+    Thumbnailer tn;
+    string imfile(ROTTESTIMAGE);
+    int w, h;
+    ASSERT_TRUE(file_exists(imfile));
+    string thumbfile = tn.get_thumbnail(imfile, TN_SIZE_LARGE);
+    unlink(thumbfile.c_str());
+    ASSERT_FALSE(file_exists(thumbfile));
+    string thumbfile2 = tn.get_thumbnail(imfile, TN_SIZE_LARGE);
+    ASSERT_EQ(thumbfile, thumbfile2);
+    ASSERT_TRUE(file_exists(thumbfile));
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(imfile.c_str(), &w, &h));
+    ASSERT_GT(w, h); // gdk_pixbuf does not reorient images automatically.
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(thumbfile.c_str(), &w, &h));
+    ASSERT_GT(h, w); // Has the orientation been straightened during scaling?
+}
+
+
+TEST(Thumbnailer, video_original) {
+    Thumbnailer tn;
+    int w, h;
+    string videofile(TESTVIDEO);
+    string origsize = tn.get_thumbnail(videofile, TN_SIZE_ORIGINAL);
+    ASSERT_TRUE(file_exists(origsize));
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(origsize.c_str(), &w, &h));
+    ASSERT_EQ(w, 1920);
+    ASSERT_EQ(h, 1080);
+}
+
+
+TEST(Thumbnailer, size) {
+    Thumbnailer tn;
+    int w, h;
+    string imfile(TESTIMAGE);
+    string thumbfile = tn.get_thumbnail(imfile, TN_SIZE_SMALL);
+    string thumbfile2 = tn.get_thumbnail(imfile, TN_SIZE_LARGE);
+    string thumbfile3 = tn.get_thumbnail(imfile, TN_SIZE_XLARGE);
+    ASSERT_FALSE(thumbfile.empty());
+    ASSERT_FALSE(thumbfile2.empty());
+    ASSERT_FALSE(thumbfile3.empty());
+    ASSERT_NE(thumbfile, thumbfile2);
+    ASSERT_NE(thumbfile, thumbfile3);
+    ASSERT_NE(thumbfile2, thumbfile3);
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(thumbfile.c_str(), &w, &h));
+    ASSERT_EQ(w, 128);
+    ASSERT_LE(h, 128);
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(thumbfile2.c_str(), &w, &h));
+    ASSERT_EQ(w, 256);
+    ASSERT_LE(h, 256);
+    ASSERT_TRUE(gdk_pixbuf_get_file_info(thumbfile3.c_str(), &w, &h));
+    ASSERT_EQ(w, 512);
+    ASSERT_LE(h, 512);
+}
+
+TEST(Thumbnailer, deletetest) {
+    Thumbnailer tn;
+    string srcimg(TESTIMAGE);
+    string workimage("working_image.jpg");
+    copy_file(srcimg, workimage);
+    ASSERT_TRUE(file_exists(workimage));
+    string thumbfile = tn.get_thumbnail(workimage, TN_SIZE_SMALL);
+    string thumbfile2 = tn.get_thumbnail(workimage, TN_SIZE_LARGE);
+    string thumbfile3 = tn.get_thumbnail(workimage, TN_SIZE_XLARGE);
+    ASSERT_TRUE(file_exists(thumbfile));
+    ASSERT_TRUE(file_exists(thumbfile2));
+    ASSERT_TRUE(file_exists(thumbfile3));
+    unlink(workimage.c_str());
+    string tmp = tn.get_thumbnail(workimage, TN_SIZE_SMALL);
+    ASSERT_TRUE(tmp.empty());
+    ASSERT_FALSE(file_exists(thumbfile));
+    ASSERT_FALSE(file_exists(thumbfile2));
+    ASSERT_FALSE(file_exists(thumbfile3));
+}
+
+TEST(Thumbnailer, no_image_cache) {
+    Thumbnailer tn;
+    string srcimg(TESTIMAGE);
+    string dstimg = tn.get_thumbnail(srcimg, TN_SIZE_ORIGINAL);
+    ASSERT_EQ(srcimg, dstimg);
+}
+
+TEST(Thumbnailer, album_art) {
+    // During test suite run we may not have access to the net.
+    // So just test calling to ensure symbol visibility etc work.
+    Thumbnailer tn;
+    string artist("The Prodigy");
+    string album("Music for the Jilted Generation");
+    tn.get_album_art(artist, album, TN_SIZE_ORIGINAL, TN_LOCAL);
+}
+
+int main(int argc, char **argv) {
+    g_type_init(); // Still needed in precise.
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

=== added file 'tests/download.cpp'
--- tests/download.cpp	1970-01-01 00:00:00 +0000
+++ tests/download.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<gtest/gtest.h>
+#include<internal/lastfmdownloader.h>
+#include<cstdio>
+#include<unistd.h>
+#include<mutex>
+#include<condition_variable>
+#include<thread>
+
+using namespace std;
+
+const char *testimage = "abc";
+
+class FakeDownloader : public HttpDownloader {
+private:
+    constexpr static const char *imloc = "http://dummy";
+    constexpr static const char *xml = "<album><coverart><large>http://dummy</large></coverart></album>";
+
+public:
+    std::string download(const std::string &url) override {
+        if(url.find("audioscrobbler") != std::string::npos) {
+            return xml;
+        }
+        if(url == imloc) {
+            return testimage;
+        }
+        throw std::runtime_error("Tried to get unknown data from FakeDownloader.");
+    }
+};
+
+TEST(Downloader, canned) {
+    LastFMDownloader lfdl(new FakeDownloader());
+    string artist("Some guy");
+    string album("Some album");
+    string outfile("/tmp/temptestfile");
+    unlink(outfile.c_str());
+    ASSERT_TRUE(lfdl.download(artist, album, outfile));
+    char output[4];
+    FILE *f = fopen(outfile.c_str(), "r");
+    ASSERT_TRUE(f);
+    ASSERT_EQ(fread(output, 1, 3, f), 3);
+    output[3] = '\0';
+    fclose(f);
+    unlink(outfile.c_str());
+    string s1(testimage);
+    string s2(output);
+    ASSERT_EQ(s1, s2);
+}
+
+static std::mutex m;
+static std::condition_variable cv;
+static bool go = false;
+
+static void query_thread(LastFMDownloader *lfdl, int num) {
+    string fname("/tmp/tmpfile");
+    string artist("Some guy");
+    string album("Some album");
+    artist += num;
+    album += num;
+    fname += num;
+    {
+        std::unique_lock<std::mutex> lk(m);
+        cv.wait(lk, []{return go;});
+    }
+    for(int i=0; i<10; i++) {
+        unlink(fname.c_str());
+        ASSERT_TRUE(lfdl->download(artist, album, fname));
+    }
+    unlink(fname.c_str());
+}
+
+TEST(Downloader, threads) {
+    LastFMDownloader lfdl(new FakeDownloader());
+    vector<std::thread> workers;
+    for(int i=0; i<10; i++) {
+        workers.emplace_back(query_thread, &lfdl, i);
+    }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    {
+        std::lock_guard<std::mutex> g(m);
+        go = true;
+    }
+    cv.notify_all();
+    for(auto &i : workers) {
+        i.join();
+    }
+}
+
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

=== added file 'tests/mediaartcachetest.cpp'
--- tests/mediaartcachetest.cpp	1970-01-01 00:00:00 +0000
+++ tests/mediaartcachetest.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2013-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<sys/types.h>
+#include<string.h>
+#include<stdio.h>
+#include<dirent.h>
+
+#include<string>
+#include <gtest/gtest.h>
+
+#include "../include/internal/mediaartcache.h"
+
+using namespace std;
+
+namespace mediascanner {
+
+TEST(MediaArtCacheTest, BasicFunctionality) {
+    MediaArtCache mac;
+    mac.clear();
+    string artist = "Some Guy";
+    string album = "Muzak";
+    const int datasize = 3;
+    char data[datasize] = {'a', 'b', 'c'};
+    char indata[datasize];
+    FILE *f;
+
+    ASSERT_FALSE(mac.has_art(artist, album));
+    mac.add_art(artist, album, data, datasize);
+    ASSERT_TRUE(mac.has_art(artist, album));
+    f = fopen(mac.get_art_file(artist, album).c_str(), "r");
+    ASSERT_TRUE(f);
+    ASSERT_EQ(fread(indata, 1, datasize, f), datasize);
+    fclose(f);
+    ASSERT_EQ(memcmp(indata, data, datasize), 0);
+
+    mac.clear();
+    assert(!mac.has_art(artist, album));
+}
+
+TEST(MediaArtCacheTest, Swapped) {
+    string artist1("foo");
+    string album1("bar");
+    string artist2(album1);
+    string album2(artist1);
+    const int datasize = 4;
+    char data1[datasize] = {'a', 'b', 'c', 'd'};
+    char data2[datasize] = {'d', 'c', 'b', 'e'};
+    char indata[datasize];
+    MediaArtCache mac;
+    FILE *f;
+    mac.clear();
+
+    ASSERT_FALSE(mac.has_art(artist1, album1));
+    ASSERT_FALSE(mac.has_art(artist2, album2));
+
+    mac.add_art(artist1, album1, data1, datasize);
+    ASSERT_TRUE(mac.has_art(artist1, album1));
+    ASSERT_FALSE(mac.has_art(artist2, album2));
+
+    mac.clear();
+
+    mac.add_art(artist2, album2, data2, datasize);
+    ASSERT_FALSE(mac.has_art(artist1, album1));
+    ASSERT_TRUE(mac.has_art(artist2, album2));
+
+    mac.add_art(artist1, album1, data1, datasize);
+
+    f = fopen(mac.get_art_file(artist1, album1).c_str(), "r");
+    ASSERT_TRUE(f);
+    ASSERT_EQ(fread(indata, 1, datasize, f), datasize);
+    fclose(f);
+    ASSERT_EQ(memcmp(indata, data1, datasize), 0);
+
+    f = fopen(mac.get_art_file(artist2, album2).c_str(), "r");
+    ASSERT_TRUE(f);
+    ASSERT_EQ(fread(indata, 1, datasize, f), datasize);
+    fclose(f);
+    ASSERT_EQ(memcmp(indata, data2, datasize), 0);
+}
+
+static int count_files(const string &dir) {
+    DIR *d = opendir(dir.c_str());
+    int count = 0;
+    if(!d) {
+        string s = "Something went wrong.";
+        throw s;
+    }
+    struct dirent *entry, *de;
+    entry = (dirent*)malloc(sizeof(dirent) + NAME_MAX);
+    while(readdir_r(d, entry, &de) == 0 && de) {
+        string basename = entry->d_name;
+        if (basename == "." || basename == "..")
+            continue;
+        count++;
+    }
+    closedir(d);
+    free(entry);
+    return count;
+}
+
+TEST(MediaArtCacheTest, Prune) {
+    MediaArtCache mac;
+    mac.clear();
+    const int max_files = MediaArtCache::MAX_SIZE;
+    string cache_dir = mac.get_cache_dir();
+    char arr[] = {'a', 'b', 'c'};
+    ASSERT_EQ(count_files(cache_dir), 0);
+    for(int i=0; i<max_files+5; i++) {
+        string tmpname = cache_dir + "/" + to_string(i) + ".jpg";
+        FILE *f = fopen(tmpname.c_str(), "w");
+        if (!f) {
+            string error("Could not create file ");
+            error += tmpname;
+            throw error;
+        }
+        fwrite(arr, 1, 3, f);
+        fflush(f);
+        fclose(f);
+    }
+    ASSERT_GT(count_files(cache_dir), max_files);
+    mac.prune();
+    int numfiles = count_files(cache_dir);
+    ASSERT_GT(numfiles, 0);
+    ASSERT_LE(numfiles, max_files);
+    mac.prune();
+    ASSERT_EQ(numfiles, count_files(cache_dir));
+}
+
+}
+
+int main(int argc, char *argv[]) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

=== added directory 'tests/qml'
=== added file 'tests/qml/tst_image_provider.qml'
--- tests/qml/tst_image_provider.qml	1970-01-01 00:00:00 +0000
+++ tests/qml/tst_image_provider.qml	2015-02-04 08:57:20 +0000
@@ -0,0 +1,62 @@
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.Thumbnailer 0.1
+
+Item {
+    Image {
+        id: image
+        width: 200
+        height: 200
+
+        SignalSpy {
+            id: spy
+            target: image
+            signalName: "statusChanged"
+        }
+    }
+
+    Canvas {
+        id: canvas
+        width: 200
+        height: 200
+        renderStrategy: Canvas.Immediate
+        renderTarget: Canvas.Image
+    }
+
+    TestCase {
+        name: "ThumbnailerProviderTests"
+        when: windowShown
+
+        function test_albumart() {
+            var ctx = loadImage(
+                "image://albumart/artist=Gotye&album=Making%20Mirrors");
+            comparePixel(ctx, 0, 0, 242, 228, 209, 255);
+        }
+
+        function loadImage(uri) {
+            image.source = uri
+            while (image.status == Image.Loading) {
+                spy.wait();
+            }
+            compare(image.status, Image.Ready);
+
+            var ctx = canvas.getContext("2d");
+            ctx.drawImage(image, 0, 0);
+            return ctx;
+        }
+
+        function comparePixel(ctx,x,y,r,g,b,a, d) {
+            var c = ctx.getImageData(x,y,1,1).data;
+            if (d === undefined)
+                d = 0;
+            r = Math.round(r);
+            g = Math.round(g);
+            b = Math.round(b);
+            a = Math.round(a);
+            var notSame = Math.abs(c[0]-r)>d || Math.abs(c[1]-g)>d || Math.abs(c[2]-b)>d || Math.abs(c[3]-a)>d;
+            if (notSame)
+                qtest_fail('Pixel compare fail:\nactual :[' + c[0]+','+c[1]+','+c[2]+','+c[3] + ']\nexpected:['+r+','+g+','+b+','+a+'] +/- '+d, 1);
+
+        }
+    }
+}

=== added file 'tests/testimage.jpg'
Binary files tests/testimage.jpg	1970-01-01 00:00:00 +0000 and tests/testimage.jpg	2015-02-04 08:57:20 +0000 differ
=== added file 'tests/testrotate.jpg'
Binary files tests/testrotate.jpg	1970-01-01 00:00:00 +0000 and tests/testrotate.jpg	2015-02-04 08:57:20 +0000 differ
=== added file 'tests/testsetup.h.in'
--- tests/testsetup.h.in	1970-01-01 00:00:00 +0000
+++ tests/testsetup.h.in	2015-02-04 08:57:20 +0000
@@ -0,0 +1,6 @@
+#ifndef TESTSETUP_H
+#define TESTSETUP_H
+
+#define TESTDATADIR "@TESTDATADIR@"
+
+#endif

=== added file 'tests/testvideo.ogg'
Binary files tests/testvideo.ogg	1970-01-01 00:00:00 +0000 and tests/testvideo.ogg	2015-02-04 08:57:20 +0000 differ
=== added file 'tests/unique_gobj.cpp'
--- tests/unique_gobj.cpp	1970-01-01 00:00:00 +0000
+++ tests/unique_gobj.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/gobj_memory.h>
+#include<gdk-pixbuf/gdk-pixbuf.h>
+#include<gtest/gtest.h>
+
+using namespace std;
+
+TEST(Unique_gobj, trivial) {
+    unique_gobj<GdkPixbuf> basic(gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480));
+    ASSERT_TRUE(bool(basic));
+    ASSERT_TRUE(gdk_pixbuf_get_width(basic.get()) == 640);
+    ASSERT_TRUE(gdk_pixbuf_get_height(basic.get()) == 480);
+}
+
+TEST(Unique_gobj, compare) {
+    GdkPixbuf *pb1 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    GdkPixbuf *pb2 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    if(pb1 > pb2) {
+        std::swap(pb1, pb2);
+    }
+    ASSERT_TRUE(pb1 < pb2);
+    unique_gobj<GdkPixbuf> u1(pb1);
+    unique_gobj<GdkPixbuf> u2(pb2);
+
+    ASSERT_TRUE(!(u1 == nullptr));
+    ASSERT_TRUE(u1 != nullptr);
+    ASSERT_TRUE(u1 != u2);
+    ASSERT_TRUE(!(u1 == u2));
+    ASSERT_TRUE(u1 < u2);
+    ASSERT_TRUE(!(u2 < u1));
+    ASSERT_TRUE(!(u1 == u2));
+    ASSERT_TRUE(!(u2 == u1));
+    ASSERT_TRUE(u1 <= u2);
+    ASSERT_TRUE(!(u2 <= u1));
+}
+
+// This is its own thing due to need to avoid double release.
+
+TEST(Unique_gobj, equality) {
+    GdkPixbuf *pb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    unique_gobj<GdkPixbuf> u1(pb);
+    g_object_ref(G_OBJECT(pb));
+    unique_gobj<GdkPixbuf> u2(pb);
+    ASSERT_TRUE(u1 == u2);
+    ASSERT_TRUE(u2 == u1);
+    ASSERT_TRUE(!(u1 != u2));
+    ASSERT_TRUE(!(u2 != u1));
+}
+
+TEST(Unique_gobj, release) {
+    GdkPixbuf *pb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    unique_gobj<GdkPixbuf> u(pb);
+    ASSERT_TRUE(u != nullptr);
+    ASSERT_TRUE(u.get() != nullptr);
+    ASSERT_TRUE(pb == u.release());
+    ASSERT_TRUE(!u);
+    ASSERT_TRUE(u.get() == nullptr);
+    g_object_unref(pb);
+}
+
+void sub_func(GdkPixbuf *pb) {
+    ASSERT_TRUE(G_OBJECT(pb)->ref_count == 2);
+    unique_gobj<GdkPixbuf> u(pb);
+    ASSERT_TRUE(G_OBJECT(pb)->ref_count == 2);
+    // Now it dies and refcount is reduced.
+}
+
+TEST(Unique_gobj, refcount) {
+    GdkPixbuf *pb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    ASSERT_TRUE(G_OBJECT(pb)->ref_count == 1);
+    g_object_ref(G_OBJECT(pb));
+    sub_func(pb);
+    ASSERT_TRUE(G_OBJECT(pb)->ref_count == 1);
+    g_object_unref(G_OBJECT(pb));
+}
+
+TEST(Unique_gobj, swap) {
+    GdkPixbuf *pb1 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    GdkPixbuf *pb2 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    unique_gobj<GdkPixbuf> u1(pb1);
+    unique_gobj<GdkPixbuf> u2(pb2);
+
+    u1.swap(u2);
+    ASSERT_TRUE(u1.get() == pb2);
+    ASSERT_TRUE(u2.get() == pb1);
+
+    std::swap(u1, u2);
+    ASSERT_TRUE(u1.get() == pb1);
+    ASSERT_TRUE(u2.get() == pb2);
+}
+
+TEST(Unique_gobj, floating) {
+    GdkPixbuf *pb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    bool got_exception = false;
+    g_object_force_floating(G_OBJECT(pb));
+    try {
+        unique_gobj<GdkPixbuf> u(pb);
+    } catch(const invalid_argument &c) {
+        got_exception = true;
+    }
+    g_object_unref(G_OBJECT(pb));
+    ASSERT_TRUE(got_exception);
+}
+
+TEST(Unique_gobj, move) {
+    GdkPixbuf *pb1 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    GdkPixbuf *pb2 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    g_object_ref(G_OBJECT(pb1));
+    unique_gobj<GdkPixbuf> u1(pb1);
+    unique_gobj<GdkPixbuf> u2(pb2);
+    u1 = std::move(u2);
+    ASSERT_TRUE(u1.get() == pb2);
+    ASSERT_TRUE(!u2);
+    ASSERT_TRUE(G_OBJECT(pb1)->ref_count == 1);
+    g_object_unref(G_OBJECT(pb1));
+}
+
+TEST(Unique_gobj, null) {
+    GdkPixbuf *pb1 = NULL;
+    GdkPixbuf *pb3 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    unique_gobj<GdkPixbuf> u1(pb1);
+    unique_gobj<GdkPixbuf> u2(nullptr);
+    unique_gobj<GdkPixbuf> u3(pb3);
+
+    ASSERT_TRUE(!u1);
+    ASSERT_TRUE(!u2);
+    u3 = nullptr;
+    ASSERT_TRUE(!u3);
+}
+
+TEST(Unique_gobj, reset) {
+    GdkPixbuf *pb1 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    GdkPixbuf *pb2 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 640, 480);
+    unique_gobj<GdkPixbuf> u(pb1);
+
+    u.reset(pb2);
+    ASSERT_TRUE(u.get() == pb2);
+    u.reset(nullptr);
+    ASSERT_TRUE(!u);
+}
+
+TEST(Unique_gobj, sizeoftest) {
+    ASSERT_TRUE(sizeof(GdkPixbuf*) == sizeof(unique_gobj<GdkPixbuf>));
+}
+
+TEST(Unique_gobj, deleter) {
+    unique_gobj<GdkPixbuf> u1;
+    ASSERT_TRUE(u1.get_deleter() == g_object_unref);
+}
+
+int main(int argc, char **argv) {
+    g_type_init(); // Still needed in precise.
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

=== added directory 'tools'
=== renamed directory 'tools' => 'tools.moved'
=== added file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tools/CMakeLists.txt	2015-02-04 08:57:20 +0000
@@ -0,0 +1,11 @@
+#add_executable(imdump imdump.cpp)
+#target_link_libraries(imdump thumbnailer ${GST_DEPS_LDFLAGS})
+
+add_executable(scaler scaler.cpp ../src/imagescaler.cpp)
+target_link_libraries(scaler ${IMG_DEPS_LDFLAGS})
+
+add_executable(cachetool cachetool.cpp)
+target_link_libraries(cachetool thumbnailer)
+
+add_executable(lastfmtest lastfmtest.cpp ../src/lastfmdownloader.cpp ../src/soupdownloader.cpp)
+target_link_libraries(lastfmtest ${SOUP_DEPS_LDFLAGS} ${XML_DEPS_LDFLAGS})

=== added file 'tools/cachetool.cpp'
--- tools/cachetool.cpp	1970-01-01 00:00:00 +0000
+++ tools/cachetool.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<thumbnailer.h>
+#include<cstdio>
+#include<gst/gst.h>
+#include<stdexcept>
+
+int main(int argc, char **argv) {
+    Thumbnailer t;
+    if(argc != 2) {
+        printf("%s <file name>\n", argv[0]);
+        return 1;
+    }
+    std::string ifilename(argv[1]);
+    std::string ofilename = t.get_thumbnail(ifilename, TN_SIZE_LARGE);
+    if(ofilename.empty())
+        printf("Thumbnail could not be generated.\n");
+    else
+        printf("Thumbnail file is %s.\n", ofilename.c_str());
+    return 0;
+}

=== added file 'tools/imdump.cpp'
--- tools/imdump.cpp	1970-01-01 00:00:00 +0000
+++ tools/imdump.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/audioimageextractor.h>
+#include<cstdio>
+#include<gst/gst.h>
+#include<stdexcept>
+
+int main(int argc, char **argv) {
+    gst_init(&argc, &argv);
+    AudioImageExtractor ae;
+    try {
+        ae.extract(argv[1], argv[2]);
+    } catch(std::runtime_error &e) {
+        printf("Failed: %s\n", e.what());
+        return 1;
+    }
+    return 0;
+}

=== added file 'tools/lastfmtest.cpp'
--- tools/lastfmtest.cpp	1970-01-01 00:00:00 +0000
+++ tools/lastfmtest.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<string>
+#include<cstdio>
+
+#include<internal/lastfmdownloader.h>
+#include<memory>
+
+using namespace std;
+
+int main(int /*argc*/, char **/*argv*/) {
+    LastFMDownloader dl;
+    dl.download("The Prodigy", "Music for the Jilted Generation", "image.jpg");
+    return 0;
+}

=== added file 'tools/scaler.cpp'
--- tools/scaler.cpp	1970-01-01 00:00:00 +0000
+++ tools/scaler.cpp	2015-02-04 08:57:20 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#include<internal/imagescaler.h>
+#include<cstdio>
+#include<gst/gst.h>
+#include<stdexcept>
+
+int main(int argc, char **argv) {
+    ImageScaler sc;
+    try {
+        std::string ifilename(argv[1]);
+        std::string ofilename(argv[2]);
+        sc.scale(ifilename, ofilename, TN_SIZE_LARGE, ifilename);
+    } catch(std::runtime_error &e) {
+        printf("Failed: %s\n", e.what());
+        return 1;
+    }
+    return 0;
+}