coverinfo.cpp 13.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/**
 * Copyright (C) 2004 Nathan Toone <nathan@toonetown.com>
 * Copyright (C) 2005, 2008 Michael Pyne <mpyne@kde.org>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * 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/>.
 */
17

18 19
#include "coverinfo.h"

20 21
#include <kglobal.h>
#include <kapplication.h>
22
#include <kdebug.h>
23

24 25
#include <QRegExp>
#include <QLabel>
26
#include <QCursor>
Laurent Montel's avatar
Laurent Montel committed
27 28
#include <QPixmap>
#include <QMouseEvent>
Laurent Montel's avatar
Laurent Montel committed
29
#include <QFrame>
Laurent Montel's avatar
Laurent Montel committed
30 31
#include <QHBoxLayout>
#include <QEvent>
Laurent Montel's avatar
Laurent Montel committed
32
#include <QFile>
33
#include <QFileInfo>
34
#include <QDesktopWidget>
Michael Pyne's avatar
Michael Pyne committed
35
#include <QImage>
36
#include <QScopedPointer>
37

38 39 40 41 42
#include <taglib/mpegfile.h>
#include <taglib/tstring.h>
#include <taglib/id3v2tag.h>
#include <taglib/attachedpictureframe.h>

43 44 45 46 47 48 49 50
#ifdef TAGLIB_WITH_MP4
#include <taglib/mp4coverart.h>
#include <taglib/mp4file.h>
#include <taglib/mp4tag.h>
#include <taglib/mp4item.h>
#endif

#include "mediafiles.h"
51 52 53
#include "collectionlist.h"
#include "playlistsearch.h"
#include "playlistitem.h"
54
#include "tag.h"
55

56 57 58
struct CoverPopup : public QWidget
{
    CoverPopup(const QPixmap &image, const QPoint &p) :
Dirk Mueller's avatar
Dirk Mueller committed
59
        QWidget(0, Qt::WDestructiveClose | Qt::WX11BypassWM)
60 61 62 63 64
    {
        QHBoxLayout *layout = new QHBoxLayout(this);
        QLabel *label = new QLabel(this);

        layout->addWidget(label);
Laurent Montel's avatar
Laurent Montel committed
65
        label->setFrameStyle(QFrame::Box | QFrame::Raised);
66 67 68 69 70 71 72
        label->setLineWidth(1);
        label->setPixmap(image);

        setGeometry(p.x(), p.y(), label->width(), label->height());
        show();
    }
    virtual void leaveEvent(QEvent *) { close(); }
73
    virtual void mouseReleaseEvent(QMouseEvent *) { close(); }
74 75
};

76 77 78 79 80
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////


81
CoverInfo::CoverInfo(const FileHandle &file) :
82 83
    m_file(file),
    m_hasCover(false),
84
    m_hasAttachedCover(false),
85
    m_haveCheckedForCover(false),
Michael Pyne's avatar
Michael Pyne committed
86
    m_coverKey(CoverManager::NoMatch)
87
{
88

89 90
}

Michael Pyne's avatar
Michael Pyne committed
91
bool CoverInfo::hasCover() const
92
{
93
    if(m_haveCheckedForCover)
94
        return m_hasCover || m_hasAttachedCover;
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

    m_haveCheckedForCover = true;

    // Check for new-style covers.  First let's determine what our coverKey is
    // if it's not already set, as that's also tracked by the CoverManager.
    if(m_coverKey == CoverManager::NoMatch)
        m_coverKey = CoverManager::idForTrack(m_file.absFilePath());

    // We were assigned a key, let's see if we already have a cover.  Notice
    // that due to the way the CoverManager is structured, we should have a
    // cover if we have a cover key.  If we don't then either there's a logic
    // error, or the user has been mucking around where they shouldn't.
    if(m_coverKey != CoverManager::NoMatch)
        m_hasCover = CoverManager::hasCover(m_coverKey);

110 111
    // Check if it's embedded in the file itself.

112
    m_hasAttachedCover = hasEmbeddedAlbumArt();
113 114 115 116 117 118 119 120 121 122 123

    if(m_hasAttachedCover)
        return true;

    // Look for cover.jpg or cover.png in the directory.
    if(QFile::exists(m_file.fileInfo().absolutePath() + "/cover.jpg") ||
       QFile::exists(m_file.fileInfo().absolutePath() + "/cover.png"))
    {
        m_hasCover = true;
    }

124 125 126
    return m_hasCover;
}

