diff --git a/src/musicalbum.cpp b/src/musicalbum.cpp
index cd14361e..5b7a6c96 100644
--- a/src/musicalbum.cpp
+++ b/src/musicalbum.cpp
@@ -1,368 +1,368 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "musicalbum.h"
 
 #include <algorithm>
 
 #include <QList>
 #include <QString>
 #include <QUrl>
 #include <QMap>
 
 #include <QDebug>
 
 class MusicAlbumPrivate
 {
 public:
 
     qulonglong mDatabaseId = 0;
 
     QString mId;
 
     QString mParentId;
 
     QString mTitle;
 
     QString mArtist;
 
     QUrl mAlbumArtURI;
 
     QUrl mResourceURI;
 
     QList<MusicAudioTrack> mTracks;
 
     int mTracksCount = 0;
 
     bool mIsValid = false;
 
     bool mIsSingleDiscAlbum = true;
 
     QStringList mGenres;
 
 };
 
 MusicAlbum::MusicAlbum() : d(std::make_unique<MusicAlbumPrivate>())
 {
 }
 
 MusicAlbum::MusicAlbum(MusicAlbum &&other)
 {
     d.swap(other.d);
 }
 
 MusicAlbum::MusicAlbum(const MusicAlbum &other) : d(std::make_unique<MusicAlbumPrivate>(*other.d))
 {
 }
 
 MusicAlbum& MusicAlbum::operator=(MusicAlbum &&other)
 {
     if (&other != this) {
         d.reset();
         d.swap(other.d);
     }
 
     return *this;
 }
 
 MusicAlbum& MusicAlbum::operator=(const MusicAlbum &other)
 {
     if (&other != this) {
         (*d) = (*other.d);
     }
 
     return *this;
 }
 
 MusicAlbum::~MusicAlbum()
 = default;
 
 void MusicAlbum::setValid(bool value)
 {
     d->mIsValid = value;
 }
 
 bool MusicAlbum::isValid() const
 {
     return d->mIsValid;
 }
 
 void MusicAlbum::setDatabaseId(qulonglong value)
 {
     d->mDatabaseId = value;
 }
 
 qulonglong MusicAlbum::databaseId() const
 {
     return d->mDatabaseId;
 }
 
 void MusicAlbum::setId(const QString &value)
 {
     d->mId = value;
 }
 
 QString MusicAlbum::id() const
 {
     return d->mId;
 }
 
 void MusicAlbum::setParentId(const QString &value)
 {
     d->mParentId = value;
 }
 
 QString MusicAlbum::parentId() const
 {
     return d->mParentId;
 }
 
 void MusicAlbum::setTracksCount(int count)
 {
     d->mTracksCount = count;
 }
 
 int MusicAlbum::tracksCount() const
 {
     return d->mTracks.size();
 }
 
 void MusicAlbum::setTitle(const QString &value)
 {
     d->mTitle = value;
 }
 
 QString MusicAlbum::title() const
 {
     return d->mTitle;
 }
 
 void MusicAlbum::setArtist(const QString &value)
 {
     d->mArtist = value;
 }
 
 QString MusicAlbum::artist() const
 {
     QString result;
 
     if (!d->mArtist.isEmpty()) {
         result = d->mArtist;
     } else {
         QString possibleAlbumArtist;
         for (const auto &oneTrack : qAsConst(d->mTracks)) {
             if (oneTrack.isValidAlbumArtist()) {
                 result = oneTrack.albumArtist();
                 break;
             }
             if (possibleAlbumArtist.isEmpty()) {
                 possibleAlbumArtist = oneTrack.artist();
             } else {
                 if (possibleAlbumArtist != oneTrack.artist()) {
                     possibleAlbumArtist.clear();
                     break;
                 }
             }
         }
 
         if (result.isEmpty() && d->mTracks.size() > 1) {
             if (possibleAlbumArtist.isEmpty()) {
                 result = QStringLiteral("Various Artists");
             } else {
                 result = possibleAlbumArtist;
             }
         } else if (result.isEmpty() && d->mTracks.size() == 1) {
             result = d->mTracks.constFirst().albumArtist();
         }
     }
 
     return result;
 }
 
 void MusicAlbum::setAlbumArtURI(const QUrl &value)
 {
     d->mAlbumArtURI = value;
 }
 
 QUrl MusicAlbum::albumArtURI() const
 {
     return d->mAlbumArtURI;
 }
 
 void MusicAlbum::setResourceURI(const QUrl &value)
 {
     d->mResourceURI = value;
 }
 
 QUrl MusicAlbum::resourceURI() const
 {
     return d->mResourceURI;
 }
 
 void MusicAlbum::setIsSingleDiscAlbum(bool value)
 {
     d->mIsSingleDiscAlbum = value;
 }
 
 bool MusicAlbum::isSingleDiscAlbum() const
 {
     return d->mIsSingleDiscAlbum;
 }
 
 void MusicAlbum::setGenres(const QStringList &aGenres)
 {
     d->mGenres = aGenres;
 }
 
 QStringList MusicAlbum::genres() const
 {
     return d->mGenres;
 }
 
 void MusicAlbum::setTracks(const QList<MusicAudioTrack> &allTracks)
 {
     d->mTracks = allTracks;
 }
 
 const MusicAudioTrack& MusicAlbum::trackFromIndex(int index) const
 {
     return d->mTracks[index];
 }
 
 qulonglong MusicAlbum::trackIdFromIndex(int index) const
 {
     return d->mTracks[index].databaseId();
 }
 
 int MusicAlbum::trackIndexFromId(qulonglong id) const
 {
     int result = -1;
 
     for (result = 0; result < d->mTracks.size(); ++result) {
         if (d->mTracks[result].databaseId() == id) {
             return result;
         }
     }
 
     result = -1;
 
     return result;
 }
 
 QStringList MusicAlbum::allArtists() const
 {
     auto result = QList<QString>();
 
     result.reserve(d->mTracks.size());
 
     const auto &allTracks = d->mTracks;
     for (const auto &oneTrack : allTracks) {
         result.push_back(oneTrack.artist());
     }
 
     std::sort(result.begin(), result.end());
     result.erase(std::unique(result.begin(), result.end()), result.end());
 
     return result;
 }
 
 QStringList MusicAlbum::allTracksTitle() const
 {
     auto result = QList<QString>();
 
     result.reserve(d->mTracks.size());
 
     const auto &allTracks = d->mTracks;
     for (const auto &oneTrack : allTracks) {
         result.push_back(oneTrack.title());
     }
 
     std::sort(result.begin(), result.end());
     result.erase(std::unique(result.begin(), result.end()), result.end());
 
     return result;
 }
 
 bool MusicAlbum::isEmpty() const
 {
     return d->mTracks.isEmpty();
 }
 
 void MusicAlbum::removeTrackFromIndex(int index)
 {
     if (index < 0 || index >= tracksCount()) {
         return;
     }
 
     --d->mTracksCount;
     d->mTracks.removeAt(index);
 }
 
 void MusicAlbum::insertTrack(const MusicAudioTrack &newTrack, int index)
 {
     d->mTracks.insert(index, newTrack);
     ++d->mTracksCount;
 }
 
 void MusicAlbum::updateTrack(const MusicAudioTrack &modifiedTrack, int index)
 {
     d->mTracks[index] = modifiedTrack;
 }
 
