playermanager.cpp 17.8 KB
Newer Older
1 2 3 4
/***************************************************************************
    begin                : Sat Feb 14 2004
    copyright            : (C) 2004 by Scott Wheeler
    email                : wheeler@kde.org
5 6 7 8

    copyright            : (C) 2007 by Matthias Kretz
    email                : kretz@kde.org

9
    copyright            : (C) 2008, 2009 by Michael Pyne
10
    email                : michael.pyne@kdemail.net
11 12 13 14 15 16 17 18 19 20 21
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

22 23
#include "playermanager.h"

24
#include <kdebug.h>
Matthias Kretz's avatar
Matthias Kretz committed
25
#include <kmessagebox.h>
26
#include <klocale.h>
27 28 29
#include <kactioncollection.h>
#include <kselectaction.h>
#include <ktoggleaction.h>
Andreas Pakulat's avatar
Andreas Pakulat committed
30
#include <kurl.h>
31

32 33 34
#include <Phonon/AudioOutput>
#include <Phonon/MediaObject>
#include <Phonon/VolumeFaderEffect>
35

Laurent Montel's avatar
Laurent Montel committed
36
#include <QPixmap>
37 38
#include <QTimer>

39 40
#include <math.h>

41
#include "playlistinterface.h"
42
#include "playeradaptor.h"
43
#include "slideraction.h"
44
#include "statuslabel.h"
45
#include "actioncollection.h"
46
#include "collectionlist.h"
Michael Pyne's avatar
Michael Pyne committed
47
#include "coverinfo.h"
48
#include "tag.h"
49
#include "scrobbler.h"
50 51

using namespace ActionCollection;
52

Stephan Kulow's avatar
Stephan Kulow committed
53
enum PlayerManagerStatus { StatusStopped = -1, StatusPaused = 1, StatusPlaying = 2 };
54

55 56 57 58 59
////////////////////////////////////////////////////////////////////////////////
// protected members
////////////////////////////////////////////////////////////////////////////////

PlayerManager::PlayerManager() :
60
    QObject(),
61
    m_playlistInterface(0),
62
    m_statusLabel(0),
63
    m_setup(false),
64
    m_crossfadeTracks(true),
65
    m_curOutputPath(0)
66
{
Michael Pyne's avatar
Michael Pyne committed
67 68 69 70 71
// This class is the first thing constructed during program startup, and
// therefore has no access to the widgets needed by the setup() method.
// Since the setup() method will be called indirectly by the player() method
// later, just disable it here. -- mpyne
//    setup();
Laurent Montel's avatar
Laurent Montel committed
72
    new PlayerAdaptor( this );
73 74 75 76
    
    
    m_scrobbler = new Scrobbler(this);
    connect(this, SIGNAL(signalItemChanged(FileHandle)), m_scrobbler, SLOT(nowPlaying(FileHandle)));
77 78 79 80
}

PlayerManager::~PlayerManager()
{
81

82 83 84 85 86 87
}

////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////

88 89
bool PlayerManager::playing() const
{
90
    if(!m_setup)
91 92
        return false;

93 94
    Phonon::State state = m_media[m_curOutputPath]->state();
    return (state == Phonon::PlayingState || state == Phonon::BufferingState);
95 96 97 98
}

bool PlayerManager::paused() const
{
99
    if(!m_setup)
100 101
        return false;

102
    return m_media[m_curOutputPath]->state() == Phonon::PausedState;
103 104
}

105 106 107 108 109 110 111 112
bool PlayerManager::muted() const
{
    if(!m_setup)
        return false;

    return m_output[m_curOutputPath]->isMuted();
}

113 114
float PlayerManager::volume() const
{
115
    if(!m_setup)
116
        return 1.0;
117

118
    return m_output[m_curOutputPath]->volume();
119 120
}

121 122
int PlayerManager::status() const
{
123
    if(!m_setup)
124
        return StatusStopped;
125

126
    if(paused())
127
        return StatusPaused;
128

129
    if(playing())
130
        return StatusPlaying;
131

132 133 134
    return 0;
}

Scott Wheeler's avatar
Scott Wheeler committed
135
int PlayerManager::totalTime() const
136
{
137
    if(!m_setup)
138 139
        return 0;

140
    return m_media[m_curOutputPath]->totalTime() / 1000;
141 142
}

Scott Wheeler's avatar
Scott Wheeler committed
143
int PlayerManager::currentTime() const
144
{
145
    if(!m_setup)
146 147
        return 0;

148
    return m_media[m_curOutputPath]->currentTime() / 1000;
149 150
}

151 152 153 154 155 156 157 158
bool PlayerManager::seekable() const
{
    if(!m_setup)
        return false;

    return m_media[m_curOutputPath]->isSeekable();
}

159 160 161 162 163 164 165
QStringList PlayerManager::trackProperties()
{
    return FileHandle::properties();
}

QString PlayerManager::trackProperty(const QString &property) const
{
Michael Pyne's avatar
Michael Pyne committed
166
    if(!playing() && !paused())
167
        return QString();
168 169 170 171

    return m_file.property(property);
}

Michael Pyne's avatar
Michael Pyne committed
172 173 174 175 176
QPixmap PlayerManager::trackCover(const QString &size) const
{
    if(!playing() && !paused())
        return QPixmap();

177
    if(size.toLower() == "small")
Michael Pyne's avatar
Michael Pyne committed
178
        return m_file.coverInfo()->pixmap(CoverInfo::Thumbnail);
179
    if(size.toLower() == "large")
Michael Pyne's avatar
Michael Pyne committed
180 181 182 183 184
        return m_file.coverInfo()->pixmap(CoverInfo::FullSize);

    return QPixmap();
}

185 186 187 188 189
FileHandle PlayerManager::playingFile() const
{
    return m_file;
}

190 191
QString PlayerManager::playingString() const
{
192
    if(!playing() || m_file.isNull())
193
        return QString();
194

195
    return m_file.tag()->playingString();
196 197
}

198
void PlayerManager::setPlaylistInterface(PlaylistInterface *interface)
199 200 201 202
{
    m_playlistInterface = interface;
}

203 204 205 206 207
void PlayerManager::setStatusLabel(StatusLabel *label)
{
    m_statusLabel = label;
}

208 209 210 211
////////////////////////////////////////////////////////////////////////////////
// public slots
////////////////////////////////////////////////////////////////////////////////

212
void PlayerManager::play(const FileHandle &file)
213
{
214
    if(!m_setup)
215 216
        setup();

217
    if(!m_media[0] || !m_media[1] || !m_playlistInterface)
218 219
        return;

220 221 222 223
    stopCrossfade();

    // The "currently playing" media object.
    Phonon::MediaObject *mediaObject = m_media[m_curOutputPath];
224 225
    connect(mediaObject, SIGNAL(aboutToFinish()), m_scrobbler, SLOT(scrobble()));
    
226
    if(file.isNull()) {
227
        if(paused())
228
            mediaObject->play();
229
        else if(playing()) {
230
            mediaObject->seek(0);
231
        }
232
        else {
233
            m_playlistInterface->playNext();
234
            m_file = m_playlistInterface->currentFile();
235

236
            if(!m_file.isNull())
237
            {
238 239
                mediaObject->setCurrentSource(KUrl::fromPath(m_file.absFilePath()));
                mediaObject->play();
240 241

                emit signalItemChanged(m_file);
242
            }
243
        }
244
    }
245
    else {
246
        mediaObject->setCurrentSource(KUrl::fromPath(file.absFilePath()));
247
        mediaObject->play();
248 249 250 251 252

        if(m_file != file)
            emit signalItemChanged(file);

        m_file = file;
253
    }
254

255 256
    // Our state changed handler will perform the follow up actions necessary
    // once we actually start playing.
257 258
}

259 260 261 262 263 264 265 266 267
void PlayerManager::play(const QString &file)
{
    CollectionListItem *item = CollectionList::instance()->lookup(file);
    if(item) {
        Playlist::setPlaying(item);
        play(item->file());
    }
}

Scott Wheeler's avatar
Scott Wheeler committed
268 269 270 271 272
void PlayerManager::play()
{
    play(FileHandle::null());
}

273 274
void PlayerManager::pause()
{
275
    if(!m_setup)
276 277
        return;

278
    if(paused()) {
279 280 281 282
        play();
        return;
    }

283
    action("pause")->setEnabled(false);
284

285
    m_media[m_curOutputPath]->pause();
286 287

    emit signalPause();
288 289 290 291
}

void PlayerManager::stop()
{
292
    if(!m_setup || !m_playlistInterface)
293 294
        return;

295 296 297 298
    action("pause")->setEnabled(false);
    action("stop")->setEnabled(false);
    action("back")->setEnabled(false);
    action("forward")->setEnabled(false);
299
    action("forwardAlbum")->setEnabled(false);
300

301 302 303 304
    // Fading out playback is for chumps.
    stopCrossfade();
    m_media[0]->stop();
    m_media[1]->stop();
305 306 307 308 309

    if(!m_file.isNull()) {
        m_file = FileHandle::null();
        emit signalItemChanged(m_file);
    }
310 311
}

Laurent Montel's avatar
Laurent Montel committed
312
void PlayerManager::setVolume(float volume)
313
{
314
    if(!m_setup)
315
        setup();
316

317 318
    m_output[0]->setVolume(volume);
    m_output[1]->setVolume(volume);
319 320
}

321
void PlayerManager::seek(int seekTime)
322
{
323
    if(!m_setup || m_media[m_curOutputPath]->currentTime() == seekTime)
324
        return;
325

326 327
    kDebug() << "Stopping crossfade to seek from" << m_media[m_curOutputPath]->currentTime()
             << "to" << seekTime;
328 329
    stopCrossfade();
    m_media[m_curOutputPath]->seek(seekTime);
330 331 332 333
}

void PlayerManager::seekForward()
{
334 335 336 337 338 339
    Phonon::MediaObject *mediaObject = m_media[m_curOutputPath];
    const qint64 total = mediaObject->totalTime();
    const qint64 newtime = mediaObject->currentTime() + total / 100;

    stopCrossfade();
    mediaObject->seek(qMin(total, newtime));
340 341 342 343
}

void PlayerManager::seekBack()
{
344 345 346 347 348 349
    Phonon::MediaObject *mediaObject = m_media[m_curOutputPath];
    const qint64 total = mediaObject->totalTime();
    const qint64 newtime = mediaObject->currentTime() - total / 100;

    stopCrossfade();
    mediaObject->seek(qMax(qint64(0), newtime));
350 351
}

352 353
void PlayerManager::playPause()
{
David Faure's avatar
David Faure committed
354
    playing() ? action("pause")->trigger() : action("play")->trigger();
355 356
}

357 358
void PlayerManager::forward()
{
359 360
    m_playlistInterface->playNext();
    FileHandle file = m_playlistInterface->currentFile();
361

362 363 364 365 366 367 368 369
    if(!file.isNull())
        play(file);
    else
        stop();
}

void PlayerManager::back()
{
370 371
    m_playlistInterface->playPrevious();
    FileHandle file = m_playlistInterface->currentFile();
372

373 374 375 376 377 378
    if(!file.isNull())
        play(file);
    else
        stop();
}

379 380
void PlayerManager::volumeUp()
{
381
    if(!m_setup)
382
        return;
383

384
    setVolume(volume() + 0.04); // 4% up
385 386 387 388
}

void PlayerManager::volumeDown()
{
389
    if(!m_output)
390
        return;
391

392
    setVolume(volume() - 0.04); // 4% down
393 394
}

395
void PlayerManager::setMuted(bool m)
396
{
397
    if(!m_setup)
398 399
        return;

400 401 402 403 404 405 406 407 408 409 410
    m_output[m_curOutputPath]->setMuted(m);
}

bool PlayerManager::mute()
{
    if(!m_setup)
        return false;

    bool newState = !muted();
    setMuted(newState);
    return newState;
411 412
}

413 414 415
////////////////////////////////////////////////////////////////////////////////
// private slots
////////////////////////////////////////////////////////////////////////////////
416

417 418
void PlayerManager::slotNeedNextUrl()
{
419
    if(m_file.isNull() || !m_crossfadeTracks)
Matthias Kretz's avatar
Matthias Kretz committed
420
        return;
421

422 423
    m_playlistInterface->playNext();
    FileHandle nextFile = m_playlistInterface->currentFile();
424 425

    if(!nextFile.isNull()) {
426
        m_file = nextFile;
427
        crossfadeToFile(m_file);
428 429 430
    }
}

431 432
void PlayerManager::slotFinished()
{
433 434 435 436
    // It is possible to end up in this function if a file simply fails to play or if the
    // user moves the slider all the way to the end, therefore see if we can keep playing
    // and if we can, do so.  Otherwise, stop.  Note that this slot should
    // only be called by the currently "main" output path (i.e. not from the
437 438 439 440 441 442
    // crossfading one).  However life isn't always so nice apparently, so do some
    // sanity-checking.

    Phonon::MediaObject *mediaObject = qobject_cast<Phonon::MediaObject *>(sender());
    if(mediaObject != m_media[m_curOutputPath])
        return;
443

444 445
    m_playlistInterface->playNext();
    m_file = m_playlistInterface->currentFile();
446

447 448 449 450
    if(m_file.isNull()) {
        stop();
    }
    else {
451
        emit signalItemChanged(m_file);
452 453 454
        m_media[m_curOutputPath]->setCurrentSource(m_file.absFilePath());
        m_media[m_curOutputPath]->play();
    }
455 456
}

457 458 459
void PlayerManager::slotLength(qint64 msec)
{
    m_statusLabel->setItemTotalTime(msec / 1000);
460
    emit totalTimeChanged(msec);
461 462
}

463
void PlayerManager::slotTick(qint64 msec)
464
{
465
    if(!m_setup || !m_playlistInterface)
466
        return;
467

468
    if(m_statusLabel)
469
        m_statusLabel->setItemCurrentTime(msec / 1000);
470 471

    emit tick(msec);
472 473
}

474
void PlayerManager::slotStateChanged(Phonon::State newstate, Phonon::State oldstate)
Matthias Kretz's avatar
Matthias Kretz committed
475
{
476 477 478 479 480 481
    // Use sender() since either media object may have sent the signal.
    Phonon::MediaObject *mediaObject = qobject_cast<Phonon::MediaObject *>(sender());
    if(!mediaObject)
        return;

    // Handle errors for either media object
482
    if(newstate == Phonon::ErrorState) {
483 484 485
        QString errorMessage =
            i18nc(
              "%1 will be the /path/to/file, %2 will be some string from Phonon describing the error",
486 487
              "JuK is unable to play the audio file<nl/><filename>%1</filename><nl/>"
                "for the following reason:<nl/><message>%2</message>",
488
              m_file.absFilePath(),
489
              mediaObject->errorString()
490 491
            );

492
        switch(mediaObject->errorType()) {
493 494 495
            case Phonon::NoError:
                kDebug() << "received a state change to ErrorState but errorType is NoError!?";
                break;
496

Matthias Kretz's avatar
Matthias Kretz committed
497 498
            case Phonon::NormalError:
                forward();
499
                KMessageBox::information(0, errorMessage);
Matthias Kretz's avatar
Matthias Kretz committed
500
                break;
501

Matthias Kretz's avatar
Matthias Kretz committed
502 503
            case Phonon::FatalError:
                stop();
504
                KMessageBox::sorry(0, errorMessage);
Matthias Kretz's avatar
Matthias Kretz committed
505 506 507
                break;
        }
    }
508

509 510 511 512 513
    // Now bail out if we're not dealing with the currently playing media
    // object.

    if(mediaObject != m_media[m_curOutputPath])
        return;
514

515 516 517 518 519 520
    // Handle state changes for the playing media object.
    if(newstate == Phonon::StoppedState && oldstate != Phonon::LoadingState) {
        // If this occurs it should be due to a transitory shift (i.e. playing a different
        // song when one is playing now), since it didn't occur in the error handler.  Just
        // in case we really did abruptly stop, handle that case in a couple of seconds.
        QTimer::singleShot(2000, this, SLOT(slotUpdateGuiIfStopped()));
Michael Pyne's avatar
Michael Pyne committed
521
        emit signalStop();
522
    }
523 524 525 526 527 528 529 530 531 532
    else if(newstate == Phonon::PlayingState) {
        action("pause")->setEnabled(true);
        action("stop")->setEnabled(true);
        action("forward")->setEnabled(true);
        if(action<KToggleAction>("albumRandomPlay")->isChecked())
            action("forwardAlbum")->setEnabled(true);
        action("back")->setEnabled(true);

        emit signalPlay();
    }
533 534
}

535 536 537 538 539 540 541 542
////////////////////////////////////////////////////////////////////////////////
// private members
////////////////////////////////////////////////////////////////////////////////

void PlayerManager::setup()
{
    // All of the actions required by this class should be listed here.

543 544 545
    if(!action("pause") ||
       !action("stop") ||
       !action("back") ||
546
       !action("forwardAlbum") ||
547 548
       !action("forward") ||
       !action("trackPositionAction"))
549
    {
550
        kWarning() << "Could not find all of the required actions.";
551 552 553
        return;
    }

554 555 556 557
    if(m_setup)
        return;
    m_setup = true;

558 559 560 561 562 563
    // We use two audio paths at all times to make cross fading easier (and to also easily
    // support not using cross fading with the same code).  The currently playing audio
    // path is controlled using m_curOutputPath.

    for(int i = 0; i < 2; ++i) {
        m_output[i] = new Phonon::AudioOutput(Phonon::MusicCategory, this);
564

565 566 567
        m_media[i] = new Phonon::MediaObject(this);
        m_audioPath[i] = Phonon::createPath(m_media[i], m_output[i]);
        m_media[i]->setTickInterval(200);
568
        m_media[i]->setPrefinishMark(2000);
569

570 571 572 573 574
        // Pre-cache a volume fader object
        m_fader[i] = new Phonon::VolumeFaderEffect(m_media[i]);
        m_audioPath[i].insertEffect(m_fader[i]);
        m_fader[i]->setVolume(1.0f);

Laurent Montel's avatar
Laurent Montel committed
575
        connect(m_media[i], SIGNAL(stateChanged(Phonon::State,Phonon::State)), SLOT(slotStateChanged(Phonon::State,Phonon::State)));
576
        connect(m_media[i], SIGNAL(prefinishMarkReached(qint32)), SLOT(slotNeedNextUrl()));
577 578 579 580
        connect(m_media[i], SIGNAL(totalTimeChanged(qint64)), SLOT(slotLength(qint64)));
        connect(m_media[i], SIGNAL(tick(qint64)), SLOT(slotTick(qint64)));
        connect(m_media[i], SIGNAL(finished()), SLOT(slotFinished()));
    }
581

582 583
    // initialize action states

584 585 586 587
    action("pause")->setEnabled(false);
    action("stop")->setEnabled(false);
    action("back")->setEnabled(false);
    action("forward")->setEnabled(false);
588
    action("forwardAlbum")->setEnabled(false);
589

590
    QDBusConnection::sessionBus().registerObject("/Player", this);
591 592 593
}

void PlayerManager::slotUpdateGuiIfStopped()
594
{
595 596 597
    if(m_media[0]->state() == Phonon::StoppedState && m_media[1]->state() == Phonon::StoppedState)
        stop();
}
598

599 600 601
void PlayerManager::crossfadeToFile(const FileHandle &newFile)
{
    int nextOutputPath = 1 - m_curOutputPath;
602

603 604 605
    // Don't need this anymore
    disconnect(m_media[m_curOutputPath], SIGNAL(finished()), this, 0);
    connect(m_media[nextOutputPath], SIGNAL(finished()), SLOT(slotFinished()));
606

607
    m_fader[nextOutputPath]->setVolume(0.0f);
608

609
    emit signalItemChanged(newFile);
610 611
    m_media[nextOutputPath]->setCurrentSource(newFile.absFilePath());
    m_media[nextOutputPath]->play();
612

613 614
    m_fader[m_curOutputPath]->setVolume(1.0f);
    m_fader[m_curOutputPath]->fadeTo(0.0f, 2000);
615

616
    m_fader[nextOutputPath]->fadeTo(1.0f, 2000);
617

618 619
    m_curOutputPath = nextOutputPath;
}
620

621 622 623 624
void PlayerManager::stopCrossfade()
{
    // According to the Phonon docs, setVolume immediately takes effect,
    // which is "good enough for government work" ;)
625

626 627 628
    // 1 - curOutputPath is the other output path...
    m_fader[m_curOutputPath]->setVolume(1.0f);
    m_fader[1 - m_curOutputPath]->setVolume(0.0f);
629

630 631 632 633 634 635 636 637
    // We don't actually need to physically stop crossfading as the playback
    // code will call ->play() when necessary anyways.  If we hit stop()
    // here instead of pause() then we will trick our stateChanged handler
    // into thinking Phonon had a spurious stop and we'll switch tracks
    // unnecessarily.  (This isn't a problem after crossfade completes due to
    // the signals being disconnected).

    m_media[1 - m_curOutputPath]->pause();
638 639
}

Michael Pyne's avatar
Michael Pyne committed
640 641 642 643 644 645 646 647 648
QString PlayerManager::randomPlayMode() const
{
    if(action<KToggleAction>("randomPlay")->isChecked())
        return "Random";
    if(action<KToggleAction>("albumRandomPlay")->isChecked())
        return "AlbumRandom";
    return "NoRandom";
}

649 650 651 652 653
void PlayerManager::setCrossfadeEnabled(bool crossfadeEnabled)
{
    m_crossfadeTracks = crossfadeEnabled;
}

Michael Pyne's avatar
Michael Pyne committed
654 655
void PlayerManager::setRandomPlayMode(const QString &randomMode)
{
656
    if(randomMode.toLower() == "random")
Michael Pyne's avatar
Michael Pyne committed
657
        action<KToggleAction>("randomPlay")->setChecked(true);
658
    if(randomMode.toLower() == "albumrandom")
Michael Pyne's avatar
Michael Pyne committed
659
        action<KToggleAction>("albumRandomPlay")->setChecked(true);
660
    if(randomMode.toLower() == "norandom")
Michael Pyne's avatar
Michael Pyne committed
661 662 663
        action<KToggleAction>("disableRandomPlay")->setChecked(true);
}

664
#include "playermanager.moc"
665

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