127
void CoverInfo::clearCover()
Scott Wheeler's avatar
Scott Wheeler committed
128
{
129
    m_hasCover = false;
130
    m_hasAttachedCover = false;
131

132 133
    // Re-search for cover since we may still have a different type of cover.
    m_haveCheckedForCover = false;
Michael Pyne's avatar
Michael Pyne committed
134 135 136

    // We don't need to call removeCover because the CoverManager will
    // automatically unlink the cover if we were the last track to use it.
137 138
    CoverManager::setIdForTrack(m_file.absFilePath(), CoverManager::NoMatch);
    m_coverKey = CoverManager::NoMatch;
Scott Wheeler's avatar
Scott Wheeler committed
139 140
}

141
void CoverInfo::setCover(const QImage &image)
142
{
143 144 145
    if(image.isNull())
        return;

Michael Pyne's avatar
Michael Pyne committed
146 147
    m_haveCheckedForCover = true;
    m_hasCover = true;
148

149
    QPixmap cover = QPixmap::fromImage(image);
150

Michael Pyne's avatar
Michael Pyne committed
151 152 153 154
    // If we use replaceCover we'll change the cover for every other track
    // with the same coverKey, which we don't want since that case will be
    // handled by Playlist.  Instead just replace this track's cover.
    m_coverKey = CoverManager::addCover(cover, m_file.tag()->artist(), m_file.tag()->album());
155
    if(m_coverKey != CoverManager::NoMatch)
Michael Pyne's avatar
Michael Pyne committed
156 157 158 159 160 161 162
        CoverManager::setIdForTrack(m_file.absFilePath(), m_coverKey);
}

void CoverInfo::setCoverId(coverKey id)
{
    m_coverKey = id;
    m_haveCheckedForCover = true;
163
    m_hasCover = id != CoverManager::NoMatch;
Michael Pyne's avatar
Michael Pyne committed
164 165 166

    // Inform CoverManager of the change.
    CoverManager::setIdForTrack(m_file.absFilePath(), m_coverKey);
167 168
}

169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
void CoverInfo::applyCoverToWholeAlbum(bool overwriteExistingCovers) const
{
    QString artist = m_file.tag()->artist();
    QString album = m_file.tag()->album();
    PlaylistSearch::ComponentList components;
    ColumnList columns;

    columns.append(PlaylistItem::ArtistColumn);
    components.append(PlaylistSearch::Component(artist, false, columns, PlaylistSearch::Component::Exact));

    columns.clear();
    columns.append(PlaylistItem::AlbumColumn);
    components.append(PlaylistSearch::Component(album, false, columns, PlaylistSearch::Component::Exact));

    PlaylistList playlists;
    playlists.append(CollectionList::instance());

    PlaylistSearch search(playlists, components, PlaylistSearch::MatchAll);

    // Search done, iterate through results.

    PlaylistItemList results = search.matchedItems();
    PlaylistItemList::ConstIterator it = results.constBegin();
    for(; it != results.constEnd(); ++it) {

        // Don't worry about files that somehow already have a tag,
Michael Pyne's avatar
Michael Pyne committed
195 196
        // unless the conversion is forced.
        if(!overwriteExistingCovers && (*it)->file().coverInfo()->coverId() != CoverManager::NoMatch)
197 198 199 200 201 202
            continue;

        (*it)->file().coverInfo()->setCoverId(m_coverKey);
    }
}

Michael Pyne's avatar
Michael Pyne committed
203
coverKey CoverInfo::coverId() const
204
{
Michael Pyne's avatar
Michael Pyne committed
205 206 207
    if(m_coverKey == CoverManager::NoMatch)
        m_coverKey = CoverManager::idForTrack(m_file.absFilePath());

Michael Pyne's avatar
Michael Pyne committed
208 209
    return m_coverKey;
}
210

