kworship/media/KwMediaManager.cpp

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file KwMediaManager.cpp
  22  * @brief Media management interface.
  23  * @author James Hogan <james@albanarts.com>
  24  */
  25
  26 #include "KwMediaManager.h"
  27 #include "KwMediaPreferencesSequence.h"
  28 #include "KwMediaPreferencesAudio.h"
  29 #include "KwMediaPreferencesVisual.h"
  30
  31 #include <phonon/mediaobject.h>
  32 #include <phonon/audiooutput.h>
  33 #include <phonon/videowidget.h>
  34
  35 #include <cassert>
  36
  37 /*
  38  * Constructors + destructors
  39  */
  40
  41 /// Default constructor.
  42 KwMediaManager::KwMediaManager()
  43 : m_audio()
  44 , m_video()
  45 {
  46 }
  47
  48 /// Destructor.
  49 KwMediaManager::~KwMediaManager()
  50 {
  51   stopAll();
  52 }
  53
  54 /*
  55  * Output linking
  56  */
  57
  58 /// Link the audio to an audio output.
  59 void KwMediaManager::linkAudio(KwAudioOutput* audioOut)
  60 {
  61   Phonon::Path path;
  62   if (isAudio())
  63   {
  64     path = Phonon::createPath(m_audio.object, audioOut);
  65     assert(path.isValid());
  66     connectAudioOutput(audioOut);
  67   }
  68   m_audio.outputs.insert(audioOut, path);
  69 }
  70
  71 /// Unlink an audio output.
  72 void KwMediaManager::unlinkAudio(KwAudioOutput* audioOut)
  73 {
  74   NowPlayingDataAudio::Outputs::iterator it = m_audio.outputs.find(audioOut);
  75   if (isAudio())
  76   {
  77     assert((*it).isValid());
  78     (*it).disconnect();
  79     disconnectAudioOutput(audioOut);
  80   }
  81   m_audio.outputs.erase(it);
  82 }
  83
  84 /// Link the video to a video output.
  85 void KwMediaManager::linkVideo(KwVideoWidget* videoOut)
  86 {
  87   Phonon::Path path;
  88   if (isVideo())
  89   {
  90     path = Phonon::createPath(m_video.object, videoOut);
  91     assert(path.isValid());
  92     connectVideoOutput(videoOut);
  93   }
  94   m_video.outputs.insert(videoOut, path);
  95 }
  96
  97 /// Unlink a video output.
  98 void KwMediaManager::unlinkVideo(KwVideoWidget* videoOut)
  99 {
 100   NowPlayingDataVideo::Outputs::iterator it = m_video.outputs.find(videoOut);
 101   if (isVideo())
 102   {
 103     assert((*it).isValid());
 104     (*it).disconnect();
 105     disconnectVideoOutput(videoOut);
 106   }
 107   m_video.outputs.erase(it);
 108 }
 109
 110 /*
 111  * Starter methods
 112  */
 113
 114 /// Set up some audio.
 115 KwMediaObject* KwMediaManager::setupAudio(const QUrl& url, KwMediaPreferencesSequence* prefsSequence, KwMediaPreferencesAudio* prefsAudio)
 116 {
 117   assert(prefsSequence != 0);
 118   assert(prefsAudio != 0);
 119
 120   KwMediaObject* mediaObject = new KwMediaObject;
 121   mediaObject->setCurrentSource(url);
 122
 123   stopAudio(false);
 124   m_audio.object = mediaObject;
 125   m_audio.prefsSequence = prefsSequence;
 126   m_audio.prefs = prefsAudio;
 127
 128   prefsSequence->setManager(this);
 129   prefsAudio->setManager(this);
 130
 131   // Link media object to audio outputs
 132   NowPlayingDataAudio::Outputs::iterator it;
 133   for (it = m_audio.outputs.begin(); it != m_audio.outputs.end(); ++it)
 134   {
 135     *it = Phonon::createPath(mediaObject, it.key());
 136     assert((*it).isValid());
 137     connectAudioOutput(it.key());
 138   }
 139
 140   connectAudioObject();
 141
 142   audioAdded(false);
 143
 144   return mediaObject;
 145 }
 146
 147 /// Set up some video.
 148 KwMediaObject* KwMediaManager::setupVideo(const QUrl& url, KwMediaPreferencesSequence* prefsSequence, KwMediaPreferencesVisual* prefsVideo, KwMediaPreferencesAudio* prefsAudio)
 149 {
 150   assert(prefsSequence != 0);
 151   assert(prefsVideo != 0);
 152
 153   // Stop audio iff new video has audio
 154   stopVideo(prefsAudio != 0);
 155
 156   KwMediaObject* mediaObject = new KwMediaObject;
 157   mediaObject->setCurrentSource(url);
 158   m_video.object = mediaObject;
 159   m_video.prefsSequence = prefsSequence;
 160   m_video.prefs = prefsVideo;
 161
 162   prefsSequence->setManager(this);
 163   prefsVideo->setManager(this);
 164
 165   // Link media object to video widgets
 166   NowPlayingDataVideo::Outputs::iterator it;
 167   for (it = m_video.outputs.begin(); it != m_video.outputs.end(); ++it)
 168   {
 169     *it = Phonon::createPath(mediaObject, it.key());
 170     assert((*it).isValid());
 171     connectVideoOutput(it.key());
 172   }
 173
 174   connectVideoObject();
 175
 176   // Keep audio playing if we don't want audio from this video
 177   if (prefsAudio != 0)
 178   {
 179     stopAudio(false);
 180     m_audio.object = mediaObject;
 181     m_audio.prefsSequence = prefsSequence;
 182     m_audio.prefs = prefsAudio;
 183
 184     prefsAudio->setManager(this);
 185
 186     // Link media object to audio outputs
 187     NowPlayingDataAudio::Outputs::iterator it;
 188     for (it = m_audio.outputs.begin(); it != m_audio.outputs.end(); ++it)
 189     {
 190       *it = Phonon::createPath(mediaObject, it.key());
 191       assert((*it).isValid());
 192       connectAudioOutput(it.key());
 193     }
 194
 195     connectAudioObject();
 196     audioAdded(true);
 197   }
 198   videoAdded(prefsAudio != 0);
 199
 200   return mediaObject;
 201 }
 202
 203 /*
 204  * Stopper methods
 205  */
 206
 207 /// Stop all playing media.
 208 void KwMediaManager::stopAll()
 209 {
 210   stopAudio();
 211   stopVideo();
 212 }
 213
 214 /// Stop any playing audio.
 215 void KwMediaManager::stopAudio(bool stopLinkedVideo)
 216 {
 217   if (isAudio())
 218   {
 219     disconnectAudioObject();
 220     bool linked = isLinked();
 221     audioRemoved(linked && stopLinkedVideo);
 222     if (!linked)
 223     {
 224       delete m_audio.object;
 225     }
 226     else if (!stopLinkedVideo)
 227     {
 228       // If we're not deleting object and it remains in use, unlink audio
 229       NowPlayingDataAudio::Outputs::iterator it;
 230       for (it = m_audio.outputs.begin(); it != m_audio.outputs.end(); ++it)
 231       {
 232         assert((*it).isValid());
 233         (*it).disconnect();
 234         disconnectAudioOutput(it.key());
 235       }
 236     }
 237     m_audio.object = 0;
 238     m_audio.prefsSequence->setManager(0);
 239     m_audio.prefsSequence = 0;
 240     m_audio.prefs->setManager(0);
 241     m_audio.prefs = 0;
 242     if (linked && stopLinkedVideo)
 243     {
 244       stopVideo(false);
 245     }
 246   }
 247 }
 248
 249 /// Stop any playing video.
 250 void KwMediaManager::stopVideo(bool stopLinkedAudio)
 251 {
 252   if (isVideo())
 253   {
 254     disconnectVideoObject();
 255     bool linked = isLinked();
 256     videoRemoved(linked && stopLinkedAudio);
 257     if (!linked)
 258     {
 259       delete m_video.object;
 260     }
 261     else if (!stopLinkedAudio)
 262     {
 263       // If we're not deleting object and it remains in use, unlink audio
 264       NowPlayingDataVideo::Outputs::iterator it;
 265       for (it = m_video.outputs.begin(); it != m_video.outputs.end(); ++it)
 266       {
 267         assert((*it).isValid());
 268         bool disconnected = (*it).disconnect();
 269         Q_UNUSED(disconnected);
 270         assert(disconnected);
 271         disconnectVideoOutput(it.key());
 272       }
 273     }
 274     m_video.object = 0;
 275     m_video.prefsSequence->setManager(0);
 276     m_video.prefsSequence = 0;
 277     m_video.prefs->setManager(0);
 278     m_video.prefs = 0;
 279     if (linked && stopLinkedAudio)
 280     {
 281       stopAudio(false);
 282     }
 283   }
 284 }
 285
 286 /*
 287  * Accessors
 288  */
 289
 290 /// Get the audio object.
 291 KwMediaObject* KwMediaManager::getAudioObject()
 292 {
 293   return m_audio.object;
 294 }
 295
 296 /// Get the video object.
 297 KwMediaObject* KwMediaManager::getVideoObject()
 298 {
 299   return m_video.object;
 300 }
 301
 302 /// Is linked?
 303 bool KwMediaManager::isLinked() const
 304 {
 305   return m_audio.object != 0 && m_audio.object == m_video.object;
 306 }
 307
 308 /// Is audio playing?
 309 bool KwMediaManager::isAudio() const
 310 {
 311   return m_audio.object != 0;
 312 }
 313
 314 /// Is video playing?
 315 bool KwMediaManager::isVideo() const
 316 {
 317   return m_video.object != 0;
 318 }
 319
 320 /*
 321  * Media control slots
 322  */
 323
 324 /// Play/pause audio.
 325 void KwMediaManager::audioPlayPause()
 326 {
 327   if (isAudio())
 328   {
 329     switch (m_audio.object->state())
 330     {
 331       case Phonon::PlayingState:
 332       case Phonon::BufferingState:
 333         m_audio.object->pause();
 334         break;
 335
 336       case Phonon::StoppedState:
 337       case Phonon::PausedState:
 338         m_audio.object->play();
 339         break;
 340
 341       default:
 342         break;
 343     }
 344   }
 345 }
 346
 347 /// Play/pause video.
 348 void KwMediaManager::videoPlayPause()
 349 {
 350   if (isVideo())
 351   {
 352     switch (m_video.object->state())
 353     {
 354       case Phonon::PlayingState:
 355       case Phonon::BufferingState:
 356         m_video.object->pause();
 357         break;
 358
 359       case Phonon::StoppedState:
 360       case Phonon::PausedState:
 361         m_video.object->play();
 362         break;
 363
 364       default:
 365         break;
 366     }
 367   }
 368 }
 369
 370 /// Stop audio.
 371 void KwMediaManager::audioStop()
 372 {
 373   if (isAudio())
 374   {
 375     m_audio.object->stop();
 376   }
 377 }
 378
 379 /// Stop video.
 380 void KwMediaManager::videoStop()
 381 {
 382   if (isVideo())
 383   {
 384     m_video.object->stop();
 385   }
 386 }
 387
 388 /*
 389  * Private slots
 390  */
 391
 392 /// The audio object's metadata has changed.
 393 void KwMediaManager::audioMetaDataHasChanged()
 394 {
 395   assert(isAudio());
 396
 397   QStringList title = m_audio.object->metaData("TITLE");
 398   if (!title.empty())
 399   {
 400     audioMediaNameChanged(title.first());
 401   }
 402   else
 403   {
 404     audioMediaNameChanged("");
 405   }
 406 }
 407
 408 /// The video object's metadata has changed.
 409 void KwMediaManager::videoMetaDataHasChanged()
 410 {
 411   assert(isVideo());
 412
 413   QStringList title = m_video.object->metaData("TITLE");
 414   if (!title.empty())
 415   {
 416     videoMediaNameChanged(title.first());
 417   }
 418   else
 419   {
 420     videoMediaNameChanged("");
 421   }
 422 }
 423
 424 /*
 425  * Internal functions
 426  */
 427
 428 /// Make the internal connections for a new media object.
 429 void KwMediaManager::connectAudioObject()
 430 {
 431   // Sequence
 432   assert(m_audio.object != 0);
 433   connect(m_audio.object, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SIGNAL(audioStateChanged(Phonon::State,Phonon::State)));
 434   connect(m_audio.object, SIGNAL(metaDataChanged()), this, SLOT(audioMetaDataHasChanged()));
 435   // Audio
 436   assert(m_audio.prefs != 0);
 437   connect(this, SIGNAL(setVolume(qreal)), m_audio.prefs, SLOT(setVolume(qreal)));
 438   connect(this, SIGNAL(setMuted(bool)), m_audio.prefs, SLOT(setMuted(bool)));
 439   connect(this, SIGNAL(setFadeoutMsec(qint32)), m_audio.prefs, SLOT(setFadeoutMsec(qint32)));
 440   connect(m_audio.prefs, SIGNAL(volumeChanged(qreal)), this, SIGNAL(volumeChanged(qreal)));
 441   connect(m_audio.prefs, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
 442
 443   volumeChanged(m_audio.prefs->getVolume());
 444   mutedChanged(m_audio.prefs->getMuted());
 445 }
 446
 447 /// Remove the internal connections for an old media object.
 448 void KwMediaManager::disconnectAudioObject()
 449 {
 450   // Sequence
 451   assert(m_audio.object != 0);
 452   disconnect(m_audio.object, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SIGNAL(audioStateChanged(Phonon::State,Phonon::State)));
 453   disconnect(m_audio.object, SIGNAL(metaDataChanged()), this, SLOT(audioMetaDataHasChanged()));
 454   // Audio
 455   assert(m_audio.prefs != 0);
 456   disconnect(this, SIGNAL(setVolume(qreal)), m_audio.prefs, SLOT(setVolume(qreal)));
 457   disconnect(this, SIGNAL(setMuted(bool)), m_audio.prefs, SLOT(setMuted(bool)));
 458   disconnect(this, SIGNAL(setFadeoutMsec(qint32)), m_audio.prefs, SLOT(setFadeoutMsec(qint32)));
 459   disconnect(m_audio.prefs, SIGNAL(volumeChanged(qreal)), this, SIGNAL(volumeChanged(qreal)));
 460   disconnect(m_audio.prefs, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
 461 }
 462
 463 /// Make the internal connections for a new video object.
 464 void KwMediaManager::connectVideoObject()
 465 {
 466   connect(m_video.object, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SIGNAL(videoStateChanged(Phonon::State,Phonon::State)));
 467   connect(m_video.object, SIGNAL(metaDataChanged()), this, SLOT(videoMetaDataHasChanged()));
 468 }
 469
 470 /// Remove the internal connections for an old video object.
 471 void KwMediaManager::disconnectVideoObject()
 472 {
 473   disconnect(m_video.object, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SIGNAL(videoStateChanged(Phonon::State,Phonon::State)));
 474   disconnect(m_video.object, SIGNAL(metaDataChanged()), this, SLOT(videoMetaDataHasChanged()));
 475 }
 476
 477 /// Make the internal connections for a new audio ouptut.
 478 void KwMediaManager::connectAudioOutput(KwAudioOutput* output)
 479 {
 480   assert(m_audio.prefs != 0);
 481   connect(m_audio.prefs, SIGNAL(volumeChanged(qreal)), output, SLOT(setVolume(qreal)));
 482   connect(m_audio.prefs, SIGNAL(mutedChanged(bool)), output, SLOT(setMuted(bool)));
 483 }
 484
 485 /// Remove the internal connections for an old audio output.
 486 void KwMediaManager::disconnectAudioOutput(KwAudioOutput* output)
 487 {
 488   assert(m_audio.prefs != 0);
 489   disconnect(m_audio.prefs, SIGNAL(volumeChanged(qreal)), output, SLOT(setVolume(qreal)));
 490   disconnect(m_audio.prefs, SIGNAL(mutedChanged(bool)), output, SLOT(setMuted(bool)));
 491 }
 492
 493 /// Make the internal connections for a new video ouptut.
 494 void KwMediaManager::connectVideoOutput(KwVideoWidget* output)
 495 {
 496   Q_UNUSED(output);
 497   assert(isVideo());
 498 }
 499
 500 /// Remove the internal connections for an old video output.
 501 void KwMediaManager::disconnectVideoOutput(KwVideoWidget* output)
 502 {
 503   Q_UNUSED(output);
 504   assert(isVideo());
 505 }
 506