--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/3rdparty/phonon/qt7/audiograph.mm Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,320 @@
+/* This file is part of the KDE project.
+
+ Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+
+ This library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2.1 or 3 of the License.
+
+ This library 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 Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "audiograph.h"
+#include "quicktimeaudioplayer.h"
+#include "medianode.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace Phonon
+{
+namespace QT7
+{
+
+AudioGraph::AudioGraph(MediaNode *root) : MediaNode(AudioGraphNode, 0, root), m_root(root)
+{
+ m_audioGraphRef = 0;
+ m_initialized = false;
+ m_startedLogically = false;
+ m_graphCannotPlay = false;
+ m_paused = false;
+}
+
+AudioGraph::~AudioGraph()
+{
+ deleteGraph();
+}
+
+void AudioGraph::startAllOverFromScratch()
+{
+ MediaNodeEvent event(MediaNodeEvent::AudioGraphAboutToBeDeleted, this);
+ m_root->notify(&event);
+ deleteGraph();
+}
+
+void AudioGraph::deleteGraph()
+{
+ if (m_audioGraphRef){
+ AUGraphStop(m_audioGraphRef);
+ AUGraphUninitialize(m_audioGraphRef);
+ AUGraphClose(m_audioGraphRef);
+ DisposeAUGraph(m_audioGraphRef);
+ m_initialized = false;
+ m_graphCannotPlay = false;
+ DEBUG_AUDIO_GRAPH("Graph ref in" << int(this) << "is deleted")
+ }
+}
+
+MediaNode *AudioGraph::root()
+{
+ return m_root;
+}
+
+AUGraph AudioGraph::audioGraphRef()
+{
+ return m_audioGraphRef;
+}
+
+void AudioGraph::setStatusCannotPlay()
+{
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "received 'cannot play' request")
+ if (!m_graphCannotPlay){
+ stop();
+ m_graphCannotPlay = true;
+ MediaNodeEvent e(MediaNodeEvent::AudioGraphCannotPlay, this);
+ m_root->notify(&e);
+ }
+}
+
+void AudioGraph::rebuildGraph()
+{
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "is rebuilding")
+ startAllOverFromScratch();
+ if (!openAndInit()){
+ setStatusCannotPlay();
+ } else {
+ tryStartGraph();
+ m_graphCannotPlay = false;
+ }
+}
+
+bool AudioGraph::graphCannotPlay()
+{
+ return m_graphCannotPlay;
+}
+
+void AudioGraph::updateStreamSpecifications()
+{
+ if (!m_initialized){
+ if (m_graphCannotPlay)
+ rebuildGraph();
+ return;
+ }
+
+ AudioConnection rootConnection(m_root);
+ bool updateOk = updateStreamSpecificationRecursive(&rootConnection);
+ if (!updateOk){
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "could not update stream specification. Rebuild.")
+ rebuildGraph();
+ }
+}
+
+bool AudioGraph::updateStreamSpecificationRecursive(AudioConnection *connection)
+{
+ bool updateOk = connection->updateStreamSpecification();
+ if (!updateOk)
+ return false;
+
+ for (int i=0; i<connection->m_sink->m_audioSinkList.size(); ++i){
+ if (!updateStreamSpecificationRecursive(connection->m_sink->m_audioSinkList[i]))
+ return false;
+ }
+ return true;
+}
+
+bool AudioGraph::openAndInit()
+{
+ OSStatus err;
+ err = NewAUGraph(&m_audioGraphRef);
+ BACKEND_ASSERT3(err == noErr, "Could not create audio graph.", NORMAL_ERROR, false)
+
+ MediaNodeEvent eventNew(MediaNodeEvent::NewAudioGraph, this);
+ m_root->notify(&eventNew);
+
+ AudioConnection rootConnection(m_root);
+ createAndConnectAuNodesRecursive(&rootConnection);
+ err = AUGraphOpen(m_audioGraphRef);
+ BACKEND_ASSERT3(err == noErr, "Could not create audio graph.", NORMAL_ERROR, false)
+
+ if (!createAudioUnitsRecursive(&rootConnection))
+ return false;
+
+ err = AUGraphInitialize(m_audioGraphRef);
+ BACKEND_ASSERT3(err == noErr, "Could not initialize audio graph.", NORMAL_ERROR, false)
+
+ m_initialized = true;
+ MediaNodeEvent eventInit(MediaNodeEvent::AudioGraphInitialized, this);
+ m_root->notify(&eventInit);
+ return true;
+}
+
+void AudioGraph::createAndConnectAuNodesRecursive(AudioConnection *connection)
+{
+ connection->m_sink->m_audioNode->createAndConnectAUNodes();
+ for (int i=0; i<connection->m_sink->m_audioSinkList.size(); ++i){
+ AudioConnection *c = connection->m_sink->m_audioSinkList[i];
+ createAndConnectAuNodesRecursive(c);
+ bool ok = c->connect(this);
+ BACKEND_ASSERT2(ok, "Could not connect an audio nodes pair in the audio graph.", NORMAL_ERROR)
+ }
+}
+
+bool AudioGraph::createAudioUnitsRecursive(AudioConnection *connection)
+{
+ connection->m_sink->m_audioNode->createAudioUnits();
+ bool ok = connection->updateStreamSpecification();
+ if (!ok)
+ return false;
+ for (int i=0; i<connection->m_sink->m_audioSinkList.size(); ++i){
+ if (!createAudioUnitsRecursive(connection->m_sink->m_audioSinkList[i]))
+ return false;
+ }
+ return true;
+}
+
+void AudioGraph::tryStartGraph()
+{
+ // The graph will only start if the background AUGraph
+ // is valid. Therefore we just try. If it fails, user
+ // actions like connect etc. migh make the graph valid
+ // at a later point.
+ if (m_startedLogically && !isRunning()){
+ OSStatus err = AUGraphStart(m_audioGraphRef);
+ if (err == noErr)
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "started")
+ else
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "could not start")
+ }
+}
+
+bool AudioGraph::isRunning()
+{
+ Boolean running = false;
+ AUGraphIsRunning(m_audioGraphRef, &running);
+ return running;
+}
+
+void AudioGraph::setPaused(bool pause)
+{
+ // This function should only make
+ // a difference if the graph is
+ // running before pausing.
+ if (pause){
+ if (isRunning()){
+ stop();
+ m_paused = true;
+ }
+ } else if (m_paused){
+ start();
+ m_paused = false;
+ }
+}
+
+void AudioGraph::connectLate(AudioConnection *connection)
+{
+ MediaNodeEvent event(MediaNodeEvent::NewAudioGraph, this);
+ connection->m_sink->notify(&event);
+
+ if (!m_initialized)
+ return;
+
+ DEBUG_AUDIO_GRAPH("Graph:" << int(this) << "create and connect audio sink after init:" << int(connection->m_sink->m_audioNode))
+ AudioConnection startConnection(connection->m_source);
+ createAndConnectAuNodesRecursive(&startConnection);
+
+ if (!createAudioUnitsRecursive(&startConnection)){
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "could not update stream specification. Rebuild.")
+ rebuildGraph();
+ }
+}
+
+void AudioGraph::disconnectLate(AudioConnection *connection)
+{
+ if (!m_initialized)
+ return;
+
+ DEBUG_AUDIO_GRAPH("Graph:" << int(this) << "disconnect audio sink after init:" << int(connection->m_sink->m_audioNode))
+
+ if (!connection->disconnect(this)){
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "could not disconnect audio sink. Rebuild.")
+ rebuildGraph();
+ }
+}
+
+void AudioGraph::update()
+{
+ if (m_startedLogically){
+ if (m_initialized){
+ // Quick solution:
+ AUGraphUpdate(m_audioGraphRef, 0);
+ tryStartGraph();
+ } else
+ rebuildGraph();
+ }
+}
+
+int AudioGraph::nodeCount()
+{
+ if (!m_audioGraphRef)
+ return 0;
+ UInt32 count;
+ AUGraphGetNodeCount(m_audioGraphRef, &count);
+ return int(count);
+}
+
+void AudioGraph::prepare()
+{
+ if (!m_initialized)
+ rebuildGraph();
+}
+
+void AudioGraph::start()
+{
+ // Start does not mean 'start to play
+ // music'. It means 'prepare to receive
+ // audio from the player units'.
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "asked to start (cannot play:" << m_graphCannotPlay << ")")
+ m_startedLogically = true;
+
+ if (m_graphCannotPlay)
+ return;
+
+ if (!m_initialized)
+ rebuildGraph();
+
+ if (!m_graphCannotPlay)
+ tryStartGraph();
+}
+
+void AudioGraph::stop()
+{
+ DEBUG_AUDIO_GRAPH("Graph" << int(this) << "asked to stop")
+ if (m_audioGraphRef)
+ AUGraphStop(m_audioGraphRef);
+ m_startedLogically = false;
+}
+
+void AudioGraph::notify(const MediaNodeEvent *event, bool propagate)
+{
+ switch (event->type()){
+ case MediaNodeEvent::StartConnectionChange:
+ if (m_graphCannotPlay)
+ startAllOverFromScratch();
+ break;
+ case MediaNodeEvent::EndConnectionChange:
+ update();
+ break;
+ default:
+ break;
+ }
+ m_root->notify(event, propagate);
+}
+
+}} // namespace Phonon::QT7
+
+QT_END_NAMESPACE