Michael Pyne's avatar
Michael Pyne committed
211 212 213
QPixmap CoverInfo::pixmap(CoverSize size) const
{
    if(hasCover() && m_coverKey != CoverManager::NoMatch) {
214 215 216 217 218 219
        return CoverManager::coverFromId(m_coverKey,
            size == Thumbnail
               ? CoverManager::Thumbnail
               : CoverManager::FullSize);
    }

220 221
    QImage cover;

222 223 224 225 226 227 228 229 230 231 232 233 234
    // If m_hasCover is still true we must have a directory cover image.
    if(m_hasCover) {
        QString fileName = m_file.fileInfo().absolutePath() + "/cover.jpg";

        if(!cover.load(fileName)) {
            fileName = m_file.fileInfo().absolutePath() + "/cover.png";

            if(!cover.load(fileName))
                return QPixmap();
        }
    }

    // If we get here, see if there is an embedded cover.
235
    cover = embeddedAlbumArt();
236
    if(!cover.isNull() && size == Thumbnail)
237
        cover = scaleCoverToThumbnail(cover);
238

239 240 241 242
    if(cover.isNull()) {
        return QPixmap();
    }

243 244 245
    return QPixmap::fromImage(cover);
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
QString CoverInfo::localPathToCover(const QString &fallbackFileName) const
{
    if(m_coverKey != CoverManager::NoMatch) {
        QString path = CoverManager::coverInfo(m_coverKey)->path;
        if(!path.isEmpty())
            return path;
    }

    if(hasEmbeddedAlbumArt()) {
        QFile albumArtFile(fallbackFileName);
        if(!albumArtFile.open(QIODevice::ReadWrite)) {
            return QString();
        }

        QImage albumArt = embeddedAlbumArt();
        albumArt.save(&albumArtFile, "PNG");
        return fallbackFileName;
    }

    QString basePath = m_file.fileInfo().absolutePath();
    if(QFile::exists(basePath + "/cover.jpg"))
        return basePath + "/cover.jpg";
    else if(QFile::exists(basePath + "/cover.png"))
        return basePath + "/cover.png";

    return QString();
}

274 275 276 277 278 279 280 281 282 283
bool CoverInfo::hasEmbeddedAlbumArt() const
{
    QScopedPointer<TagLib::File> fileTag(
            MediaFiles::fileFactoryByType(m_file.absFilePath()));

    if (TagLib::MPEG::File *mpegFile =
            dynamic_cast<TagLib::MPEG::File *>(fileTag.data()))
    {
        TagLib::ID3v2::Tag *id3tag = mpegFile->ID3v2Tag(false);

284 285 286 287 288
        if (!id3tag) {
            kError() << m_file.absFilePath() << "seems to have invalid ID3 tag";
            return false;
        }

289 290 291 292 293 294 295 296 297
        // Look for attached picture frames.
        TagLib::ID3v2::FrameList frames = id3tag->frameListMap()["APIC"];
        return !frames.isEmpty();
    }
#ifdef TAGLIB_WITH_MP4
    else if(TagLib::MP4::File *mp4File =
            dynamic_cast<TagLib::MP4::File *>(fileTag.data()))
    {
        TagLib::MP4::Tag *tag = mp4File->tag();
298 299 300 301
        if (tag) {
            TagLib::MP4::ItemListMap &items = tag->itemListMap();
            return items.contains("covr");
        }
302 303 304 305 306 307 308 309
    }
#endif

    return false;
}

static QImage embeddedMPEGAlbumArt(TagLib::ID3v2::Tag *id3tag)
{
310
    if(!id3tag)
311
        return QImage();
312 313

    // Look for attached picture frames.
Pau Garcia i Quiles's avatar
Pau Garcia i Quiles committed
314
    TagLib::ID3v2::FrameList frames = id3tag->frameListMap()["APIC"];
315 316

    if(frames.isEmpty())
317
        return QImage();
318

319 320 321 322 323
    // According to the spec attached picture frames have different types.
    // So we should look for the corresponding picture depending on what
    // type of image (i.e. front cover, file info) we want.  If only 1
    // frame, just return that (scaled if necessary).

Pau Garcia i Quiles's avatar
Pau Garcia i Quiles committed
324
    TagLib::ID3v2::AttachedPictureFrame *selectedFrame = 0;
325 326

    if(frames.size() != 1) {
Pau Garcia i Quiles's avatar
Pau Garcia i Quiles committed
327
        TagLib::ID3v2::FrameList::Iterator it = frames.begin();
328
        for(; it != frames.end(); ++it) {
329 330 331

            // This must be dynamic_cast<>, TagLib will return UnknownFrame in APIC for
            // encrypted frames.
Pau Garcia i Quiles's avatar
Pau Garcia i Quiles committed
332 333
            TagLib::ID3v2::AttachedPictureFrame *frame =
                dynamic_cast<TagLib::ID3v2::AttachedPictureFrame *>(*it);
334 335 336

            // Both thumbnail and full size should use FrontCover, as
            // FileIcon may be too small even for thumbnail.
337
            if(frame && frame->type() != TagLib::ID3v2::AttachedPictureFrame::FrontCover)
338 339 340 341 342 343 344 345 346 347 348
                continue;

            selectedFrame = frame;
            break;
        }
    }

    // If we get here we failed to pick a picture, or there was only one,
    // so just use the first picture.

    if(!selectedFrame)
349 350 351
        selectedFrame = dynamic_cast<TagLib::ID3v2::AttachedPictureFrame *>(frames.front());

    if(!selectedFrame) // Could occur for encrypted picture frames.
352
        return QImage();
353

354 355 356 357 358
    TagLib::ByteVector picture = selectedFrame->picture();
    return QImage::fromData(
            reinterpret_cast<const uchar *>(picture.data()),
            picture.size());
}
359

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
#ifdef TAGLIB_WITH_MP4
static QImage embeddedMP4AlbumArt(TagLib::MP4::Tag *tag)
{
    TagLib::MP4::ItemListMap &items = tag->itemListMap();

    if(!items.contains("covr"))
        return QImage();

    TagLib::MP4::CoverArtList covers = items["covr"].toCoverArtList();
    TagLib::MP4::CoverArtList::ConstIterator end = covers.end();

    for(TagLib::MP4::CoverArtList::ConstIterator it = covers.begin(); it != end; ++it) {
        TagLib::MP4::CoverArt cover = *it;
        TagLib::ByteVector coverData = cover.data();

        QImage result = QImage::fromData(
                reinterpret_cast<const uchar *>(coverData.data()),
                coverData.size());

        if(!result.isNull())
            return result;
    }
382

383 384
    // No appropriate image found
    return QImage();
385
}
386
#endif
387

388
void CoverInfo::popup() const
389 390
{
    QPixmap image = pixmap(FullSize);
391
    QPoint mouse  = QCursor::pos();
Laurent Montel's avatar
Laurent Montel committed
392
    QRect desktop = QApplication::desktop()->screenGeometry(mouse);
393

394 395 396 397 398 399 400 401 402 403 404
    int x = mouse.x();
    int y = mouse.y();
    int height = image.size().height() + 4;
    int width  = image.size().width() + 4;

    // Detect the right direction to pop up (always towards the center of the
    // screen), try to pop up with the mouse pointer 10 pixels into the image in
    // both directions.  If we're too close to the screen border for this margin,
    // show it at the screen edge, accounting for the four pixels (two on each
    // side) for the window border.

405 406
    if(x - desktop.x() < desktop.width() / 2)
        x = (x - desktop.x() < 10) ? desktop.x() : (x - 10);
407
    else
408
        x = (x - desktop.x() > desktop.width() - 10) ? desktop.width() - width +desktop.x() : (x - width + 10);
409

410 411
    if(y - desktop.y() < desktop.height() / 2)
        y = (y - desktop.y() < 10) ? desktop.y() : (y - 10);
412
    else
413
        y = (y - desktop.y() > desktop.height() - 10) ? desktop.height() - height + desktop.y() : (y - height + 10);
414 415

    new CoverPopup(image, QPoint(x, y));
416 417
}

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
QImage CoverInfo::embeddedAlbumArt() const
{
    QScopedPointer<TagLib::File> fileTag(
            MediaFiles::fileFactoryByType(m_file.absFilePath()));

    if (TagLib::MPEG::File *mpegFile =
            dynamic_cast<TagLib::MPEG::File *>(fileTag.data()))
    {
        TagLib::ID3v2::Tag *id3tag = mpegFile->ID3v2Tag(false);
        return embeddedMPEGAlbumArt(id3tag);
    }
#ifdef TAGLIB_WITH_MP4
    else if(TagLib::MP4::File *mp4File =
            dynamic_cast<TagLib::MP4::File *>(fileTag.data()))
    {
        TagLib::MP4::Tag *tag = mp4File->tag();
434 435 436
        if (tag) {
            return embeddedMP4AlbumArt(tag);
        }
437 438 439 440 441 442
    }
#endif

    return QImage();
}

443 444 445 446 447
QImage CoverInfo::scaleCoverToThumbnail(const QImage &image) const
{
    return image.scaled(80, 80, Qt::KeepAspectRatio, Qt::SmoothTransformation);
}

448
// vim: set et sw=4 tw=0 sta: