void QWmpPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
{
if (!content.isNull() && !stream)
setUrl(content.canonicalUrl());
else
setUrl(QUrl());
}
void QMediaPlayerPrivate::setMedia(const QMediaContent &media, QIODevice *stream)
{
Q_Q(QMediaPlayer);
if (!control)
return;
QScopedPointer<QFile> file;
// Backends can't play qrc files directly.
// If the backend supports StreamPlayback, we pass a QFile for that resource.
// If it doesn't, we copy the data to a temporary file and pass its path.
if (!media.isNull() && !stream && media.canonicalUrl().scheme() == QLatin1String("qrc")) {
qrcMedia = media;
file.reset(new QFile(QLatin1Char(':') + media.canonicalUrl().path()));
if (!file->open(QFile::ReadOnly)) {
QMetaObject::invokeMethod(q, "_q_error", Qt::QueuedConnection,
Q_ARG(int, QMediaPlayer::ResourceError),
Q_ARG(QString, QMediaPlayer::tr("Attempting to play invalid Qt resource")));
QMetaObject::invokeMethod(q, "_q_mediaStatusChanged", Qt::QueuedConnection,
Q_ARG(QMediaPlayer::MediaStatus, QMediaPlayer::InvalidMedia));
file.reset();
// Ignore the next NoMedia status change, we just want to clear the current media
// on the backend side since we can't load the new one and we want to be in the
// InvalidMedia status.
ignoreNextStatusChange = QMediaPlayer::NoMedia;
control->setMedia(QMediaContent(), 0);
} else if (hasStreamPlaybackFeature) {
void QMediaPlayerPrivate::_q_updateMedia(const QMediaContent &media)
{
if (!control)
return;
const QMediaPlayer::State currentState = state;
filterStates = true;
control->setMedia(media, 0);
if (!media.isNull()) {
switch (currentState) {
case QMediaPlayer::PlayingState:
control->play();
break;
case QMediaPlayer::PausedState:
control->pause();
break;
default:
break;
}
}
filterStates = false;
state = control->state();
if (state != currentState)
emit q_func()->stateChanged(state);
}
void tst_QMediaContent::testNull()
{
QMediaContent media;
QCOMPARE(media.isNull(), true);
QCOMPARE(media.canonicalUrl(), QUrl());
QCOMPARE(media.canonicalResource(), QMediaResource());
QCOMPARE(media.resources(), QMediaResourceList());
}
void QWinRTMediaPlayerControl::setMedia(const QMediaContent &media, QIODevice *stream)
{
Q_D(QWinRTMediaPlayerControl);
if (d->media == media)
return;
d->media = media;
d->stream.reset(stream);
if (d->hasAudio != false) {
d->hasAudio = false;
emit audioAvailableChanged(d->hasAudio);
}
if (d->hasVideo != false) {
d->hasVideo = false;
emit videoAvailableChanged(d->hasVideo);
}
if (d->seekable != false) {
d->seekable = false;
emit seekableChanged(d->seekable);
}
if (d->bufferStatus != 0) {
d->bufferStatus = 0;
emit bufferStatusChanged(d->bufferStatus);
}
if (d->position != 0) {
d->position = 0;
emit positionChanged(d->position);
}
if (d->duration != 0) {
d->duration = 0;
emit durationChanged(d->duration);
}
QMediaPlayer::MediaStatus mediaStatus = media.isNull() ? QMediaPlayer::NoMedia
: QMediaPlayer::LoadingMedia;
if (d->mediaStatus != mediaStatus) {
d->mediaStatus = mediaStatus;
emit mediaStatusChanged(d->mediaStatus);
}
emit mediaChanged(media);
QString urlString;
if (!d->stream) {
// If we can read the file via Qt, use the byte stream approach
foreach (const QMediaResource &resource, media.resources()) {
const QUrl url = resource.url();
if (url.isLocalFile()) {
urlString = url.toLocalFile();
QScopedPointer<QFile> file(new QFile(urlString));
if (file->open(QFile::ReadOnly)) {
file->setProperty(QT_WINRT_MEDIAPLAYER_STREAM_ID, true);
d->stream.reset(file.take());
break;
}
}
}
}
void QGstreamerPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
{
QMediaPlayer::State oldState = m_state;
m_state = QMediaPlayer::StoppedState;
m_session->stop();
if (m_bufferProgress != -1) {
m_bufferProgress = -1;
emit bufferStatusChanged(0);
}
if (m_stream) {
closeFifo();
disconnect(m_stream, SIGNAL(readyRead()), this, SLOT(writeFifo()));
m_stream = 0;
}
m_currentResource = content;
m_stream = stream;
m_seekToStartPending = false;
QNetworkRequest request;
if (m_stream) {
if (m_stream->isReadable() && openFifo()) {
request = QNetworkRequest(QUrl(QString(QLatin1String("fd://%1")).arg(m_fifoFd[0])));
}
} else if (!content.isNull()) {
request = content.canonicalRequest();
}
m_session->load(request);
if (m_fifoFd[1] >= 0) {
m_fifoCanWrite = true;
writeFifo();
}
if (!request.url().isEmpty()) {
if (m_mediaStatus != QMediaPlayer::LoadingMedia)
emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::LoadingMedia);
m_session->pause();
} else {
if (m_mediaStatus != QMediaPlayer::NoMedia)
emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::NoMedia);
setBufferProgress(0);
}
emit mediaChanged(m_currentResource);
if (m_state != oldState)
emit stateChanged(m_state);
}
/** Play current track in the playlist. */
void MediaPlayer::play()
{
// Check if it's possible to play tracks first
if (!_playlist) {
return;
}
QMediaContent mc = _playlist->media(_playlist->currentIndex());
if (mc.isNull()) {
return;
}
this->playMediaContent(mc);
}
bool QWmpPlaylist::addMedia(const QMediaContent &content)
{
bool appended = false;
IWMPMedia *media = 0;
if (!content.isNull() && m_playlist && m_player && m_player->newMedia(
QAutoBStr(content.canonicalUrl()), &media) == S_OK) {
appended = m_playlist->appendItem(media) == S_OK;
media->Release();
}
return appended;
}
void QMediaPlayerPrivate::_q_updateMedia(const QMediaContent &media)
{
Q_Q(QMediaPlayer);
if (!control)
return;
const QMediaPlayer::State currentState = state;
filterStates = true;
control->setMedia(media, 0);
if (!media.isNull()) {
switch (currentState) {
case QMediaPlayer::PlayingState:
control->play();
break;
case QMediaPlayer::PausedState:
control->pause();
break;
default:
break;
}
}
filterStates = false;
state = control->state();
if (state != currentState) {
if (state == QMediaPlayer::PlayingState)
q->addPropertyWatch("position");
else
q->removePropertyWatch("position");
emit q->stateChanged(state);
}
}
void QMediaPlayerPrivate::_q_updateMedia(const QMediaContent &media)
{
Q_Q(QMediaPlayer);
if (!control)
return;
// check if the current playlist is a top-level playlist
Q_ASSERT(playlist);
if (media.isNull() && playlist != rootMedia.playlist()) {
// switch back to parent playlist
QMediaPlaylist *pls = parentPlaylist(playlist);
Q_ASSERT(pls);
disconnectPlaylist();
playlist = pls;
connectPlaylist();
Q_ASSERT(!pendingPlaylist.playlist());
nestedPlaylists--;
Q_ASSERT(nestedPlaylists >= 0);
playlist->next();
return;
}
if (media.playlist()) {
if (nestedPlaylists < MAX_NESTED_PLAYLISTS) {
nestedPlaylists++;
Q_ASSERT(!pendingPlaylist.playlist());
// disconnect current playlist
disconnectPlaylist();
// new playlist signals are connected
// in the call to setPlaylist() in _q_handlePlaylistLoaded()
playlist = media.playlist();
emit q->currentMediaChanged(media);
_q_handlePlaylistLoaded();
return;
} else if (playlist) {
playlist->next();
}
return;
}
const QMediaPlayer::State currentState = state;
setMedia(media, 0);
if (!media.isNull()) {
switch (currentState) {
case QMediaPlayer::PlayingState:
control->play();
break;
case QMediaPlayer::PausedState:
control->pause();
break;
default:
break;
}
}
_q_stateChanged(control->state());
}
void QGstreamerPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
{
#ifdef DEBUG_PLAYBIN
qDebug() << Q_FUNC_INFO;
#endif
pushState();
m_currentState = QMediaPlayer::StoppedState;
QMediaContent oldMedia = m_currentResource;
m_pendingSeekPosition = 0;
m_session->showPrerollFrames(false); // do not show prerolled frames until pause() or play() explicitly called
m_setMediaPending = false;
if (!content.isNull() || stream) {
if (!m_resources->isGranted())
m_resources->acquire();
} else {
m_resources->release();
}
m_session->stop();
bool userStreamValid = false;
if (m_bufferProgress != -1) {
m_bufferProgress = -1;
emit bufferStatusChanged(0);
}
if (m_stream && m_stream != stream) {
if (m_ownStream)
delete m_stream;
m_stream = 0;
m_ownStream = false;
}
// If the canonical URL refers to a Qt resource, open with QFile and use
// the stream playback capability to play.
if (stream == 0 && content.canonicalUrl().scheme() == QLatin1String("qrc")) {
stream = new QFile(QLatin1Char(':') + content.canonicalUrl().path(), this);
if (!stream->open(QIODevice::ReadOnly)) {
delete stream;
m_mediaStatus = QMediaPlayer::InvalidMedia;
m_currentResource = content;
emit mediaChanged(m_currentResource);
emit error(QMediaPlayer::FormatError, tr("Attempting to play invalid Qt resource"));
if (m_currentState != QMediaPlayer::PlayingState)
m_resources->release();
popAndNotifyState();
return;
}
m_ownStream = true;
}
m_currentResource = content;
m_stream = stream;
QNetworkRequest request;
if (m_stream) {
userStreamValid = stream->isOpen() && m_stream->isReadable();
request = content.canonicalRequest();
} else if (!content.isNull()) {
request = content.canonicalRequest();
}
#if !defined(HAVE_GST_APPSRC)
m_session->loadFromUri(request);
#else
if (m_stream) {
if (userStreamValid){
m_session->loadFromStream(request, m_stream);
} else {
m_mediaStatus = QMediaPlayer::InvalidMedia;
emit error(QMediaPlayer::FormatError, tr("Attempting to play invalid user stream"));
if (m_currentState != QMediaPlayer::PlayingState)
m_resources->release();
popAndNotifyState();
return;
}
} else
m_session->loadFromUri(request);
#endif
#if defined(HAVE_GST_APPSRC)
if (!request.url().isEmpty() || userStreamValid) {
#else
if (!request.url().isEmpty()) {
#endif
m_mediaStatus = QMediaPlayer::LoadingMedia;
m_session->pause();
} else {
m_mediaStatus = QMediaPlayer::NoMedia;
setBufferProgress(0);
}
if (m_currentResource != oldMedia)
emit mediaChanged(m_currentResource);
emit positionChanged(position());
if (content.isNull() && !stream)
m_resources->release();
popAndNotifyState();
}
void QGstreamerPlayerControl::setVideoOutput(QObject *output)
{
m_session->setVideoRenderer(output);
}