-QDebug& operator<<(QDebug &stream, const MusicAlbum &data)
+ELISALIB_EXPORT QDebug operator<<(QDebug stream, const MusicAlbum &data)
 {
     stream << data.title() << " artist: " << data.artist() << " tracks: " << data.tracksCount();
 
     return stream;
 }
 
-bool operator==(const MusicAlbum &album1, const MusicAlbum &album2)
+ELISALIB_EXPORT bool operator==(const MusicAlbum &album1, const MusicAlbum &album2)
 {
     return album1.title() == album2.title() && (
             (album1.isValidArtist() && album2.isValidArtist() && album1.artist() == album2.artist()) ||
              !album1.isValidArtist() || !album2.isValidArtist());
 }
 
 int MusicAlbum::highestTrackRating() const
 {
     int result = 0;
 
     const auto &allTracks = d->mTracks;
     for (const auto &oneTrack : allTracks) {
         result = std::max(result, oneTrack.rating());
     }
 
     return result;
 }
 
 bool MusicAlbum::isValidArtist() const
 {
     return !d->mArtist.isEmpty();
 }
 
 bool MusicAlbum::canUpdateArtist(const MusicAudioTrack &currentTrack) const
 {
     bool result = false;
 
     if (currentTrack.isValidAlbumArtist() && currentTrack.albumArtist() != artist()) {
         result = true;
     }
 
     return result;
 }
