void QGstreamerPlayerControl::setBufferProgress(int progress)
{
if (m_bufferProgress == progress || m_mediaStatus == QMediaPlayer::NoMedia)
return;
QMediaPlayer::MediaStatus oldStatus = m_mediaStatus;
m_bufferProgress = progress;
if (m_state == QMediaPlayer::StoppedState) {
m_mediaStatus = QMediaPlayer::LoadedMedia;
} else {
if (m_bufferProgress < 100) {
m_mediaStatus = QMediaPlayer::StalledMedia;
m_session->pause();
} else {
m_mediaStatus = QMediaPlayer::BufferedMedia;
if (m_state == QMediaPlayer::PlayingState)
m_session->play();
}
}
if (m_mediaStatus != oldStatus)
emit mediaStatusChanged(m_mediaStatus);
emit bufferStatusChanged(m_bufferProgress);
}
void QAndroidMediaPlayerControl::resetBufferingProgress()
{
mBuffering = false;
mBufferPercent = 0;
mAvailablePlaybackRange = QMediaTimeRange();
Q_EMIT bufferStatusChanged(mBufferPercent);
}
void QGstreamerPlayerControl::setBufferProgress(int progress)
{
if (m_bufferProgress == progress || m_mediaStatus == QMediaPlayer::NoMedia)
return;
#ifdef DEBUG_PLAYBIN
qDebug() << Q_FUNC_INFO << progress;
#endif
m_bufferProgress = progress;
if (m_resources->isGranted()) {
if (m_currentState == QMediaPlayer::PlayingState &&
m_bufferProgress == 100 &&
m_session->state() != QMediaPlayer::PlayingState)
m_session->play();
if (!m_session->isLiveSource() && m_bufferProgress < 100 &&
(m_session->state() == QMediaPlayer::PlayingState ||
m_session->pendingState() == QMediaPlayer::PlayingState))
m_session->pause();
}
updateMediaStatus();
emit bufferStatusChanged(m_bufferProgress);
}
void QAndroidMediaPlayerControl::onBufferChanged(qint32 percent)
{
mBuffering = percent != 100;
mBufferPercent = percent;
Q_EMIT bufferStatusChanged(mBufferPercent);
updateAvailablePlaybackRanges();
if (mBufferPercent == 100)
setMediaStatus(QMediaPlayer::BufferedMedia);
}
void BbMediaPlayerControl::bpsEventHandler(bps_event_t *event)
{
if (m_videoControl)
m_videoControl->bpsEventHandler(event);
if (bps_event_get_domain(event) != mmrenderer_get_domain())
return;
if (bps_event_get_code(event) == MMRENDERER_STATE_CHANGE) {
const mmrenderer_state_t newState = mmrenderer_event_get_state(event);
if (newState == MMR_STOPPED) {
// Only react to stop events that happen when the end of the stream is reached and
// playback is stopped because of this.
// Ignore other stop event sources, souch as calling mmr_stop() ourselves and
// mmr_input_attach().
if (m_stopEventsToIgnore > 0) {
--m_stopEventsToIgnore;
} else {
setMediaStatus(QMediaPlayer::EndOfMedia);
stopInternal(IgnoreMmRenderer);
}
return;
}
}
if (bps_event_get_code(event) == MMRENDERER_STATUS_UPDATE) {
// Prevent spurious position change events from overriding our own position, for example
// when setting the position to 0 in stop().
if (m_state != QMediaPlayer::PlayingState ||
m_mediaStatus == QMediaPlayer::LoadingMedia ||
m_mediaStatus == QMediaPlayer::NoMedia ||
m_mediaStatus == QMediaPlayer::InvalidMedia)
return;
const qint64 newPosition = QString::fromAscii(mmrenderer_event_get_position(event)).toLongLong();
if (newPosition != 0 && newPosition != m_position) {
m_position = newPosition;
emit positionChanged(m_position);
}
const QString bufferStatus = QString::fromAscii(mmrenderer_event_get_bufferlevel(event));
const int slashPos = bufferStatus.indexOf('/');
if (slashPos != -1) {
const int fill = bufferStatus.left(slashPos).toInt();
const int capacity = bufferStatus.mid(slashPos + 1).toInt();
if (capacity != 0) {
m_bufferStatus = fill / static_cast<float>(capacity) * 100.0f;
emit bufferStatusChanged(m_bufferStatus);
}
}
}
}
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);
}
void MmRendererMediaPlayerControl::setMmBufferLevel(const QString &bufferLevel)
{
// buffer level has format level/capacity, e.g. "91319/124402"
const int slashPos = bufferLevel.indexOf('/');
if (slashPos != -1) {
const int fill = bufferLevel.leftRef(slashPos).toInt();
const int capacity = bufferLevel.midRef(slashPos + 1).toInt();
if (capacity != 0) {
m_bufferLevel = fill / static_cast<float>(capacity) * 100.0f;
emit bufferStatusChanged(m_bufferLevel);
}
}
}
void MmRendererMediaPlayerControl::attach()
{
// Should only be called in detached state
Q_ASSERT(m_audioId == -1 && !m_inputAttached);
if (m_media.isNull() || !m_context) {
setMediaStatus(QMediaPlayer::NoMedia);
return;
}
if (m_videoRendererControl)
m_videoRendererControl->attachDisplay(m_context);
if (m_videoWindowControl)
m_videoWindowControl->attachDisplay(m_context);
const QByteArray defaultAudioDevice = qgetenv("QQNX_RENDERER_DEFAULT_AUDIO_SINK");
m_audioId = mmr_output_attach(m_context, defaultAudioDevice.isEmpty() ? "audio:default" : defaultAudioDevice.constData(), "audio");
if (m_audioId == -1) {
emitMmError("mmr_output_attach() for audio failed");
return;
}
const QByteArray resourcePath = resourcePathForUrl(m_media.canonicalUrl());
if (resourcePath.isEmpty()) {
detach();
return;
}
if (mmr_input_attach(m_context, resourcePath.constData(), "track") != 0) {
emitMmError(QStringLiteral("mmr_input_attach() failed for ") + QString(resourcePath));
setMediaStatus(QMediaPlayer::InvalidMedia);
detach();
return;
}
// For whatever reason, the mmrenderer sends out a MMR_STOPPED event when calling
// mmr_input_attach() above. Ignore it, as otherwise we'll trigger stopping right after we
// started.
m_stopEventsToIgnore++;
m_inputAttached = true;
setMediaStatus(QMediaPlayer::LoadedMedia);
// mm-renderer has buffer properties "status" and "level"
// QMediaPlayer's buffer status maps to mm-renderer's buffer level
m_bufferLevel = 0;
emit bufferStatusChanged(m_bufferLevel);
}
void BbMediaPlayerControl::attach()
{
if (m_media.isNull() || !m_context) {
setMediaStatus(QMediaPlayer::NoMedia);
return;
}
if (m_videoControl)
m_videoControl->attachDisplay(m_context);
m_audioId = mmr_output_attach(m_context, "audio:default", "audio");
if (m_audioId == -1) {
emitMmError("mmr_output_attach() for audio failed");
return;
}
const QString resourcePath = resourcePathForUrl(m_media.canonicalUrl());
if (resourcePath.isEmpty()) {
detach();
return;
}
if (mmr_input_attach(m_context, QFile::encodeName(resourcePath), "track") != 0) {
emitMmError(QString("mmr_input_attach() for %1 failed").arg(resourcePath));
setMediaStatus(QMediaPlayer::InvalidMedia);
detach();
return;
}
// For whatever reason, the mmrenderer sends out a MMR_STOPPED event when calling
// mmr_input_attach() above. Ignore it, as otherwise we'll trigger stopping right after we
// started.
m_stopEventsToIgnore++;
m_inputAttached = true;
setMediaStatus(QMediaPlayer::LoadedMedia);
m_bufferStatus = 0;
emit bufferStatusChanged(m_bufferStatus);
}
void QAndroidMediaPlayerControl::onMediaPlayerInfo(qint32 what, qint32 extra)
{
switch (what) {
case JMediaPlayer::MEDIA_PLAYER_INVALID_STATE:
setError(what, QStringLiteral("Error: Invalid state"));
break;
case JMediaPlayer::MEDIA_PLAYER_PREPARING:
setMediaStatus(QMediaPlayer::LoadingMedia);
setState(QMediaPlayer::StoppedState);
break;
case JMediaPlayer::MEDIA_PLAYER_READY:
if (mBuffering) {
setMediaStatus(mBufferPercent == 100 ? QMediaPlayer::BufferedMedia
: QMediaPlayer::BufferingMedia);
} else {
setMediaStatus(QMediaPlayer::LoadedMedia);
mBufferPercent = 100;
Q_EMIT bufferStatusChanged(mBufferPercent);
updateAvailablePlaybackRanges();
}
setAudioAvailable(true);
mMediaPlayerReady = true;
flushPendingStates();
break;
case JMediaPlayer::MEDIA_PLAYER_DURATION:
Q_EMIT durationChanged(extra);
break;
case JMediaPlayer::MEDIA_PLAYER_PROGRESS:
Q_EMIT positionChanged(extra);
break;
case JMediaPlayer::MEDIA_PLAYER_FINISHED:
setState(QMediaPlayer::StoppedState);
setMediaStatus(QMediaPlayer::EndOfMedia);
break;
}
}
void setBufferStatus(int status) { emit bufferStatusChanged(m_bufferStatus = status); }
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);
}
