| /* 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 <QtCore/QVector> |
| #include <QtCore/QTimerEvent> |
| #include <QtCore/QTimer> |
| #include <QtCore/QTime> |
| #include <QtCore/QLibrary> |
| |
| #ifndef Q_CC_MSVC |
| #include <dshow.h> |
| #endif |
| #include <objbase.h> |
| #include <initguid.h> |
| #include <qnetwork.h> |
| #ifdef Q_CC_MSVC |
| # include <comdef.h> |
| #endif |
| #include <evcode.h> |
| |
| #include "mediaobject.h" |
| #include "videowidget.h" |
| #include "audiooutput.h" |
| |
| |
| #include <QtCore/QDebug> |
| |
| #define TIMER_INTERVAL 16 //... ms for the timer that polls the current state (we use the multimedia timer) |
| #define PRELOAD_TIME 2000 // 2 seconds to load a source |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace Phonon |
| { |
| namespace DS9 |
| { |
| typedef BOOL (WINAPI* LPAMGETERRORTEXT)(HRESULT, WCHAR *, DWORD); |
| |
| //first the definition of the WorkerThread class |
| WorkerThread::WorkerThread() |
| : QThread(), m_finished(false), m_currentWorkId(1) |
| { |
| } |
| |
| WorkerThread::~WorkerThread() |
| { |
| } |
| |
| void WorkerThread::run() |
| { |
| while (m_finished == false) { |
| HANDLE handles[FILTER_COUNT +1]; |
| handles[0] = m_waitCondition; |
| int count = 1; |
| for(int i = 0; i < FILTER_COUNT; ++i) { |
| if (m_graphHandle[i].graph) { |
| handles[count++] = m_graphHandle[i].handle; |
| } |
| } |
| DWORD result = ::WaitForMultipleObjects(count, handles, FALSE, INFINITE); |
| if (result == WAIT_OBJECT_0) { |
| handleTask(); |
| } else { |
| //this is the event management |
| const Graph &graph = m_graphHandle[result - WAIT_OBJECT_0 - 1].graph; |
| long eventCode; |
| LONG_PTR param1, param2; |
| |
| ComPointer<IMediaEvent> mediaEvent(graph, IID_IMediaEvent); |
| mediaEvent->GetEvent(&eventCode, ¶m1, ¶m2, 0); |
| emit eventReady(graph, eventCode, param1); |
| mediaEvent->FreeEventParams(eventCode, param1, param2); |
| } |
| } |
| } |
| |
| //wants to know as soon as the state is set |
| void WorkerThread::addStateChangeRequest(Graph graph, OAFilterState state, QList<Filter> decoders) |
| { |
| QMutexLocker locker(&m_mutex); |
| bool found = false; |
| //we try to see if there is already an attempt to change the state and we remove it |
| for(int i = 0; !found && i < m_queue.size(); ++i) { |
| const Work &w = m_queue.at(i); |
| if (w.graph == graph && w.task == ChangeState) { |
| found = true; |
| m_queue.removeAt(i); |
| } |
| } |
| |
| //now let's create the new task |
| Work w; |
| w.task = ChangeState; |
| w.id = m_currentWorkId++; |
| w.graph = graph; |
| w.state = state; |
| w.decoders = decoders; |
| m_queue.enqueue(w); |
| m_waitCondition.set(); |
| } |
| |
| quint16 WorkerThread::addSeekRequest(Graph graph, qint64 time) |
| { |
| QMutexLocker locker(&m_mutex); |
| bool found = false; |
| //we try to see if there is already an attempt to seek and we remove it |
| for(int i = 0; !found && i < m_queue.size(); ++i) { |
| const Work &w = m_queue.at(i); |
| if (w.graph == graph && w.task == Seek) { |
| found = true; |
| m_queue.removeAt(i); |
| } |
| } |
| |
| Work w; |
| w.task = Seek; |
| //we create a new graph |
| w.graph = graph; |
| w.id = m_currentWorkId++; |
| w.time = time; |
| m_queue.enqueue(w); |
| m_waitCondition.set(); |
| return w.id; |
| } |
| |
| quint16 WorkerThread::addUrlToRender(const QString &url) |
| { |
| QMutexLocker locker(&m_mutex); |
| Work w; |
| w.task = Render; |
| //we create a new graph |
| w.graph = Graph(CLSID_FilterGraph, IID_IGraphBuilder); |
| w.url = url; |
| w.url.detach(); |
| w.id = m_currentWorkId++; |
| m_queue.enqueue(w); |
| m_waitCondition.set(); |
| return w.id; |
| } |
| |
| quint16 WorkerThread::addFilterToRender(const Filter &filter) |
| { |
| QMutexLocker locker(&m_mutex); |
| Work w; |
| w.task = Render; |
| //we create a new graph |
| w.graph = Graph(CLSID_FilterGraph, IID_IGraphBuilder); |
| w.filter = filter; |
| w.graph->AddFilter(filter, 0); |
| w.id = m_currentWorkId++; |
| m_queue.enqueue(w); |
| m_waitCondition.set(); |
| return w.id; |
| } |
| |
| void WorkerThread::replaceGraphForEventManagement(Graph newGraph, Graph oldGraph) |
| { |
| QMutexLocker locker(&m_mutex); |
| Work w; |
| w.task = ReplaceGraph; |
| w.graph = newGraph; |
| w.oldGraph = oldGraph; |
| m_queue.enqueue(w); |
| m_waitCondition.set(); |
| } |
| |
| void WorkerThread::handleTask() |
| { |
| QMutexLocker locker(Backend::directShowMutex); |
| { |
| QMutexLocker locker(&m_mutex); |
| if (m_finished || m_queue.isEmpty()) { |
| return; |
| } |
| |
| m_currentWork = m_queue.dequeue(); |
| |
| //we ensure to have the wait condition in the right state |
| if (m_queue.isEmpty()) { |
| m_waitCondition.reset(); |
| } else { |
| m_waitCondition.set(); |
| } |
| } |
| |
| HRESULT hr = S_OK; |
| |
| if (m_currentWork.task == ReplaceGraph) { |
| int index = -1; |
| for(int i = 0; i < FILTER_COUNT; ++i) { |
| if (m_graphHandle[i].graph == m_currentWork.oldGraph) { |
| m_graphHandle[i].graph = Graph(); |
| index = i; |
| break; |
| } else if (index == -1 && m_graphHandle[i].graph == 0) { |
| //this is the first available slot |
| index = i; |
| } |
| } |
| |
| Q_ASSERT(index != -1); |
| |
| //add the new graph |
| HANDLE h; |
| if (SUCCEEDED(ComPointer<IMediaEvent>(m_currentWork.graph, IID_IMediaEvent) |
| ->GetEventHandle(reinterpret_cast<OAEVENT*>(&h)))) { |
| m_graphHandle[index].graph = m_currentWork.graph; |
| m_graphHandle[index].handle = h; |
| } |
| } else if (m_currentWork.task == Render) { |
| if (m_currentWork.filter) { |
| //let's render pins |
| const QList<OutputPin> outputs = BackendNode::pins(m_currentWork.filter, PINDIR_OUTPUT); |
| for (int i = 0; SUCCEEDED(hr) && i < outputs.count(); ++i) { |
| hr = m_currentWork.graph->Render(outputs.at(i)); |
| } |
| } else if (!m_currentWork.url.isEmpty()) { |
| //let's render a url (blocking call) |
| hr = m_currentWork.graph->RenderFile(reinterpret_cast<const wchar_t *>(m_currentWork.url.utf16()), 0); |
| } |
| if (hr != E_ABORT) { |
| emit asyncRenderFinished(m_currentWork.id, hr, m_currentWork.graph); |
| } |
| } else if (m_currentWork.task == Seek) { |
| //that's a seekrequest |
| ComPointer<IMediaSeeking> mediaSeeking(m_currentWork.graph, IID_IMediaSeeking); |
| qint64 newtime = m_currentWork.time * 10000; |
| hr = mediaSeeking->SetPositions(&newtime, AM_SEEKING_AbsolutePositioning, |
| 0, AM_SEEKING_NoPositioning); |
| emit asyncSeekingFinished(m_currentWork.id, newtime / 10000); |
| hr = E_ABORT; //to avoid emitting asyncRenderFinished |
| } else if (m_currentWork.task == ChangeState) { |
| |
| //remove useless decoders |
| QList<Filter> unused; |
| for (int i = 0; i < m_currentWork.decoders.count(); ++i) { |
| const Filter &filter = m_currentWork.decoders.at(i); |
| bool used = false; |
| const QList<OutputPin> pins = BackendNode::pins(filter, PINDIR_OUTPUT); |
| for( int i = 0; i < pins.count(); ++i) { |
| InputPin input; |
| if (pins.at(i)->ConnectedTo(input.pparam()) == S_OK) { |
| used = true; |
| } |
| } |
| if (!used) { |
| unused += filter; |
| } |
| } |
| |
| //we can get the state |
| for (int i = 0; i < unused.count(); ++i) { |
| //we should remove this filter from the graph |
| m_currentWork.graph->RemoveFilter(unused.at(i)); |
| } |
| |
| |
| //we can get the state |
| ComPointer<IMediaControl> mc(m_currentWork.graph, IID_IMediaControl); |
| |
| //we change the state here |
| switch(m_currentWork.state) |
| { |
| case State_Stopped: |
| mc->Stop(); |
| break; |
| case State_Paused: |
| mc->Pause(); |
| break; |
| case State_Running: |
| mc->Run(); |
| break; |
| } |
| OAFilterState s; |
| //blocking call |
| HRESULT hr = mc->GetState(INFINITE, &s); |
| |
| if (SUCCEEDED(hr)) { |
| if (s == State_Stopped) { |
| emit stateReady(m_currentWork.graph, Phonon::StoppedState); |
| } else if (s == State_Paused) { |
| emit stateReady(m_currentWork.graph, Phonon::PausedState); |
| } else /*if (s == State_Running)*/ { |
| emit stateReady(m_currentWork.graph, Phonon::PlayingState); |
| } |
| } |
| } |
| |
| { |
| QMutexLocker locker(&m_mutex); |
| m_currentWork = Work(); //reinitialize |
| } |
| } |
| |
| void WorkerThread::abortCurrentRender(qint16 renderId) |
| { |
| QMutexLocker locker(&m_mutex); |
| if (m_currentWork.id == renderId) { |
| m_currentWork.graph->Abort(); |
| } |
| bool found = false; |
| for(int i = 0; !found && i < m_queue.size(); ++i) { |
| const Work &w = m_queue.at(i); |
| if (w.id == renderId) { |
| found = true; |
| m_queue.removeAt(i); |
| if (m_queue.isEmpty()) { |
| m_waitCondition.reset(); |
| } |
| } |
| } |
| } |
| |
| //tells the thread to stop processing |
| void WorkerThread::signalStop() |
| { |
| QMutexLocker locker(&m_mutex); |
| m_queue.clear(); |
| if (m_currentWork.graph) { |
| //in case we're currently rendering something |
| m_currentWork.graph->Abort(); |
| |
| } |
| |
| m_finished = true; |
| m_waitCondition.set(); |
| } |
| |
| |
| MediaObject::MediaObject(QObject *parent) : BackendNode(parent), |
| transactionState(Phonon::StoppedState), |
| m_errorType(Phonon::NoError), |
| m_state(Phonon::LoadingState), |
| m_nextState(Phonon::StoppedState), |
| m_prefinishMark(0), |
| m_tickInterval(0), |
| m_buffering(false), |
| m_oldHasVideo(false), |
| m_prefinishMarkSent(false), |
| m_aboutToFinishSent(false), |
| m_nextSourceReadyToStart(false), |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| m_autoplayTitles(true), |
| m_currentTitle(0), |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| m_targetTick(INFINITE) |
| { |
| |
| for(int i = 0; i < FILTER_COUNT; ++i) { |
| m_graphs[i] = new MediaGraph(this, i); |
| } |
| |
| connect(&m_thread, SIGNAL(stateReady(Graph,Phonon::State)), |
| SLOT(slotStateReady(Graph,Phonon::State))); |
| |
| connect(&m_thread, SIGNAL(eventReady(Graph,long,long)), |
| SLOT(handleEvents(Graph,long,long))); |
| |
| connect(&m_thread, SIGNAL(asyncRenderFinished(quint16,HRESULT,Graph)), |
| SLOT(finishLoading(quint16,HRESULT,Graph))); |
| |
| connect(&m_thread, SIGNAL(asyncSeekingFinished(quint16,qint64)), |
| SLOT(finishSeeking(quint16,qint64))); |
| //really special case |
| m_mediaObject = this; |
| m_thread.start(); |
| } |
| |
| MediaObject::~MediaObject() |
| { |
| //be sure to finish the timer first |
| m_tickTimer.stop(); |
| |
| //we finish the worker thread here |
| m_thread.signalStop(); |
| m_thread.wait(); |
| |
| //and then we delete the graphs |
| for (int i = 0; i < FILTER_COUNT; ++i) { |
| delete m_graphs[i]; |
| } |
| } |
| |
| WorkerThread *MediaObject::workerThread() |
| { |
| return &m_thread; |
| } |
| |
| MediaGraph *MediaObject::currentGraph() const |
| { |
| return m_graphs[0]; |
| } |
| |
| MediaGraph *MediaObject::nextGraph() const |
| { |
| return m_graphs[FILTER_COUNT - 1]; |
| } |
| |
| //utility function to save the graph to a file |
| void MediaObject::timerEvent(QTimerEvent *e) |
| { |
| if (e->timerId() == m_tickTimer.timerId()) { |
| |
| const qint64 current = currentTime(); |
| const qint64 total = totalTime(); |
| |
| if ( m_tickInterval != 0 && current > m_targetTick) { |
| updateTargetTick(); |
| emit tick(current); |
| } |
| |
| //check that the title hasn't changed |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| if (m_autoplayTitles && m_currentTitle < _iface_availableTitles() - 1) { |
| |
| if (current >= total) { |
| //we go to the next title |
| _iface_setCurrentTitle(m_currentTitle + 1, false); |
| emit tick(current); |
| } |
| return; |
| } |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| |
| if (total) { |
| const qint64 remaining = total - current; |
| |
| if (m_transitionTime < 0 && m_nextSourceReadyToStart) { |
| if (remaining < -m_transitionTime + TIMER_INTERVAL/2) { |
| //we need to switch graphs to run the next source in the queue (with cross-fading) |
| switchToNextSource(); |
| return; |
| } else if (current < -m_transitionTime) { |
| //we are currently crossfading |
| for (int i = 0; i < m_audioOutputs.count(); ++i) { |
| m_audioOutputs.at(i)->setCrossFadingProgress( currentGraph()->index(), qMin( qreal(1.), qreal(current) / qreal(-m_transitionTime))); |
| } |
| } |
| } |
| |
| if (m_prefinishMark > 0 && !m_prefinishMarkSent && remaining < m_prefinishMark + TIMER_INTERVAL/2) { |
| #ifdef GRAPH_DEBUG |
| qDebug() << "DS9: emit prefinishMarkReached" << remaining << QTime::currentTime().toString(); |
| #endif |
| m_prefinishMarkSent = true; |
| |
| emit prefinishMarkReached( remaining ); |
| } |
| |
| if (!m_aboutToFinishSent && remaining < PRELOAD_TIME - m_transitionTime + TIMER_INTERVAL/2) { |
| //let's take a 2 seconds time to actually load the next file |
| #ifdef GRAPH_DEBUG |
| qDebug() << "DS9: emit aboutToFinish" << remaining << QTime::currentTime().toString(); |
| #endif |
| m_aboutToFinishSent = true; |
| emit aboutToFinish(); |
| } |
| } else { |
| //total is 0: the stream is probably live (endless) |
| } |
| |
| if (m_buffering) { |
| ComPointer<IAMNetworkStatus> status(currentGraph()->realSource(), IID_IAMNetworkStatus); |
| if (status) { |
| long l; |
| status->get_BufferingProgress(&l); |
| emit bufferStatus(l); |
| #ifdef GRAPH_DEBUG |
| qDebug() << "emit bufferStatus(" << l << ")"; |
| #endif |
| } |
| } |
| } |
| } |
| |
| void MediaObject::switchToNextSource() |
| { |
| m_prefinishMarkSent = false; |
| m_aboutToFinishSent = false; |
| m_nextSourceReadyToStart = false; |
| |
| m_oldHasVideo = currentGraph()->hasVideo(); |
| |
| qSwap(m_graphs[0], m_graphs[1]); //swap the graphs |
| |
| if (m_transitionTime >= 0) |
| m_graphs[1]->stop(); //make sure we stop the previous graph |
| |
| if (currentGraph()->mediaSource().type() != Phonon::MediaSource::Invalid && |
| catchComError(currentGraph()->renderResult())) { |
| setState(Phonon::ErrorState); |
| return; |
| } |
| |
| //we need to play the next media |
| play(); |
| |
| //we tell the video widgets to switch now to the new source |
| #ifndef QT_NO_PHONON_VIDEO |
| for (int i = 0; i < m_videoWidgets.count(); ++i) { |
| m_videoWidgets.at(i)->setCurrentGraph(currentGraph()->index()); |
| } |
| #endif //QT_NO_PHONON_VIDEO |
| |
| emit currentSourceChanged(currentGraph()->mediaSource()); |
| emit metaDataChanged(currentGraph()->metadata()); |
| |
| if (nextGraph()->hasVideo() != currentGraph()->hasVideo()) { |
| emit hasVideoChanged(currentGraph()->hasVideo()); |
| } |
| |
| emit tick(0); |
| emit totalTimeChanged(totalTime()); |
| |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| setTitles(currentGraph()->titles()); |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| } |
| |
| Phonon::State MediaObject::state() const |
| { |
| if (m_buffering) { |
| return Phonon::BufferingState; |
| } else { |
| return m_state; |
| } |
| } |
| |
| bool MediaObject::hasVideo() const |
| { |
| return currentGraph()->hasVideo(); |
| } |
| |
| bool MediaObject::isSeekable() const |
| { |
| return currentGraph()->isSeekable(); |
| } |
| |
| qint64 MediaObject::totalTime() const |
| { |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| //1st, check if there is more titles after |
| const qint64 ret = (m_currentTitle < _iface_availableTitles() - 1) ? |
| titleAbsolutePosition(m_currentTitle+1) : currentGraph()->absoluteTotalTime(); |
| |
| //this is the duration of the current title |
| return ret - titleAbsolutePosition(m_currentTitle); |
| #else |
| return currentGraph()->absoluteTotalTime(); |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| } |
| |
| qint64 MediaObject::currentTime() const |
| { |
| //this handles inaccuracy when stopping on a title |
| return currentGraph()->absoluteCurrentTime() |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| - titleAbsolutePosition(m_currentTitle) |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| ; |
| } |
| |
| qint32 MediaObject::tickInterval() const |
| { |
| return m_tickInterval; |
| } |
| |
| void MediaObject::setTickInterval(qint32 newTickInterval) |
| { |
| m_tickInterval = newTickInterval; |
| updateTargetTick(); |
| } |
| |
| void MediaObject::pause() |
| { |
| if (currentGraph()->isLoading()) { |
| m_nextState = Phonon::PausedState; |
| } else { |
| currentGraph()->pause(); |
| } |
| } |
| |
| void MediaObject::stop() |
| { |
| if (currentGraph()->isLoading()) { |
| m_nextState = Phonon::StoppedState; |
| } else { |
| currentGraph()->stop(); |
| } |
| } |
| |
| void MediaObject::ensureStopped() |
| { |
| currentGraph()->ensureStopped(); |
| if (m_state == Phonon::ErrorState) { |
| //we reset the state here |
| m_state = Phonon::StoppedState; |
| } |
| } |
| |
| void MediaObject::play() |
| { |
| if (currentGraph()->isLoading()) { |
| m_nextState = Phonon::PlayingState; |
| } else { |
| currentGraph()->play(); |
| } |
| } |
| |
| QString MediaObject::errorString() const |
| { |
| return m_errorString; |
| } |
| |
| Phonon::ErrorType MediaObject::errorType() const |
| { |
| return m_errorType; |
| } |
| |
| |
| void MediaObject::updateTargetTick() |
| { |
| if (m_tickInterval) { |
| const qint64 current = currentTime(); |
| m_targetTick = current / m_tickInterval * m_tickInterval; |
| if (current == 0 || m_targetTick < current) { |
| m_targetTick += m_tickInterval; |
| } |
| } |
| } |
| |
| void MediaObject::setState(Phonon::State newstate) |
| { |
| if (newstate == Phonon::PlayingState) { |
| updateTargetTick(); |
| } |
| |
| if (newstate == m_state) { |
| return; |
| } |
| |
| //manage the timer |
| if (newstate == Phonon::PlayingState) { |
| m_tickTimer.start(TIMER_INTERVAL, this); |
| } else { |
| m_tickTimer.stop(); |
| } |
| |
| Phonon::State oldstate = state(); |
| m_state = newstate; |
| emit stateChanged(newstate, oldstate); |
| } |
| |
| |
| qint32 MediaObject::prefinishMark() const |
| { |
| return m_prefinishMark; |
| } |
| |
| void MediaObject::setPrefinishMark(qint32 newPrefinishMark) |
| { |
| m_prefinishMark = newPrefinishMark; |
| } |
| |
| qint32 MediaObject::transitionTime() const |
| { |
| return m_transitionTime; |
| } |
| |
| void MediaObject::setTransitionTime(qint32 time) |
| { |
| m_transitionTime = time; |
| } |
| |
| qint64 MediaObject::remainingTime() const |
| { |
| return totalTime() - currentTime(); |
| } |
| |
| |
| Phonon::MediaSource MediaObject::source() const |
| { |
| return currentGraph()->mediaSource(); |
| } |
| |
| void MediaObject::setNextSource(const Phonon::MediaSource &source) |
| { |
| m_nextSourceReadyToStart = true; |
| const bool shouldSwitch = (m_state == Phonon::StoppedState || m_state == Phonon::ErrorState); |
| nextGraph()->loadSource(source); //let's preload the source |
| |
| if (shouldSwitch) { |
| switchToNextSource(); |
| } |
| } |
| |
| void MediaObject::setSource(const Phonon::MediaSource &source) |
| { |
| m_nextSourceReadyToStart = false; |
| m_prefinishMarkSent = false; |
| m_aboutToFinishSent = false; |
| |
| m_oldHasVideo = currentGraph()->hasVideo(); |
| setState(Phonon::LoadingState); |
| //After loading we go into stopped state |
| m_nextState = Phonon::StoppedState; |
| catchComError(currentGraph()->loadSource(source)); |
| emit currentSourceChanged(source); |
| } |
| |
| void MediaObject::slotStateReady(Graph graph, Phonon::State newState) |
| { |
| if (graph == currentGraph()->graph() && !currentGraph()->isLoading()) { |
| setState(newState); |
| } |
| } |
| |
| void MediaObject::loadingFinished(MediaGraph *mg) |
| { |
| if (mg == currentGraph()) { |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| //Title interface |
| m_currentTitle = 0; |
| setTitles(currentGraph()->titles()); |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| |
| HRESULT hr = mg->renderResult(); |
| |
| if (catchComError(hr)) { |
| return; |
| } |
| |
| if (m_oldHasVideo != currentGraph()->hasVideo()) { |
| emit hasVideoChanged(currentGraph()->hasVideo()); |
| } |
| |
| #ifndef QT_NO_PHONON_VIDEO |
| if (currentGraph()->hasVideo()) { |
| updateVideoGeometry(); |
| } |
| #endif //QT_NO_PHONON_VIDEO |
| |
| emit metaDataChanged(currentGraph()->metadata()); |
| emit totalTimeChanged(totalTime()); |
| |
| //let's put the next state |
| switch(m_nextState) |
| { |
| case Phonon::PausedState: |
| pause(); |
| break; |
| case Phonon::PlayingState: |
| play(); |
| break; |
| case Phonon::ErrorState: |
| setState(Phonon::ErrorState); |
| break; |
| case Phonon::StoppedState: |
| default: |
| stop(); |
| break; |
| } |
| } |
| } |
| |
| void MediaObject::seek(qint64 time) |
| { |
| //we seek into the current title |
| currentGraph()->absoluteSeek(time |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| + titleAbsolutePosition(m_currentTitle) |
| #endif //QT_NO_PHONON_MEDIACONTROLLER |
| ); |
| } |
| |
| void MediaObject::seekingFinished(MediaGraph *mg) |
| { |
| if (mg == currentGraph()) { |
| |
| updateTargetTick(); |
| if (currentTime() < totalTime() - m_prefinishMark) { |
| m_prefinishMarkSent = false; |
| } |
| |
| if (currentTime() < totalTime() - PRELOAD_TIME + m_transitionTime) { |
| m_aboutToFinishSent = false; |
| } |
| |
| //this helps the update of the application (seekslider for example) |
| if (m_state == PausedState || m_state == PlayingState) { |
| emit tick(currentTime()); |
| } |
| } |
| } |
| |
| |
| bool MediaObject::catchComError(HRESULT hr) |
| { |
| |
| m_errorString.clear(); |
| m_errorType = Phonon::NoError; |
| |
| if (hr != S_OK) { |
| #ifdef GRAPH_DEBUG |
| qWarning("an error occurred 0x%x",hr); |
| #endif |
| LPAMGETERRORTEXT getErrorText = (LPAMGETERRORTEXT)QLibrary::resolve(QLatin1String("quartz"), "AMGetErrorTextW"); |
| |
| WCHAR buffer[MAX_ERROR_TEXT_LEN]; |
| if (getErrorText && getErrorText(hr, buffer, MAX_ERROR_TEXT_LEN)) { |
| m_errorString = QString::fromWCharArray(buffer); |
| } else { |
| m_errorString = QString::fromLatin1("Unknown error"); |
| } |
| const QString comError = QString::number(uint(hr), 16); |
| if (!m_errorString.toLower().contains(comError.toLower())) { |
| m_errorString += QString::fromLatin1(" (0x%1)").arg(comError); |
| } |
| if (FAILED(hr)) { |
| m_errorType = Phonon::FatalError; |
| setState(Phonon::ErrorState); |
| } else { |
| m_errorType = Phonon::NormalError; |
| m_nextState = Phonon::ErrorState; |
| } |
| } else { |
| m_errorType = Phonon::NoError; |
| |
| } |
| |
| return m_errorType == Phonon::FatalError; |
| } |
| |
| |
| void MediaObject::grabNode(BackendNode *node) |
| { |
| for (int i = 0; i < FILTER_COUNT; ++i) { |
| m_graphs[i]->grabNode(node); |
| } |
| node->setMediaObject(this); |
| } |
| |
| bool MediaObject::connectNodes(BackendNode *source, BackendNode *sink) |
| { |
| bool ret = true; |
| for (int i = 0; i < FILTER_COUNT; ++i) { |
| ret = ret && m_graphs[i]->connectNodes(source, sink); |
| } |
| if (ret) { |
| #ifndef QT_NO_PHONON_VIDEO |
| if (VideoWidget *video = qobject_cast<VideoWidget*>(sink)) { |
| m_videoWidgets += video; |
| } else |
| #endif //QT_NO_PHONON_VIDEO |
| if (AudioOutput *audio = qobject_cast<AudioOutput*>(sink)) { |
| m_audioOutputs += audio; |
| } |
| } |
| return ret; |
| } |
| |
| bool MediaObject::disconnectNodes(BackendNode *source, BackendNode *sink) |
| { |
| bool ret = true; |
| for (int i = 0; i < FILTER_COUNT; ++i) { |
| ret = ret && m_graphs[i]->disconnectNodes(source, sink); |
| } |
| if (ret) { |
| #ifndef QT_NO_PHONON_VIDEO |
| if (VideoWidget *video = qobject_cast<VideoWidget*>(sink)) { |
| m_videoWidgets.removeOne(video); |
| } else |
| #endif //QT_NO_PHONON_VIDEO |
| if (AudioOutput *audio = qobject_cast<AudioOutput*>(sink)) { |
| m_audioOutputs.removeOne(audio); |
| } |
| } |
| return ret; |
| } |
| |
| #ifndef QT_NO_PHONON_VIDEO |
| void MediaObject::updateVideoGeometry() |
| { |
| for (int i = 0; i < m_videoWidgets.count(); ++i) { |
| m_videoWidgets.at(i)->notifyVideoLoaded(); |
| } |
| } |
| #endif //QT_NO_PHONON_VIDEO |
| |
| void MediaObject::handleComplete(IGraphBuilder *graph) |
| { |
| if (graph == currentGraph()->graph()) { |
| if (m_transitionTime >= PRELOAD_TIME || m_aboutToFinishSent == false) { |
| emit aboutToFinish(); //give a chance to the frontend to give a next source |
| m_aboutToFinishSent = true; |
| } |
| |
| if (!m_nextSourceReadyToStart) { |
| //this is the last source, we simply finish |
| const qint64 current = currentTime(); |
| const OAFilterState currentState = currentGraph()->syncGetRealState(); |
| |
| emit tick(current); //this ensures that the end of the seek slider is reached |
| emit finished(); |
| |
| if (currentTime() == current && currentGraph()->syncGetRealState() == currentState) { |
| //no seek operation in-between |
| pause(); |
| setState(Phonon::PausedState); //we set it here |
| } |
| |
| } else if (m_transitionTime == 0) { |
| //gapless transition |
| switchToNextSource(); //let's call the function immediately |
| } else if (m_transitionTime > 0) { |
| //management of the transition (if it is >= 0) |
| QTimer::singleShot(m_transitionTime, this, SLOT(switchToNextSource())); |
| } |
| } else { |
| //it is just the end of the previous source (in case of cross-fading) |
| nextGraph()->cleanup(); |
| } |
| for (int i = 0; i < m_audioOutputs.count(); ++i) { |
| m_audioOutputs.at(i)->setCrossFadingProgress( currentGraph()->index(), 1.); //cross-fading is in any case finished |
| } |
| } |
| |
| void MediaObject::finishLoading(quint16 workId, HRESULT hr, Graph graph) |
| { |
| for(int i = 0; i < FILTER_COUNT; ++i) { |
| m_graphs[i]->finishLoading(workId, hr, graph); |
| } |
| } |
| |
| void MediaObject::finishSeeking(quint16 workId, qint64 time) |
| { |
| for(int i = 0; i < FILTER_COUNT; ++i) { |
| m_graphs[i]->finishSeeking(workId, time); |
| } |
| } |
| |
| |
| void MediaObject::handleEvents(Graph graph, long eventCode, long param1) |
| { |
| QString eventDescription; |
| switch (eventCode) |
| { |
| case EC_BUFFERING_DATA: |
| if (graph == currentGraph()->graph()) { |
| m_buffering = param1; |
| emit stateChanged(state(), m_state); |
| } |
| break; |
| case EC_LENGTH_CHANGED: |
| if (graph == currentGraph()->graph()) { |
| emit totalTimeChanged( totalTime() ); |
| } |
| break; |
| |
| case EC_COMPLETE: |
| handleComplete(graph); |
| break; |
| |
| #ifndef QT_NO_PHONON_VIDEO |
| case EC_VIDEO_SIZE_CHANGED: |
| if (graph == currentGraph()->graph()) { |
| updateVideoGeometry(); |
| } |
| break; |
| #endif //QT_NO_PHONON_VIDEO |
| |
| #ifdef GRAPH_DEBUG |
| case EC_ACTIVATE: qDebug() << "EC_ACTIVATE: A video window is being " << (param1 ? "ACTIVATED" : "DEACTIVATED"); break; |
| case EC_BUILT: qDebug() << "EC_BUILT: Send by the Video Control when a graph has been built. Not forwarded to applications."; break; |
| case EC_CLOCK_CHANGED: qDebug() << "EC_CLOCK_CHANGED"; break; |
| case EC_CLOCK_UNSET: qDebug() << "EC_CLOCK_UNSET: The clock provider was disconnected."; break; |
| case EC_CODECAPI_EVENT: qDebug() << "EC_CODECAPI_EVENT: Sent by an encoder to signal an encoding event."; break; |
| case EC_DEVICE_LOST: qDebug() << "EC_DEVICE_LOST: A Plug and Play device was removed or has become available again."; break; |
| case EC_DISPLAY_CHANGED: qDebug() << "EC_DISPLAY_CHANGED: The display mode has changed."; break; |
| case EC_END_OF_SEGMENT: qDebug() << "EC_END_OF_SEGMENT: The end of a segment has been reached."; break; |
| case EC_ERROR_STILLPLAYING: qDebug() << "EC_ERROR_STILLPLAYING: An asynchronous command to run the graph has failed."; break; |
| case EC_ERRORABORT: qDebug() << "EC_ERRORABORT: An operation was aborted because of an error."; break; |
| case EC_EXTDEVICE_MODE_CHANGE: qDebug() << "EC_EXTDEVICE_MODE_CHANGE: Not supported."; break; |
| case EC_FULLSCREEN_LOST: qDebug() << "EC_FULLSCREEN_LOST: The video renderer is switching out of full-screen mode."; break; |
| case EC_GRAPH_CHANGED: qDebug() << "EC_GRAPH_CHANGED: The filter graph has changed."; break; |
| case EC_NEED_RESTART: qDebug() << "EC_NEED_RESTART: A filter is requesting that the graph be restarted."; break; |
| case EC_NOTIFY_WINDOW: qDebug() << "EC_NOTIFY_WINDOW: Notifies a filter of the video renderer's window."; break; |
| case EC_OLE_EVENT: qDebug() << "EC_OLE_EVENT: A filter is passing a text string to the application."; break; |
| case EC_OPENING_FILE: qDebug() << "EC_OPENING_FILE: The graph is opening a file, or has finished opening a file."; break; |
| case EC_PALETTE_CHANGED: qDebug() << "EC_PALETTE_CHANGED: The video palette has changed."; break; |
| case EC_PAUSED: qDebug() << "EC_PAUSED: A pause request has completed."; break; |
| case EC_PREPROCESS_COMPLETE: qDebug() << "EC_PREPROCESS_COMPLETE: Sent by the WM ASF Writer filter when it completes the pre-processing for multipass encoding."; break; |
| case EC_QUALITY_CHANGE: qDebug() << "EC_QUALITY_CHANGE: The graph is dropping samples, for quality control."; break; |
| case EC_REPAINT: qDebug() << "EC_REPAINT: A video renderer requires a repaint."; break; |
| case EC_SEGMENT_STARTED: qDebug() << "EC_SEGMENT_STARTED: A new segment has started."; break; |
| case EC_SHUTTING_DOWN: qDebug() << "EC_SHUTTING_DOWN: The filter graph is shutting down, prior to being destroyed."; break; |
| case EC_SNDDEV_IN_ERROR: qDebug() << "EC_SNDDEV_IN_ERROR: A device error has occurred in an audio capture filter."; break; |
| case EC_SNDDEV_OUT_ERROR: qDebug() << "EC_SNDDEV_OUT_ERROR: A device error has occurred in an audio renderer filter."; break; |
| case EC_STARVATION: qDebug() << "EC_STARVATION: A filter is not receiving enough data."; break; |
| case EC_STATE_CHANGE: qDebug() << "EC_STATE_CHANGE: The filter graph has changed state."; break; |
| case EC_STEP_COMPLETE: qDebug() << "EC_STEP_COMPLETE: A filter performing frame stepping has stepped the specified number of frames."; break; |
| case EC_STREAM_CONTROL_STARTED: qDebug() << "EC_STREAM_CONTROL_STARTED: A stream-control start command has taken effect."; break; |
| case EC_STREAM_CONTROL_STOPPED: qDebug() << "EC_STREAM_CONTROL_STOPPED: A stream-control stop command has taken effect."; break; |
| case EC_STREAM_ERROR_STILLPLAYING: qDebug() << "EC_STREAM_ERROR_STILLPLAYING: An error has occurred in a stream. The stream is still playing."; break; |
| case EC_STREAM_ERROR_STOPPED: qDebug() << "EC_STREAM_ERROR_STOPPED: A stream has stopped because of an error."; break; |
| case EC_TIMECODE_AVAILABLE: qDebug() << "EC_TIMECODE_AVAILABLE: Not supported."; break; |
| case EC_UNBUILT: qDebug() << "Sent by the Video Control when a graph has been torn down. Not forwarded to applications."; break; |
| case EC_USERABORT: qDebug() << "EC_USERABORT: Send by the Video Control when a graph has been torn down. Not forwarded to applications."; break; |
| case EC_VMR_RECONNECTION_FAILED: qDebug() << "EC_VMR_RECONNECTION_FAILED: Sent by the VMR-7 and the VMR-9 when it was unable to accept a dynamic format change request from the upstream decoder."; break; |
| case EC_VMR_RENDERDEVICE_SET: qDebug() << "EC_VMR_RENDERDEVICE_SET: Sent when the VMR has selected its rendering mechanism."; break; |
| case EC_VMR_SURFACE_FLIPPED: qDebug() << "EC_VMR_SURFACE_FLIPPED: Sent when the VMR-7's allocator presenter has called the DirectDraw Flip method on the surface being presented."; break; |
| case EC_WINDOW_DESTROYED: qDebug() << "EC_WINDOW_DESTROYED: The video renderer was destroyed or removed from the graph"; break; |
| case EC_WMT_EVENT: qDebug() << "EC_WMT_EVENT: Sent by the Windows Media Format SDK when an application uses the ASF Reader filter to play ASF files protected by digital rights management (DRM)."; break; |
| case EC_WMT_INDEX_EVENT: qDebug() << "EC_WMT_INDEX_EVENT: Sent by the Windows Media Format SDK when an application uses the ASF Writer to index Windows Media Video files."; break; |
| |
| //documented by Microsoft but not supported in the Platform SDK |
| // case EC_BANDWIDTHCHANGE : qDebug() << "EC_BANDWIDTHCHANGE: not supported"; break; |
| // case EC_CONTENTPROPERTY_CHANGED: qDebug() << "EC_CONTENTPROPERTY_CHANGED: not supported."; break; |
| // case EC_EOS_SOON: qDebug() << "EC_EOS_SOON: not supported"; break; |
| // case EC_ERRORABORTEX: qDebug() << "EC_ERRORABORTEX: An operation was aborted because of an error."; break; |
| // case EC_FILE_CLOSED: qDebug() << "EC_FILE_CLOSED: The source file was closed because of an unexpected event."; break; |
| // case EC_LOADSTATUS: qDebug() << "EC_LOADSTATUS: Notifies the application of progress when opening a network file."; break; |
| // case EC_MARKER_HIT: qDebug() << "EC_MARKER_HIT: not supported."; break; |
| // case EC_NEW_PIN: qDebug() << "EC_NEW_PIN: not supported."; break; |
| // case EC_PLEASE_REOPEN: qDebug() << "EC_PLEASE_REOPEN: The source file has changed."; break; |
| // case EC_PROCESSING_LATENCY: qDebug() << "EC_PROCESSING_LATENCY: Indicates the amount of time that a component is taking to process each sample."; break; |
| // case EC_RENDER_FINISHED: qDebug() << "EC_RENDER_FINISHED: Not supported."; break; |
| // case EC_SAMPLE_LATENCY: qDebug() << "EC_SAMPLE_LATENCY: Specifies how far behind schedule a component is for processing samples."; break; |
| // case EC_SAMPLE_NEEDED: qDebug() << "EC_SAMPLE_NEEDED: Requests a new input sample from the Enhanced Video Renderer (EVR) filter."; break; |
| // case EC_SCRUB_TIME: qDebug() << "EC_SCRUB_TIME: Specifies the time stamp for the most recent frame step."; break; |
| // case EC_STATUS: qDebug() << "EC_STATUS: Contains two arbitrary status strings."; break; |
| // case EC_VIDEOFRAMEREADY: qDebug() << "EC_VIDEOFRAMEREADY: A video frame is ready for display."; break; |
| |
| default: |
| qDebug() << "Unknown event" << eventCode << "(" << param1 << ")"; |
| break; |
| #else |
| default: |
| break; |
| #endif |
| } |
| } |
| |
| |
| #ifndef QT_NO_PHONON_MEDIACONTROLLER |
| //interface management |
| bool MediaObject::hasInterface(Interface iface) const |
| { |
| return iface == AddonInterface::TitleInterface; |
| } |
| |
| QVariant MediaObject::interfaceCall(Interface iface, int command, const QList<QVariant> ¶ms) |
| { |
| if (hasInterface(iface)) { |
| |
| switch (iface) |
| { |
| case TitleInterface: |
| switch (command) |
| { |
| case availableTitles: |
| return _iface_availableTitles(); |
| case title: |
| return _iface_currentTitle(); |
| case setTitle: |
| _iface_setCurrentTitle(params.first().toInt()); |
| break; |
| case autoplayTitles: |
| return m_autoplayTitles; |
| case setAutoplayTitles: |
| m_autoplayTitles = params.first().toBool(); |
| updateStopPosition(); |
| break; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| return QVariant(); |
| } |
| |
| |
| //TitleInterface |
| |
| //this is called to set the time for the different titles |
| qint64 MediaObject::titleAbsolutePosition(int title) const |
| { |
| if (title >= 0 && title < m_titles.count()) { |
| return m_titles.at(title); |
| } else { |
| return 0; |
| } |
| } |
| |
| void MediaObject::setTitles(const QList<qint64> &titles) |
| { |
| //this is called when the source is loaded |
| const bool emitSignal = m_titles.count() != titles.count(); |
| m_titles = titles; |
| if (emitSignal) { |
| emit availableTitlesChanged(titles.count()); |
| } |
| updateStopPosition(); |
| } |
| |
| |
| int MediaObject::_iface_availableTitles() const |
| { |
| return m_titles.count() - 1; |
| } |
| |
| int MediaObject::_iface_currentTitle() const |
| { |
| return m_currentTitle; |
| } |
| |
| void MediaObject::_iface_setCurrentTitle(int title, bool bseek) |
| { |
| #ifdef GRAPH_DEBUG |
| qDebug() << "_iface_setCurrentTitle" << title; |
| #endif |
| const int oldTitle = m_currentTitle; |
| m_currentTitle = title; |
| updateStopPosition(); |
| if (bseek) { |
| //let's seek to the beginning of the song |
| seek(0); |
| } else { |
| updateTargetTick(); |
| } |
| if (oldTitle != title) { |
| emit titleChanged(title); |
| emit totalTimeChanged(totalTime()); |
| } |
| |
| } |
| |
| void MediaObject::updateStopPosition() |
| { |
| if (!m_autoplayTitles && m_currentTitle < _iface_availableTitles() - 1) { |
| //stop position is set to the end of the track |
| currentGraph()->setStopPosition(titleAbsolutePosition(m_currentTitle+1)); |
| } else { |
| //stop position is set to the end |
| currentGraph()->setStopPosition(-1); |
| } |
| } |
| #endif //QT_NO_PHONON_QT_NO_PHONON_MEDIACONTROLLER |
| |
| void MediaObject::switchFilters(int index, Filter oldFilter, Filter newFilter) |
| { |
| if (currentGraph()->index() == index) { |
| currentGraph()->switchFilters(oldFilter, newFilter); |
| } else { |
| nextGraph()->switchFilters(oldFilter, newFilter); |
| } |
| |
| } |
| |
| |
| } |
| } |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_mediaobject.cpp" |
