bool EffectPrivate::aboutToDeleteBackendObject()
{
if (m_backendObject) {
const QList<EffectParameter> parameters = pINTERFACE_CALL(parameters());
foreach (const EffectParameter &p, parameters) {
parameterValues[p] = pINTERFACE_CALL(parameterValue(p));
}
}
bool MediaObjectPrivate::aboutToDeleteBackendObject()
{
//pDebug() << Q_FUNC_INFO;
prefinishMark = pINTERFACE_CALL(prefinishMark());
transitionTime = pINTERFACE_CALL(transitionTime());
//pDebug() << Q_FUNC_INFO;
if (m_backendObject) {
state = pINTERFACE_CALL(state());
currentTime = pINTERFACE_CALL(currentTime());
tickInterval = pINTERFACE_CALL(tickInterval());
}
return true;
}
void VideoWidgetPrivate::setupBackendObject()
{
Q_Q(VideoWidget);
Q_ASSERT(m_backendObject);
//AbstractVideoOutputPrivate::setupBackendObject();
pDebug() << "calling setAspectRatio on the backend " << aspectRatio;
pINTERFACE_CALL(setAspectRatio(aspectRatio));
pINTERFACE_CALL(setScaleMode(scaleMode));
QWidget *w = pINTERFACE_CALL(widget());
if (w) {
layout.addWidget(w);
q->setSizePolicy(w->sizePolicy());
w->setMouseTracking(true);
}
}
void MediaObjectPrivate::_k_resumePause()
{
pINTERFACE_CALL(pause());
if (currentTime > 0) {
qobject_cast<MediaObjectInterface *>(m_backendObject)->seek(currentTime);
}
}
void MediaObjectPrivate::_k_aboutToFinish()
{
Q_Q(MediaObject);
pDebug() << Q_FUNC_INFO;
#ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM
kiofallback = 0; // kiofallback auto-deletes
#endif //QT_NO_PHONON_ABSTRACTMEDIASTREAM
if (sourceQueue.isEmpty()) {
emit q->aboutToFinish();
if (sourceQueue.isEmpty()) {
return;
}
}
mediaSource = sourceQueue.head();
pINTERFACE_CALL(setNextSource(mediaSource));
}
bool VideoWidgetPrivate::aboutToDeleteBackendObject()
{
aspectRatio = pINTERFACE_CALL(aspectRatio());
scaleMode = pINTERFACE_CALL(scaleMode());
return AbstractVideoOutputPrivate::aboutToDeleteBackendObject();
}
void MediaObjectPrivate::setupBackendObject()
{
Q_Q(MediaObject);
Q_ASSERT(m_backendObject);
//pDebug() << Q_FUNC_INFO;
#ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM
QObject::connect(m_backendObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)), q, SLOT(_k_stateChanged(Phonon::State, Phonon::State)));
#else
QObject::connect(m_backendObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)), q, SIGNAL(stateChanged(Phonon::State, Phonon::State)));
#endif // QT_NO_PHONON_ABSTRACTMEDIASTREAM
QObject::connect(m_backendObject, SIGNAL(tick(qint64)), q, SIGNAL(tick(qint64)));
QObject::connect(m_backendObject, SIGNAL(seekableChanged(bool)), q, SIGNAL(seekableChanged(bool)));
#ifndef QT_NO_PHONON_VIDEO
QObject::connect(m_backendObject, SIGNAL(hasVideoChanged(bool)), q, SIGNAL(hasVideoChanged(bool)));
#endif //QT_NO_PHONON_VIDEO
QObject::connect(m_backendObject, SIGNAL(bufferStatus(int)), q, SIGNAL(bufferStatus(int)));
QObject::connect(m_backendObject, SIGNAL(finished()), q, SIGNAL(finished()));
QObject::connect(m_backendObject, SIGNAL(aboutToFinish()), q, SLOT(_k_aboutToFinish()));
QObject::connect(m_backendObject, SIGNAL(prefinishMarkReached(qint32)), q, SIGNAL(prefinishMarkReached(qint32)));
QObject::connect(m_backendObject, SIGNAL(totalTimeChanged(qint64)), q, SIGNAL(totalTimeChanged(qint64)));
QObject::connect(m_backendObject, SIGNAL(metaDataChanged(const QMultiMap<QString, QString> &)),
q, SLOT(_k_metaDataChanged(const QMultiMap<QString, QString> &)));
QObject::connect(m_backendObject, SIGNAL(currentSourceChanged(const MediaSource&)),
q, SLOT(_k_currentSourceChanged(const MediaSource&)));
// set up attributes
pINTERFACE_CALL(setTickInterval(tickInterval));
pINTERFACE_CALL(setPrefinishMark(prefinishMark));
pINTERFACE_CALL(setTransitionTime(transitionTime));
switch(state)
{
case LoadingState:
case StoppedState:
case ErrorState:
break;
case PlayingState:
case BufferingState:
QTimer::singleShot(0, q, SLOT(_k_resumePlay()));
break;
case PausedState:
QTimer::singleShot(0, q, SLOT(_k_resumePause()));
break;
}
const State backendState = pINTERFACE_CALL(state());
if (state != backendState && state != ErrorState) {
// careful: if state is ErrorState we might be switching from a
// MediaObject to a ByteStream for KIO fallback. In that case the state
// change to ErrorState was already suppressed.
pDebug() << "emitting a state change because the backend object has been replaced";
emit q->stateChanged(backendState, state);
state = backendState;
}
#ifndef QT_NO_PHONON_MEDIACONTROLLER
for (int i = 0 ; i < interfaceList.count(); ++i) {
interfaceList.at(i)->_backendObjectChanged();
}
#endif //QT_NO_PHONON_MEDIACONTROLLER
// set up attributes
if (isPlayable(mediaSource.type())) {
#ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM
if (mediaSource.type() == MediaSource::Stream) {
Q_ASSERT(mediaSource.stream());
mediaSource.stream()->d_func()->setMediaObjectPrivate(this);
}
#endif //QT_NO_PHONON_ABSTRACTMEDIASTREAM
pINTERFACE_CALL(setSource(mediaSource));
}
}
void MediaObjectPrivate::_k_stateChanged(Phonon::State newstate, Phonon::State oldstate)
{
Q_Q(MediaObject);
if (mediaSource.type() != MediaSource::Url) {
// special handling only necessary for URLs because of the fallback
emit q->stateChanged(newstate, oldstate);
return;
}
if (errorOverride) {
errorOverride = false;
if (newstate == ErrorState) {
return;
}
oldstate = ErrorState;
}
// backend MediaObject reached ErrorState, try a KioMediaSource
if (newstate == Phonon::ErrorState && !kiofallback) {
kiofallback = Platform::createMediaStream(mediaSource.url(), q);
if (!kiofallback) {
pDebug() << "backend MediaObject reached ErrorState, no KIO fallback available";
emit q->stateChanged(newstate, oldstate);
return;
}
pDebug() << "backend MediaObject reached ErrorState, trying Platform::createMediaStream now";
ignoreLoadingToBufferingStateChange = false;
ignoreErrorToLoadingStateChange = false;
switch (oldstate) {
case Phonon::BufferingState:
// play() has already been called, we need to make sure it is called
// on the backend with the KioMediaStream MediaSource now, too
ignoreLoadingToBufferingStateChange = true;
break;
case Phonon::LoadingState:
ignoreErrorToLoadingStateChange = true;
// no extras
break;
default:
pError() << "backend MediaObject reached ErrorState after " << oldstate
<< ". It seems a KioMediaStream will not help here, trying anyway.";
emit q->stateChanged(Phonon::LoadingState, oldstate);
break;
}
kiofallback->d_func()->setMediaObjectPrivate(this);
MediaSource mediaSource(kiofallback);
mediaSource.setAutoDelete(true);
pINTERFACE_CALL(setSource(mediaSource));
if (oldstate == Phonon::BufferingState) {
q->play();
}
return;
} else if (ignoreLoadingToBufferingStateChange &&
kiofallback &&
oldstate == Phonon::LoadingState) {
if (newstate != Phonon::BufferingState) {
emit q->stateChanged(newstate, Phonon::BufferingState);
}
return;
} else if (ignoreErrorToLoadingStateChange && kiofallback && oldstate == ErrorState) {
if (newstate != LoadingState) {
emit q->stateChanged(newstate, Phonon::LoadingState);
}
return;
}
emit q->stateChanged(newstate, oldstate);
}