diff --git a/src/musicalbum.h b/src/musicalbum.h
index 06f897b3..274c8bb3 100644
--- a/src/musicalbum.h
+++ b/src/musicalbum.h
@@ -1,137 +1,137 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef MUSICALBUM_H
 #define MUSICALBUM_H
 
 #include "elisaLib_export.h"
 
 #include "musicaudiotrack.h"
 
 #include <QString>
 #include <QUrl>
 #include <QMap>
 #include <QStringList>
 #include <QMetaType>
 
 #include <memory>
 
 class MusicAlbumPrivate;
 class QDebug;
 
 class ELISALIB_EXPORT MusicAlbum
 {
 
 public:
 
     MusicAlbum();
 
     MusicAlbum(MusicAlbum &&other);
 
     MusicAlbum(const MusicAlbum &other);
 
     MusicAlbum& operator=(MusicAlbum &&other);
 
     MusicAlbum& operator=(const MusicAlbum &other);
 
     ~MusicAlbum();
 
     void setValid(bool value);
 
     bool isValid() const;
 
     void setDatabaseId(qulonglong value);
 
     qulonglong databaseId() const;
 
     void setId(const QString &value);
 
     QString id() const;
 
     void setParentId(const QString &value);
 
     QString parentId() const;
 
     void setTracksCount(int count);
 
     int tracksCount() const;
 
     void setTitle(const QString &value);
 
     QString title() const;
 
     void setArtist(const QString &value);
 
     QString artist() const;
 
     bool isValidArtist() const;
 
     bool canUpdateArtist(const MusicAudioTrack &currentTrack) const;
 
     void setAlbumArtURI(const QUrl &value);
 
     QUrl albumArtURI() const;
 
     void setResourceURI(const QUrl &value);
 
     QUrl resourceURI() const;
 
     void setIsSingleDiscAlbum(bool value);
 
     bool isSingleDiscAlbum() const;
 
     void setGenres(const QStringList &aGenres);
 
     QStringList genres() const;
 
     void setTracks(const QList<MusicAudioTrack> &allTracks);
 
     const MusicAudioTrack &trackFromIndex(int index) const;
 
     qulonglong trackIdFromIndex(int index) const;
 
     int trackIndexFromId(qulonglong id) const;
 
     QStringList allArtists() const;
 
     QStringList allTracksTitle() const;
 
     bool isEmpty() const;
 
     void removeTrackFromIndex(int index);
 
     void insertTrack(const MusicAudioTrack &newTrack, int index);
 
     void updateTrack(const MusicAudioTrack &modifiedTrack, int index);
 
     int highestTrackRating() const;
 
 private:
 
     std::unique_ptr<MusicAlbumPrivate> d;
 
 };
 
-QDebug& operator<<(QDebug &stream, const MusicAlbum &data);
+ELISALIB_EXPORT QDebug operator<<(QDebug stream, const MusicAlbum &data);
 
-bool operator==(const MusicAlbum &album1, const MusicAlbum &album2);
+ELISALIB_EXPORT bool operator==(const MusicAlbum &album1, const MusicAlbum &album2);
 
 Q_DECLARE_METATYPE(MusicAlbum)
 
 #endif // MUSICALBUM_H
