Amarok – versatile and easy to use audio player
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

802 lines
26 KiB

/***************************************************************************
* Copyright (C) 2004 Frederik Holljen <fh@ez.no> *
* (C) 2004,5 Max Howell <max.howell@methylblue.com> *
* (C) 2004,5 Mark Kretschmann *
* (C) 2006 Ian Monroe *
* *
* 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. *
* *
***************************************************************************/
#define DEBUG_PREFIX "controller"
#include "amarok.h"
#include "amarokconfig.h"
#include "debug.h"
#include "enginebase.h"
#include "enginecontroller.h"
#include "lastfm.h"
#include "mediabrowser.h"
#include "playlist.h"
#include "playlistloader.h"
#include "pluginmanager.h"
#include "statusbar.h"
#include <tqfile.h>
#include <tqobjectlist.h>
#include <tqtimer.h>
#include <tdeapplication.h>
#include <tdefileitem.h>
#include <tdeio/global.h>
#include <tdeio/job.h>
#include <tdemessagebox.h>
#include <krun.h>
#include <cstdlib>
EngineController::ExtensionCache EngineController::s_extensionCache;
EngineController*
EngineController::instance()
{
//will only be instantiated the first time this function is called
//will work with the inline directive
static EngineController Instance;
return &Instance;
}
EngineController::EngineController()
: m_engine( 0 )
, m_voidEngine( 0 )
, m_delayTime( 0 )
, m_muteVolume( 0 )
, m_xFadeThisTrack( false )
, m_timer( new TQTimer( this ) )
, m_playFailureCount( 0 )
, m_lastFm( false )
, m_positionOffset( 0 )
, m_lastPositionOffset( 0 )
{
m_voidEngine = m_engine = loadEngine( "void-engine" );
connect( m_timer, TQT_SIGNAL( timeout() ), TQT_SLOT( slotMainTimer() ) );
}
EngineController::~EngineController()
{
DEBUG_FUNC_INFO //we like to know when singletons are destroyed
}
//////////////////////////////////////////////////////////////////////////////////////////
// PUBLIC
//////////////////////////////////////////////////////////////////////////////////////////
EngineBase*
EngineController::loadEngine() //static
{
/// always returns a valid pointer to EngineBase
DEBUG_BLOCK
//TODO remember song position, and resume playback
// new engine, new ext cache required
extensionCache().clear();
if( m_engine != m_voidEngine ) {
EngineBase *oldEngine = m_engine;
// we assign this first for thread-safety,
// EngineController::engine() must always return an engine!
m_engine = m_voidEngine;
// we unload the old engine first because there are a number of
// bugs associated with keeping one engine loaded while loading
// another, eg xine-engine can't init(), and aRts-engine crashes
PluginManager::unload( oldEngine );
// the engine is not required to do this when we unload it but
// we need to do it to ensure Amarok looks correct.
// We don't do this for the void-engine because that
// means Amarok sets all components to empty on startup, which is
// their responsibility.
slotStateChanged( Engine::Empty );
}
m_engine = loadEngine( AmarokConfig::soundSystem() );
const TQString engineName = PluginManager::getService( m_engine )->property( "X-TDE-Amarok-name" ).toString();
if( !AmarokConfig::soundSystem().isEmpty() && engineName != AmarokConfig::soundSystem() ) {
//AmarokConfig::soundSystem() is empty on the first-ever-run
Amarok::StatusBar::instance()->longMessage( i18n(
"Sorry, the '%1' could not be loaded, instead we have loaded the '%2'." )
.arg( AmarokConfig::soundSystem() )
.arg( engineName ),
KDE::StatusBar::Sorry );
AmarokConfig::setSoundSystem( engineName );
}
// Important: Make sure soundSystem is not empty
if( AmarokConfig::soundSystem().isEmpty() )
AmarokConfig::setSoundSystem( engineName );
return m_engine;
}
#include <tqvaluevector.h>
EngineBase*
EngineController::loadEngine( const TQString &engineName )
{
/// always returns a valid plugin (exits if it can't get one)
DEBUG_BLOCK
TQString query = "[X-TDE-Amarok-plugintype] == 'engine' and [X-TDE-Amarok-name] != '%1'";
TDETrader::OfferList offers = PluginManager::query( query.arg( engineName ) );
// sort by rank, TQValueList::operator[] is O(n), so this is quite inefficient
#define rank( x ) (x)->property( "X-TDE-Amarok-rank" ).toInt()
for( int n = offers.count()-1, i = 0; i < n; i++ )
for( int j = n; j > i; j-- )
if( rank( offers[j] ) > rank( offers[j-1] ) )
tqSwap( offers[j], offers[j-1] );
#undef rank
// this is the actual engine we want
query = "[X-TDE-Amarok-plugintype] == 'engine' and [X-TDE-Amarok-name] == '%1'";
offers = PluginManager::query( query.arg( engineName ) ) + offers;
foreachType( TDETrader::OfferList, offers ) {
Amarok::Plugin *plugin = PluginManager::createFromService( *it );
if( plugin ) {
TQObject *bar = TQT_TQOBJECT(Amarok::StatusBar::instance());
EngineBase *engine = static_cast<EngineBase*>( plugin );
connect( engine, TQT_SIGNAL(stateChanged( Engine::State )),
this, TQT_SLOT(slotStateChanged( Engine::State )) );
connect( engine, TQT_SIGNAL(trackEnded()),
this, TQT_SLOT(slotTrackEnded()) );
if( bar )
{
connect( engine, TQT_SIGNAL(statusText( const TQString& )),
bar, TQT_SLOT(shortMessage( const TQString& )) );
connect( engine, TQT_SIGNAL(infoMessage( const TQString& )),
bar, TQT_SLOT(longMessage( const TQString& )) );
}
connect( engine, TQT_SIGNAL(metaData( const Engine::SimpleMetaBundle& )),
this, TQT_SLOT(slotEngineMetaData( const Engine::SimpleMetaBundle& )) );
connect( engine, TQT_SIGNAL(showConfigDialog( const TQCString& )),
kapp, TQT_SLOT(slotConfigAmarok( const TQCString& )) );
if( engine->init() )
return engine;
else
warning() << "Could not init() an engine\n";
}
}
KRun::runCommand( "tdebuildsycoca" );
KMessageBox::error( 0, i18n(
"<p>Amarok could not find any sound-engine plugins. "
"Amarok is now updating the TDE configuration database. Please wait a couple of minutes, then restart Amarok.</p>"
"<p>If this does not help, "
"it is likely that Amarok is installed under the wrong prefix, please fix your installation using:<pre>"
"$ cd /path/to/amarok/source-code/<br>"
"$ su -c \"make uninstall\"<br>"
"$ ./configure --prefix=`tde-config --prefix` && su -c \"make install\"<br>"
"$ tdebuildsycoca<br>"
"$ amarok</pre>"
"More information can be found in the README file. For further assistance join us at #amarok on irc.freenode.net.</p>" ) );
// don't use TQApplication::exit, as the eventloop may not have started yet
std::exit( EXIT_SUCCESS );
// Not executed, just here to prevent compiler warning
return 0;
}
bool EngineController::canDecode( const KURL &url ) //static
{
//NOTE this function must be thread-safe
//TODO a KFileItem version? <- presumably so we can mimetype check
const TQString fileName = url.fileName();
const TQString ext = Amarok::extension( fileName );
if ( PlaylistFile::isPlaylistFile( fileName ) ) return false;
// Ignore protocols "fetchcover" and "musicbrainz", they're not local but we don't really want them in the playlist :)
if ( url.protocol() == "fetchcover" || url.protocol() == "musicbrainz" ) return false;
// Accept non-local files, since we can't test them for validity at this point
// TODO actually, only accept unconditionally http stuff
// TODO this actually makes things like "Blarrghgjhjh:!!!" automatically get inserted
// into the playlist
// TODO remove for Amarok 1.3 and above silly checks, instead check for http type servers
if ( !url.isLocalFile() ) return true;
// If extension is already in the cache, return cache result
if ( extensionCache().contains( ext ) )
return s_extensionCache[ext];
// If file has 0 bytes, ignore it and return false, not to infect the cache with corrupt files.
// TODO also ignore files that are too small?
KFileItem f( KFileItem::Unknown, KFileItem::Unknown, url, false );
if ( !f.size() )
return false;
const bool valid = engine()->canDecode( url );
if( engine() != EngineController::instance()->m_voidEngine )
{
//we special case this as otherwise users hate us
if ( !valid && ext.lower() == "mp3"){
TQCustomEvent * e = new TQCustomEvent( 2000 );
TQApplication::postEvent( Amarok::StatusBar::instance(), e );
}
// Cache this result for the next lookup
if ( !ext.isEmpty() )
extensionCache().insert( ext, valid );
}
return valid;
}
void EngineController::unplayableNotification() {
if( !installDistroCodec(AmarokConfig::soundSystem()))
Amarok::StatusBar::instance()->longMessageThreadSafe(
i18n( "<p>The %1 claims it <b>cannot</b> play MP3 files."
"<p>You may want to choose a different engine from the <i>Configure Dialog</i>, or examine "
"the installation of the multimedia-framework that the current engine uses. "
"<p>You may find useful information in the <i>FAQ</i> section of the <i>Amarok HandBook</i>." )
.arg( AmarokConfig::soundSystem() ), KDE::StatusBar::Error );
}
bool EngineController::installDistroCodec( const TQString& engine /*Filetype type*/)
{
KService::Ptr service = TDETrader::self()->query( "Amarok/CodecInstall"
, TQString("[X-TDE-Amarok-codec] == 'mp3' and [X-TDE-Amarok-engine] == '%1'").arg(engine) ).first();
if( service )
{
TQString installScript = service->exec();
if( !installScript.isNull() ) //just a sanity check
{
KGuiItem installButton( i18n( "Install MP3 Support" ) );
if(KMessageBox::questionYesNo(PlaylistWindow::self()
, i18n("Amarok currently cannot play MP3 files.")
, i18n( "No MP3 Support" )
, installButton
, KStdGuiItem::no()
, "codecInstallWarning" ) == KMessageBox::Yes )
{
KRun::runCommand(installScript);
return true;
}
}
}
return false;
}
void EngineController::restoreSession()
{
//here we restore the session
//however, do note, this is always done, KDE session management is not involved
if( !AmarokConfig::resumeTrack().isEmpty() )
{
const KURL url = AmarokConfig::resumeTrack();
play( MetaBundle( url ), AmarokConfig::resumeTime() );
}
}
void EngineController::endSession()
{
//only update song stats, when we're not going to resume it
if ( !AmarokConfig::resumePlayback() )
{
trackEnded( trackPosition(), m_bundle.length() * 1000, "quit" );
}
PluginManager::unload( m_voidEngine );
m_voidEngine = 0;
}
//////////////////////////////////////////////////////////////////////////////////////////
// PUBLIC SLOTS
//////////////////////////////////////////////////////////////////////////////////////////
void EngineController::previous() //SLOT
{
emit orderPrevious();
}
void EngineController::next( bool forceNext ) //SLOT
{
m_previousUrl = m_bundle.url();
m_isTiming = false;
emit orderNext(forceNext);
}
void EngineController::play() //SLOT
{
if ( m_engine->state() == Engine::Paused )
{
m_engine->unpause();
}
else emit orderCurrent();
}
void EngineController::play( const MetaBundle &bundle, uint offset )
{
DEBUG_BLOCK
KURL url = bundle.url();
// don't destroy connection if we need to change station
if( url.protocol() != "lastfm" && LastFm::Controller::instance()->isPlaying() )
{
m_engine->stop();
LastFm::Controller::instance()->playbackStopped();
}
m_lastFm = false;
//Holds the time since we started trying to play non-existent files
//so we know when to abort
static TQTime failure_time;
if ( !m_playFailureCount )
failure_time.start();
debug() << "Loading URL: " << url.url() << endl;
m_lastMetadata.clear();
//TODO bummer why'd I do it this way? it should _not_ be in play!
//let Amarok know that the previous track is no longer playing
if ( m_timer->isActive() )
trackEnded( trackPosition(), m_bundle.length() * 1000, "change" );
if ( url.isLocalFile() ) {
// does the file really exist? the playlist entry might be old
if ( ! TQFile::exists( url.path()) ) {
//debug() << " file >" << url.path() << "< does not exist!" << endl;
Amarok::StatusBar::instance()->shortMessage( i18n("Local file does not exist.") );
goto some_kind_of_failure;
}
}
else
{
if( url.protocol() == "cdda" )
Amarok::StatusBar::instance()->shortMessage( i18n("Starting CD Audio track...") );
else
Amarok::StatusBar::instance()->shortMessage( i18n("Connecting to stream source...") );
debug() << "Connecting to protocol: " << url.protocol() << endl;
}
// WebDAV protocol is HTTP with extensions (and the "webdav" scheme
// is a KDE-ism anyway). Most engines cope with HTTP streaming, but
// not through TDEIO, so they don't support KDE-isms.
if ( url.protocol() == "webdav" )
url.setProtocol( "http" );
else if ( url.protocol() == "webdavs" )
url.setProtocol( "https" );
// streams from last.fm should be handled by our proxy, in order to authenticate with the server
else if ( url.protocol() == "lastfm" )
{
if( LastFm::Controller::instance()->isPlaying() )
{
if (LastFm::Controller::instance()->changeStation( url.url() ) == -1)
// Request was canceled, return immediately.
return;
connect( m_engine, TQT_SIGNAL( lastFmTrackChange() ), LastFm::Controller::instance()->getService()
, TQT_SLOT( requestMetaData() ) );
connect( LastFm::Controller::instance()->getService(), TQT_SIGNAL( metaDataResult( const MetaBundle& ) ),
this, TQT_SLOT( slotStreamMetaData( const MetaBundle& ) ) );
return;
}
else
{
url = LastFm::Controller::instance()->getNewProxy( url.url(), m_engine->lastFmProxyRequired() );
if( url.isEmpty() )
goto some_kind_of_failure;
else if ( !url.isValid() && url.url() == "lastfm://" )
// Request was canceled, return immediately.
return;
m_lastFm = true;
connect( m_engine, TQT_SIGNAL( lastFmTrackChange() ), LastFm::Controller::instance()->getService()
, TQT_SLOT( requestMetaData() ) );
connect( LastFm::Controller::instance()->getService(), TQT_SIGNAL( metaDataResult( const MetaBundle& ) ),
this, TQT_SLOT( slotStreamMetaData( const MetaBundle& ) ) );
}
debug() << "New URL is " << url.url() << endl;
}
else if (url.protocol() == "daap" )
{
KURL newUrl = MediaBrowser::instance()->getProxyUrl( url );
if( !newUrl.isEmpty() )
{
debug() << newUrl << endl;
url = newUrl;
}
else
return;
}
if( m_engine->load( url, url.protocol() == "http" || url.protocol() == "rtsp" ) )
{
//assign bundle now so that it is available when the engine
//emits stateChanged( Playing )
if( !m_bundle.url().path().isEmpty() ) //wasn't playing before
m_previousUrl = m_bundle.url();
else
m_previousUrl = bundle.url();
m_bundle = bundle;
if( m_engine->play( offset ) )
{
//Reset failure count as we are now successfully playing a song
m_playFailureCount = 0;
// Ask engine for track length, if available. It's more reliable than TagLib.
const uint trackLength = m_engine->length() / 1000;
if ( trackLength ) m_bundle.setLength( trackLength );
m_xFadeThisTrack = !m_engine->isStream() && !(url.protocol() == "cdda") &&
m_bundle.length()*1000 - offset - AmarokConfig::crossfadeLength()*2 > 0;
newMetaDataNotify( m_bundle, true /* track change */ );
return;
}
}
some_kind_of_failure:
debug() << "Failed to play this track." << endl;
++m_playFailureCount;
//Code to skip to next track if playback fails:
//
//* The failure counter is reset if a track plays successfully or if playback is
// stopped, for whatever reason.
//* For normal playback, the attempt to play is stopped at the end of the playlist
//* For repeat playlist , a whole playlist worth of songs is tried
//* For repeat album, the number of songs tried is the number of tracks from the
// album that are in the playlist.
//* For repeat track, no attempts are made
//* For the nmm engine, no attempts are made (necessary? / FIXME)
//* To prevent GUI freezes we don't try to play again after 0.5s of failure
int totalTracks = Playlist::instance()->totalTrackCount();
int currentTrack = Playlist::instance()->currentTrackIndex();
if ( ( ( Amarok::repeatPlaylist() && static_cast<int>(m_playFailureCount) < totalTracks )
|| ( Amarok::repeatNone() && currentTrack != totalTracks - 1 )
|| ( Amarok::repeatAlbum() && m_playFailureCount < Playlist::instance()->repeatAlbumTrackCount() ) )
&& AmarokConfig::soundSystem() != "nmm-engine"
&& failure_time.elapsed() < 500 )
{
debug() << "Skipping to next track." << endl;
// The test for loaded must be done _before_ next is called
if ( !m_engine->loaded() )
{
//False gives behaviour as if track played successfully
next( false );
TQTimer::singleShot( 0, this, TQT_SLOT(play()) );
}
else
{
//False gives behaviour as if track played successfully
next( false );
}
}
else
{
//Stop playback, including resetting failure count (as all new failures are
//treated as independent after playback is stopped)
stop();
}
}
void EngineController::pause() //SLOT
{
if ( m_engine->loaded() && !LastFm::Controller::instance()->isPlaying() )
m_engine->pause();
}
void EngineController::stop() //SLOT
{
//Reset failure counter as after stop, everything else is unrelated
m_playFailureCount = 0;
//let Amarok know that the previous track is no longer playing
trackEnded( trackPosition(), m_bundle.length() * 1000, "stop" );
//Remove requirement for track to be loaded for stop to be called (fixes gltiches
//where stop never properly happens if call to m_engine->load fails in play)
//if ( m_engine->loaded() )
m_engine->stop();
}
void EngineController::playPause() //SLOT
{
//this is used by the TrayIcon, PlayPauseAction and DCOP
if( m_engine->state() == Engine::Playing )
{
pause();
}
else if( m_engine->state() == Engine::Paused )
{
if ( m_engine->loaded() )
m_engine->unpause();
}
else
play();
}
void EngineController::seek( int ms ) //SLOT
{
if( bundle().length() > 0 )
{
trackPositionChangedNotify( ms, true ); /* User seek */
engine()->seek( ms );
}
}
void EngineController::seekRelative( int ms ) //SLOT
{
if( m_engine->state() != Engine::Empty )
{
int newPos = m_engine->position() + ms;
seek( newPos <= 0 ? 1 : newPos );
}
}
void EngineController::seekForward( int ms )
{
seekRelative( ms );
}
void EngineController::seekBackward( int ms )
{
seekRelative( -ms );
}
int EngineController::increaseVolume( int ticks ) //SLOT
{
return setVolume( m_engine->volume() + ticks );
}
int EngineController::decreaseVolume( int ticks ) //SLOT
{
return setVolume( m_engine->volume() - ticks );
}
int EngineController::setVolume( int percent ) //SLOT
{
m_muteVolume = 0;
if( percent < 0 ) percent = 0;
if( percent > 100 ) percent = 100;
if( (uint)percent != m_engine->volume() )
{
m_engine->setVolume( (uint)percent );
percent = m_engine->volume();
AmarokConfig::setMasterVolume( percent );
volumeChangedNotify( percent );
return percent;
}
else // Still notify
{
volumeChangedNotify( percent );
}
return m_engine->volume();
}
void EngineController::mute() //SLOT
{
if( m_muteVolume == 0 )
{
int saveVolume = m_engine->volume();
setVolume( 0 );
m_muteVolume = saveVolume;
}
else
{
setVolume( m_muteVolume );
m_muteVolume = 0;
}
}
const MetaBundle&
EngineController::bundle() const
{
static MetaBundle null;
return m_engine->state() == Engine::Empty ? null : m_bundle;
}
void EngineController::slotStreamMetaData( const MetaBundle &bundle ) //SLOT
{
// Prevent spamming by ignoring repeated identical data (some servers repeat it every 10 seconds)
if ( m_lastMetadata.contains( bundle ) )
return;
// We compare the new item with the last two items, because mth.house currently cycles
// two messages alternating, which gets very annoying
if ( m_lastMetadata.count() == 2 )
m_lastMetadata.pop_front();
m_lastMetadata << bundle;
m_previousUrl = m_bundle.url();
m_bundle = bundle;
m_lastPositionOffset = m_positionOffset;
if( m_lastFm )
m_positionOffset = m_engine->position();
else
m_positionOffset = 0;
newMetaDataNotify( m_bundle, false /* not a new track */ );
}
void EngineController::currentTrackMetaDataChanged( const MetaBundle& bundle )
{
m_previousUrl = m_bundle.url();
m_bundle = bundle;
newMetaDataNotify( bundle, false /* no track change */ );
}
//////////////////////////////////////////////////////////////////////////////////////////
// PRIVATE SLOTS
//////////////////////////////////////////////////////////////////////////////////////////
void EngineController::slotEngineMetaData( const Engine::SimpleMetaBundle &simpleBundle ) //SLOT
{
if ( !m_bundle.url().isLocalFile() )
{
MetaBundle bundle = m_bundle;
bundle.setArtist( simpleBundle.artist );
bundle.setTitle( simpleBundle.title );
bundle.setComment( simpleBundle.comment );
bundle.setAlbum( simpleBundle.album );
if( !simpleBundle.genre.isEmpty() )
bundle.setGenre( simpleBundle.genre );
if( !simpleBundle.bitrate.isEmpty() )
bundle.setBitrate( simpleBundle.bitrate.toInt() );
if( !simpleBundle.samplerate.isEmpty() )
bundle.setSampleRate( simpleBundle.samplerate.toInt() );
if( !simpleBundle.year.isEmpty() )
bundle.setYear( simpleBundle.year.toInt() );
if( !simpleBundle.tracknr.isEmpty() )
bundle.setTrack( simpleBundle.tracknr.toInt() );
slotStreamMetaData( bundle );
}
}
void EngineController::slotMainTimer() //SLOT
{
const uint position = trackPosition();
trackPositionChangedNotify( position );
// Crossfading
if ( m_engine->state() == Engine::Playing &&
AmarokConfig::crossfade() && m_xFadeThisTrack &&
m_engine->hasPluginProperty( "HasCrossfade" ) &&
Playlist::instance()->stopAfterMode() != Playlist::StopAfterCurrent &&
( (uint) AmarokConfig::crossfadeType() == 0 || //Always or...
(uint) AmarokConfig::crossfadeType() == 1 ) && //...automatic track change only
Playlist::instance()->isTrackAfter() &&
m_bundle.length()*1000 - position < (uint) AmarokConfig::crossfadeLength() )
{
debug() << "Crossfading to next track...\n";
m_engine->setXFadeNextTrack( true );
trackFinished();
}
else if ( m_engine->state() == Engine::Playing &&
AmarokConfig::fadeout() &&
Playlist::instance()->stopAfterMode() == Playlist::StopAfterCurrent &&
m_bundle.length()*1000 - position < (uint) AmarokConfig::fadeoutLength() )
{
m_engine->stop();
}
}
void EngineController::slotTrackEnded() //SLOT
{
if ( AmarokConfig::trackDelayLength() > 0 )
{
//FIXME not perfect
if ( !m_isTiming )
{
TQTimer::singleShot( AmarokConfig::trackDelayLength(), this, TQT_SLOT(trackFinished()) );
m_isTiming = true;
}
}
else trackFinished();
}
void EngineController::slotStateChanged( Engine::State newState ) //SLOT
{
switch( newState )
{
case Engine::Empty:
//FALL THROUGH...
case Engine::Paused:
m_timer->stop();
break;
case Engine::Playing:
m_timer->start( MAIN_TIMER );
break;
default:
;
}
stateChangedNotify( newState );
}
uint EngineController::trackPosition() const
{
const uint buffertime = 5000; // worked for me with xine engine over 1 mbit dsl
if( !m_engine )
return 0;
uint pos = m_engine->position();
if( !m_lastFm )
return pos;
if( m_positionOffset + buffertime <= pos )
return pos - m_positionOffset - buffertime;
if( m_lastPositionOffset + buffertime <= pos )
return pos - m_lastPositionOffset - buffertime;
return pos;
}
#include "enginecontroller.moc"