~neon/juk/master

 

    copyright            : (C) 2007 by Matthias Kretz

    email                : kretz@kde.org

 

    copyright            : (C) 2008, 2009 by Michael Pyne

    email                : michael.pyne@kdemail.net

    m_crossfadeTracks(true),

    m_curOutputPath(0)

    delete m_sliderAction;

    m_sliderAction = 0;

    if(!m_setup)

    Phonon::State state = m_media[m_curOutputPath]->state();

    return (state == Phonon::PlayingState || state == Phonon::BufferingState);

    if(!m_setup)

    return m_media[m_curOutputPath]->state() == Phonon::PausedState;

    if(!m_setup)

    return m_output[m_curOutputPath]->volume();

    if(!m_setup)

    if(!m_setup)

    return m_media[m_curOutputPath]->totalTime() / 1000;

    if(!m_setup)

        return 0;

 

    return m_media[m_curOutputPath]->currentTime() / 1000;

}

    if(!playing() || m_file.isNull())

    return m_file.tag()->playingString();

    if(!m_setup)

    if(!m_media[0] || !m_media[1] || !m_playlistInterface)

    stopCrossfade();

 

    // The "currently playing" media object.

    Phonon::MediaObject *mediaObject = m_media[m_curOutputPath];

 

            mediaObject->play();

            mediaObject->seek(0);

                mediaObject->setCurrentSource(KUrl::fromPath(m_file.absFilePath()));

                mediaObject->play();

 

                emit signalItemChanged(m_file);

        mediaObject->setCurrentSource(KUrl::fromPath(file.absFilePath()));

        mediaObject->play();

 

        if(m_file != file)

            emit signalItemChanged(file);

 

    }

 

    // Our state changed handler will perform the follow up actions necessary

    // once we actually start playing.

    if(!m_setup)

    m_media[m_curOutputPath]->pause();

    if(!m_setup || !m_playlistInterface)

    // Fading out playback is for chumps.

    stopCrossfade();

    m_media[0]->stop();

    m_media[1]->stop();

 

    if(!m_file.isNull()) {

        m_file = FileHandle::null();

        emit signalItemChanged(m_file);

    if(!m_setup)

 

    m_output[0]->setVolume(volume);

    m_output[1]->setVolume(volume);

    if(!m_setup || m_media[m_curOutputPath]->currentTime() == seekTime)

        return;

 

    kDebug() << "Stopping crossfade to seek from" << m_media[m_curOutputPath]->currentTime()

             << "to" << seekTime;

    stopCrossfade();

    m_media[m_curOutputPath]->seek(seekTime);

}

    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));

    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));

    if(!m_setup)

    setVolume(volume() + 0.04); // 4% up

    setVolume(volume() - 0.04); // 4% down

    if(!m_setup)

    m_output[m_curOutputPath]->setMuted(!m_output[m_curOutputPath]->isMuted());

    if(m_file.isNull() || !m_crossfadeTracks)

 

 

    if(!nextFile.isNull()) {

        crossfadeToFile(m_file);

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

    // 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;

 

    m_playlistInterface->playNext();

    m_file = m_playlistInterface->currentFile();

 

    if(m_file.isNull()) {

        stop();

    }

    else {

        emit signalItemChanged(m_file);

        m_media[m_curOutputPath]->setCurrentSource(m_file.absFilePath());

        m_media[m_curOutputPath]->play();

    }

    if(!m_setup || !m_playlistInterface)

    if(m_statusLabel)

void PlayerManager::slotStateChanged(Phonon::State newstate, Phonon::State oldstate)

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

    if(newstate == Phonon::ErrorState) {

        QString errorMessage =

            i18nc(

              "%1 will be the /path/to/file, %2 will be some string from Phonon describing the error",

              "JuK is unable to play the audio file<nl/><filename>%1</filename><nl/>"

                "for the following reason:<nl/><message>%2</message>",

              m_file.absFilePath(),

              mediaObject->errorString()

            );

 

        switch(mediaObject->errorType()) {

 

                KMessageBox::information(0, errorMessage);

 

                KMessageBox::sorry(0, errorMessage);

 

    // Now bail out if we're not dealing with the currently playing media

    // object.

 

    if(mediaObject != m_media[m_curOutputPath])

    // 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()));

        emit signalStop();

    }

    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();

    }

        kWarning() << "Could not find all of the required actions.";

    // 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);

 

        m_media[i] = new Phonon::MediaObject(this);

        m_audioPath[i] = Phonon::createPath(m_media[i], m_output[i]);

        m_media[i]->setTickInterval(200);

        m_media[i]->setPrefinishMark(2000);

 

        // 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);

 

        connect(m_media[i], SIGNAL(stateChanged(Phonon::State, Phonon::State)), SLOT(slotStateChanged(Phonon::State, Phonon::State)));

        connect(m_media[i], SIGNAL(prefinishMarkReached(qint32)), SLOT(slotNeedNextUrl()));

        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()));

    }

    // setup sliders (a separate slot is used to switch as needed)

        m_sliderAction->trackPositionSlider()->setMediaObject(m_media[0]);

 

        m_sliderAction->volumeSlider()->setAudioOutput(m_output[0]);

 

    QDBusConnection::sessionBus().registerObject("/Player", this);

}

 

void PlayerManager::slotUpdateSliders()

{

    m_sliderAction->trackPositionSlider()->setMediaObject(m_media[m_curOutputPath]);

    m_sliderAction->volumeSlider()->setAudioOutput(m_output[m_curOutputPath]);

 

    disconnect(m_media[1 - m_curOutputPath], 0, this, SLOT(slotUpdateSliders()));

    connect(m_media[1 - m_curOutputPath], SIGNAL(finished()), SLOT(slotFinished()));

}

 

void PlayerManager::slotUpdateGuiIfStopped()

{

    if(m_media[0]->state() == Phonon::StoppedState && m_media[1]->state() == Phonon::StoppedState)

        stop();

}

 

void PlayerManager::crossfadeToFile(const FileHandle &newFile)

{

    int nextOutputPath = 1 - m_curOutputPath;

 

    // Don't need this anymore

    disconnect(m_media[m_curOutputPath], SIGNAL(finished()), this, 0);

    connect(m_media[nextOutputPath], SIGNAL(finished()), SLOT(slotFinished()));

 

    // Wait a couple of seconds and switch slider objects.  (We would simply

    // handle this when finished() is emitted but phonon-gst is buggy).

    QTimer::singleShot(2000, this, SLOT(slotUpdateSliders()));

 

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

 

    emit signalItemChanged(newFile);

    m_media[nextOutputPath]->setCurrentSource(newFile.absFilePath());

    m_media[nextOutputPath]->play();

 

    m_fader[m_curOutputPath]->setVolume(1.0f);

    m_fader[m_curOutputPath]->fadeTo(0.0f, 2000);

 

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

 

    m_curOutputPath = nextOutputPath;

}

 

void PlayerManager::stopCrossfade()

{

    // According to the Phonon docs, setVolume immediately takes effect,

    // which is "good enough for government work" ;)

 

    // 1 - curOutputPath is the other output path...

    m_fader[m_curOutputPath]->setVolume(1.0f);

    m_fader[1 - m_curOutputPath]->setVolume(0.0f);

 

    // 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();

void PlayerManager::setCrossfadeEnabled(bool crossfadeEnabled)

{

    m_crossfadeTracks = crossfadeEnabled;

}