diff --git a/src/musicaudiotrack.cpp b/src/musicaudiotrack.cpp
index 883d45c5..f71b5e08 100644
--- a/src/musicaudiotrack.cpp
+++ b/src/musicaudiotrack.cpp
@@ -1,433 +1,433 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "musicaudiotrack.h"
 
 #include <QDateTime>
 #include <QDebug>
 #include <utility>
 
 class MusicAudioTrackPrivate
 {
 public:
 
     MusicAudioTrackPrivate() = default;
 
     MusicAudioTrackPrivate(bool aValid, QString aId, QString aParentId,
                            QString aTitle, QString aArtist, QString aAlbumName, QString aAlbumArtist,
                            int aTrackNumber, int aDiscNumber, QTime aDuration, QUrl aResourceURI,
                            const QDateTime &fileModificationTime, QUrl aAlbumCover, int rating,
                            bool aIsSingleDiscAlbum, QString aGenre, QString aComposer,
                            QString aLyricist)
         : mId(std::move(aId)), mParentId(std::move(aParentId)), mTitle(std::move(aTitle)), mArtist(std::move(aArtist)),
           mAlbumName(std::move(aAlbumName)), mAlbumArtist(std::move(aAlbumArtist)),
           mGenre(std::move(aGenre)), mComposer(std::move(aComposer)), mLyricist(std::move(aLyricist)),
           mResourceURI(std::move(aResourceURI)),
           mAlbumCover(std::move(aAlbumCover)), mDuration(aDuration),
           mFileModificationTime(fileModificationTime),
           mTrackNumber(aTrackNumber), mDiscNumber(aDiscNumber), mRating(rating),
           mIsValid(aValid), mIsSingleDiscAlbum(aIsSingleDiscAlbum)
     {
     }
 
     QString mId;
 
     QString mParentId;
 
     QString mTitle;
 
     QString mArtist;
 
     QString mAlbumName;
 
     QString mAlbumArtist;
 
     QString mGenre;
 
     QString mComposer;
 
     QString mLyricist;
 
     QString mComment;
 
     QUrl mResourceURI;
 
     QUrl mAlbumCover;
 
     qulonglong mDatabaseId = 0;
 
     QTime mDuration;
 
     QDateTime mFileModificationTime;
 
     int mTrackNumber = -1;
 
     int mDiscNumber = -1;
 
     int mChannels = -1;
 
     int mBitRate = -1;
 
     int mSampleRate = -1;
 
     int mYear = 0;
 
     int mRating = -1;
 
     bool mIsValid = false;
 
     bool mIsSingleDiscAlbum = true;
 
 };
 
 MusicAudioTrack::MusicAudioTrack() : d(std::make_unique<MusicAudioTrackPrivate>())
 {
 }
 
 MusicAudioTrack::MusicAudioTrack(bool aValid, QString aId, QString aParentId, QString aTitle, QString aArtist, QString aAlbumName,
                                  QString aAlbumArtist, int aTrackNumber, int aDiscNumber, QTime aDuration, QUrl aResourceURI,
                                  const QDateTime &fileModificationTime, QUrl aAlbumCover, int rating, bool aIsSingleDiscAlbum,
                                  QString aGenre, QString aComposer, QString aLyricist)
     : d(std::make_unique<MusicAudioTrackPrivate>(aValid, std::move(aId), std::move(aParentId),
                                                  std::move(aTitle), std::move(aArtist),
                                                  std::move(aAlbumName), std::move(aAlbumArtist),
                                                  aTrackNumber, aDiscNumber, std::move(aDuration),
                                                  std::move(aResourceURI), fileModificationTime,
                                                  std::move(aAlbumCover), rating,
                                                  aIsSingleDiscAlbum, std::move(aGenre),
                                                  std::move(aComposer), std::move(aLyricist)))
 {
 }
 
 MusicAudioTrack::MusicAudioTrack(MusicAudioTrack &&other)
 {
     d.swap(other.d);
 }
 
 MusicAudioTrack::MusicAudioTrack(const MusicAudioTrack &other) : d(std::make_unique<MusicAudioTrackPrivate>(*other.d))
 {
 }
 
 MusicAudioTrack::~MusicAudioTrack()
 = default;
 
 MusicAudioTrack& MusicAudioTrack::operator=(MusicAudioTrack &&other)
 {
     if (this != &other) {
         d.reset();
         d.swap(other.d);
     }
 
     return *this;
 }
 
 MusicAudioTrack& MusicAudioTrack::operator=(const MusicAudioTrack &other)
 {
     if (this != &other) {
         (*d) = (*other.d);
     }
 
     return *this;
 }
 
 bool MusicAudioTrack::operator <(const MusicAudioTrack &other) const
 {
     return d->mDiscNumber < other.d->mDiscNumber ||
             (d->mDiscNumber == other.d->mDiscNumber && d->mTrackNumber < other.d->mTrackNumber);
 }
 
 bool MusicAudioTrack::operator ==(const MusicAudioTrack &other) const
 {
     return d->mTitle == other.d->mTitle && d->mArtist == other.d->mArtist &&
             d->mAlbumName == other.d->mAlbumName && d->mAlbumArtist == other.d->mAlbumArtist &&
             d->mTrackNumber == other.d->mTrackNumber && d->mDiscNumber == other.d->mDiscNumber &&
             d->mDuration == other.d->mDuration && d->mResourceURI == other.d->mResourceURI &&
             d->mFileModificationTime == other.d->mFileModificationTime &&
             d->mAlbumCover == other.d->mAlbumCover && d->mRating == other.d->mRating &&
             d->mGenre == other.d->mGenre && d->mComposer == other.d->mComposer &&
             d->mLyricist == other.d->mLyricist && d->mComment == other.d->mComment &&
             d->mYear == other.d->mYear && d->mChannels == other.d->mChannels &&
             d->mBitRate == other.d->mBitRate && d->mSampleRate == other.d->mSampleRate;
 
 }
 
 bool MusicAudioTrack::operator !=(const MusicAudioTrack &other) const
 {
     return d->mTitle != other.d->mTitle || d->mArtist != other.d->mArtist ||
             d->mAlbumName != other.d->mAlbumName || d->mAlbumArtist != other.d->mAlbumArtist ||
             d->mTrackNumber != other.d->mTrackNumber || d->mDiscNumber != other.d->mDiscNumber ||
             d->mDuration != other.d->mDuration || d->mResourceURI != other.d->mResourceURI ||
             d->mFileModificationTime != other.d->mFileModificationTime ||
             d->mAlbumCover != other.d->mAlbumCover || d->mRating != other.d->mRating ||
             d->mGenre != other.d->mGenre || d->mComposer != other.d->mComposer ||
             d->mLyricist != other.d->mLyricist || d->mComment != other.d->mComment ||
             d->mYear != other.d->mYear || d->mChannels != other.d->mChannels ||
             d->mBitRate != other.d->mBitRate || d->mSampleRate != other.d->mSampleRate;
 }
 
 void MusicAudioTrack::setValid(bool value)
 {
     d->mIsValid = value;
 }
 
 bool MusicAudioTrack::isValid() const
 {
     return d->mIsValid;
 }
 
 void MusicAudioTrack::setDatabaseId(qulonglong value)
 {
     d->mDatabaseId = value;
 }
 
 qulonglong MusicAudioTrack::databaseId() const
 {
     return d->mDatabaseId;
 }
 
 void MusicAudioTrack::setId(const QString &value) const
 {
     d->mId = value;
 }
 
 QString MusicAudioTrack::id() const
 {
     return d->mId;
 }
 
 void MusicAudioTrack::setParentId(const QString &value) const
 {
     d->mParentId = value;
 }
 
 QString MusicAudioTrack::parentId() const
 {
     return d->mParentId;
 }
 
 void MusicAudioTrack::setTitle(const QString &value) const
 {
     d->mTitle = value;
 }
 
 QString MusicAudioTrack::title() const
 {
     return d->mTitle;
 }
 
 void MusicAudioTrack::setArtist(const QString &value) const
 {
     d->mArtist = value;
 }
 
 QString MusicAudioTrack::artist() const
 {
     return d->mArtist;
 }
 
 void MusicAudioTrack::setAlbumName(const QString &value) const
 {
     d->mAlbumName = value;
 }
 
 QString MusicAudioTrack::albumName() const
 {
     return d->mAlbumName;
 }
 
 void MusicAudioTrack::setAlbumArtist(const QString &value) const
 {
     d->mAlbumArtist = value;
 }
 
 QString MusicAudioTrack::albumArtist() const
 {
     return (d->mAlbumArtist.isEmpty() ? d->mArtist : d->mAlbumArtist);
 }
 
 bool MusicAudioTrack::isValidAlbumArtist() const
 {
     return !d->mAlbumArtist.isEmpty();
 }
 
 void MusicAudioTrack::setAlbumCover(const QUrl &value) const
 {
     d->mAlbumCover = value;
 }
 
 QUrl MusicAudioTrack::albumCover() const
 {
     return d->mAlbumCover;
 }
 
 void MusicAudioTrack::setGenre(const QString &value) const
 {
     d->mGenre = value;
 }
 
 QString MusicAudioTrack::genre() const
 {
     return d->mGenre;
 }
 
 void MusicAudioTrack::setComposer(const QString &value) const
 {
     d->mComposer = value;
 }
 
 QString MusicAudioTrack::composer() const
 {
     return d->mComposer;
 }
 
 void MusicAudioTrack::setLyricist(const QString &value) const
 {
     d->mLyricist = value;
 }
 
 QString MusicAudioTrack::lyricist() const
 {
     return d->mLyricist;
 }
 
 void MusicAudioTrack::setComment(const QString &value) const
 {
     d->mComment = value;
 }
 
 QString MusicAudioTrack::comment() const
 {
     return d->mComment;
 }
 
 void MusicAudioTrack::setTrackNumber(int value)
 {
     d->mTrackNumber = value;
 }
 
 int MusicAudioTrack::trackNumber() const
 {
     return d->mTrackNumber;
 }
 
 void MusicAudioTrack::setDiscNumber(int value)
 {
     d->mDiscNumber = value;
 }
 
 int MusicAudioTrack::discNumber() const
 {
     return d->mDiscNumber;
 }
 
 void MusicAudioTrack::setYear(int value)
 {
     d->mYear = value;
 }
 
 int MusicAudioTrack::year() const
 {
     return d->mYear;
 }
 
 void MusicAudioTrack::setChannels(int value)
 {
     d->mChannels = value;
 }
 
 int MusicAudioTrack::channels() const
 {
     return d->mChannels;
 }
 
 void MusicAudioTrack::setBitRate(int value)
 {
     d->mBitRate = value;
 }
 
 int MusicAudioTrack::bitRate() const
 {
     return d->mBitRate;
 }
 
 void MusicAudioTrack::setSampleRate(int value)
 {
     d->mSampleRate = value;
 }
 
 int MusicAudioTrack::sampleRate() const
 {
     return d->mSampleRate;
 }
 
 void MusicAudioTrack::setDuration(QTime value)
 {
     d->mDuration = value;
 }
 
 QTime MusicAudioTrack::duration() const
 {
     return d->mDuration;
 }
 
 void MusicAudioTrack::setFileModificationTime(const QDateTime &value)
 {
     d->mFileModificationTime = value;
 }
 
 const QDateTime &MusicAudioTrack::fileModificationTime() const
 {
     return d->mFileModificationTime;
 }
 
 void MusicAudioTrack::setResourceURI(const QUrl &value)
 {
     d->mResourceURI = value;
 }
 
 const QUrl &MusicAudioTrack::resourceURI() const
 {
     return d->mResourceURI;
 }
 
 void MusicAudioTrack::setRating(int value) const
 {
     d->mRating = value;
 }
 
 int MusicAudioTrack::rating() const
 {
     return d->mRating;
 }
 
 void MusicAudioTrack::setIsSingleDiscAlbum(bool value)
 {
     d->mIsSingleDiscAlbum = value;
 }
 
 bool MusicAudioTrack::isSingleDiscAlbum() const
 {
     return d->mIsSingleDiscAlbum;
 }
 
-QDebug operator<<(QDebug stream, const MusicAudioTrack &data)
+ELISALIB_EXPORT QDebug operator<<(QDebug stream, const MusicAudioTrack &data)
 {
     stream << data.title() << data.artist() << data.albumName() << data.albumArtist() << data.duration() << data.resourceURI();
     return stream;
 }
diff --git a/src/musicaudiotrack.h b/src/musicaudiotrack.h
index a410885f..d2916506 100644
--- a/src/musicaudiotrack.h
+++ b/src/musicaudiotrack.h
@@ -1,171 +1,171 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef MUSICAUDIOTRACK_H
 #define MUSICAUDIOTRACK_H
 
 #include "elisaLib_export.h"
 
 #include <QString>
 #include <QTime>
 #include <QUrl>
 #include <QMetaType>
 
 #include <memory>
 
 class MusicAudioTrackPrivate;
 class QDebug;
 
 class ELISALIB_EXPORT MusicAudioTrack
 {
 
 public:
 
     MusicAudioTrack();
 
     MusicAudioTrack(bool aValid, QString aId, QString aParentId, QString aTitle, QString aArtist, QString aAlbumName,
                     QString aAlbumArtist, int aTrackNumber, int aDiscNumber, QTime aDuration, QUrl aResourceURI,
                     const QDateTime &fileModificationTime, QUrl aAlbumCover, int rating, bool aIsSingleDiscAlbum,
                     QString aGenre, QString aComposer, QString aLyricist);
 
     MusicAudioTrack(MusicAudioTrack &&other);
 
     MusicAudioTrack(const MusicAudioTrack &other);
 
     ~MusicAudioTrack();
 
     MusicAudioTrack& operator=(MusicAudioTrack &&other);
 
     MusicAudioTrack& operator=(const MusicAudioTrack &other);
 
     bool operator <(const MusicAudioTrack &other) const;
 
     bool operator ==(const MusicAudioTrack &other) const;
 
     bool operator !=(const MusicAudioTrack &other) const;
 
     void setValid(bool value);
 
     bool isValid() const;
 
     void setDatabaseId(qulonglong value);
 
     qulonglong databaseId() const;
 
     void setId(const QString &value) const;
 
     QString id() const;
 
     void setParentId(const QString &value) const;
 
     QString parentId() const;
 
     void setTitle(const QString &value) const;
 
     QString title() const;
 
     void setArtist(const QString &value) const;
 
     QString artist() const;
 
     void setAlbumName(const QString &value) const;
 
     QString albumName() const;
 
     void setAlbumArtist(const QString &value) const;
 
     QString albumArtist() const;
 
     void setGenre(const QString &value) const;
 
     QString genre() const;
 
     void setComposer(const QString &value) const;
 
     QString composer() const;
 
     void setLyricist(const QString &value) const;
 
     QString lyricist() const;
 
     void setComment(const QString &value) const;
 
     QString comment() const;
 
     bool isValidAlbumArtist() const;
 
     void setAlbumCover(const QUrl &value) const;
 
     QUrl albumCover() const;
 
     void setTrackNumber(int value);
 
     int trackNumber() const;
 
     void setDiscNumber(int value);
 
     int discNumber() const;
 
     void setYear(int value);
 
     int year() const;
 
     void setChannels(int value);
 
     int channels() const;
 
     void setBitRate(int value);
 
     int bitRate() const;
 
     void setSampleRate(int value);
 
     int sampleRate() const;
 
     void setDuration(QTime value);
 
     QTime duration() const;
 
     void setFileModificationTime(const QDateTime &value);
 
     const QDateTime &fileModificationTime() const;
 
     void setResourceURI(const QUrl &value);
 
     const QUrl& resourceURI() const;
 
     void setRating(int value) const;
 
     int rating() const;
 
     void setIsSingleDiscAlbum(bool value);
 
     bool isSingleDiscAlbum() const;
 
 private:
 
     std::unique_ptr<MusicAudioTrackPrivate> d;
 
 };
 
-QDebug operator<<(QDebug stream, const MusicAudioTrack &data);
+ELISALIB_EXPORT QDebug operator<<(QDebug stream, const MusicAudioTrack &data);
 
 Q_DECLARE_METATYPE(MusicAudioTrack)
 
 #endif // MUSICAUDIOTRACK_H