qandroidmediaplayer.cpp

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++

++ #include "qandroidmediaplayer_p.h"

++ #include "androidmediaplayer_p.h"

++ #include "qandroidvideooutput_p.h"

++ #include "qandroidmetadata_p.h"

++ #include "qandroidaudiooutput_p.h"

++ #include "qaudiooutput.h"

++

++ #include <private/qplatformvideosink_p.h>

++ #include <qloggingcategory.h>

++

++ QT_BEGIN_NAMESPACE

++

++ using TrackType = QPlatformMediaPlayer::TrackType;

++

++ Q_STATIC_LOGGING_CATEGORY(lcMediaPlayer, "qt.multimedia.mediaplayer.android");

++

++ class StateChangeNotifier

++ {

++ public:

++     StateChangeNotifier(QAndroidMediaPlayer *mp)

++         : mControl(mp)

++         , mPreviousState(mp->state())

++         , mPreviousMediaStatus(mp->mediaStatus())

++     {

++         ++mControl->mActiveStateChangeNotifiers;

++     }

++

++     ~StateChangeNotifier()

++     {

++         if (--mControl->mActiveStateChangeNotifiers)

++             return;

++

++         if (mPreviousMediaStatus != mControl->mediaStatus())

++             Q_EMIT mControl->mediaStatusChanged(mControl->mediaStatus());

++

++         if (mPreviousState != mControl->state())

++             Q_EMIT mControl->stateChanged(mControl->state());

++     }

++

++ private:

++     QAndroidMediaPlayer *mControl;

++     QMediaPlayer::PlaybackState mPreviousState;

++     QMediaPlayer::MediaStatus mPreviousMediaStatus;

++ };

++

++ QAndroidMediaPlayer::QAndroidMediaPlayer(QMediaPlayer *parent)

++     : QPlatformMediaPlayer(parent),

++       mMediaPlayer(new AndroidMediaPlayer),

++       mState(AndroidMediaPlayer::Uninitialized)

++ {

++     // Set seekable to True by default. It changes if MEDIA_INFO_NOT_SEEKABLE is received

++     seekableChanged(true);

++     connect(mMediaPlayer, &AndroidMediaPlayer::bufferingChanged, this,

++             &QAndroidMediaPlayer::onBufferingChanged);

++     connect(mMediaPlayer, &AndroidMediaPlayer::info, this, &QAndroidMediaPlayer::onInfo);

++     connect(mMediaPlayer, &AndroidMediaPlayer::error, this, &QAndroidMediaPlayer::onError);

++     connect(mMediaPlayer, &AndroidMediaPlayer::stateChanged, this,

++             &QAndroidMediaPlayer::onStateChanged);

++     connect(mMediaPlayer, &AndroidMediaPlayer::videoSizeChanged, this,

++             &QAndroidMediaPlayer::onVideoSizeChanged);

++     connect(mMediaPlayer, &AndroidMediaPlayer::progressChanged, this,

++             &QAndroidMediaPlayer::positionChanged);

++     connect(mMediaPlayer, &AndroidMediaPlayer::durationChanged, this,

++             &QAndroidMediaPlayer::durationChanged);

++     connect(mMediaPlayer, &AndroidMediaPlayer::tracksInfoChanged, this,

++             &QAndroidMediaPlayer::updateTrackInfo);

++ }

++

++ QAndroidMediaPlayer::~QAndroidMediaPlayer()

++ {

++     if (m_videoSink)

++         disconnect(m_videoSink->platformVideoSink(), nullptr, this, nullptr);

++

++     mMediaPlayer->disconnect();

++     mMediaPlayer->release();

++     delete mMediaPlayer;

++ }

++

++ qint64 QAndroidMediaPlayer::duration() const

++ {

++     if (mediaStatus() == QMediaPlayer::NoMedia)

++         return 0;

++

++     if ((mState & (AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::Stopped

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         return 0;

++     }

++

++     return mMediaPlayer->getDuration();

++ }

++

++ qint64 QAndroidMediaPlayer::position() const

++ {

++     if (mediaStatus() == QMediaPlayer::EndOfMedia)

++         return duration();

++

++     if ((mState & (AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted))) {

++         return mMediaPlayer->getCurrentPosition();

++     }

++

++     return (mPendingPosition == -1) ? 0 : mPendingPosition;

++ }

++

++ void QAndroidMediaPlayer::setPosition(qint64 position)

++ {

++     if (!isSeekable())

++         return;

++

++     const int seekPosition = (position > INT_MAX) ? INT_MAX : position;

++

++     qint64 currentPosition = mMediaPlayer->getCurrentPosition();

++     if (seekPosition == currentPosition) {

++         // update position - will send a new frame of this position

++         // for consistency with other platforms

++         mMediaPlayer->seekTo(seekPosition);

++         return;

++     }

++     StateChangeNotifier notifier(this);

++

++     if (mediaStatus() == QMediaPlayer::EndOfMedia)

++         setMediaStatus(QMediaPlayer::LoadedMedia);

++

++     if ((mState & (AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         mPendingPosition = seekPosition;

++     } else {

++         mMediaPlayer->seekTo(seekPosition);

++

++         if (mPendingPosition != -1) {

++             mPendingPosition = -1;

++         }

++     }

++

++     Q_EMIT positionChanged(seekPosition);

++ }

++

++ void QAndroidMediaPlayer::setVolume(float volume)

++ {

++     if ((mState & (AndroidMediaPlayer::Idle

++                    | AndroidMediaPlayer::Initialized

++                    | AndroidMediaPlayer::Stopped

++                    | AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         mPendingVolume = volume;

++         return;

++     }

++

++     mMediaPlayer->setVolume(qRound(volume*100.));

++     mPendingVolume = -1;

++ }

++

++ void QAndroidMediaPlayer::setMuted(bool muted)

++ {

++     if ((mState & (AndroidMediaPlayer::Idle

++                    | AndroidMediaPlayer::Initialized

++                    | AndroidMediaPlayer::Stopped

++                    | AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         mPendingMute = muted;

++         return;

++     }

++

++     mMediaPlayer->setMuted(muted);

++     mPendingMute = -1;

++ }

++

++ QMediaMetaData QAndroidMediaPlayer::metaData() const

++ {

++     return QAndroidMetaData::extractMetadata(mMediaContent);

++ }

++

++ float QAndroidMediaPlayer::bufferProgress() const

++ {

++     return mBufferFilled ? 1. : mBufferPercent;

++ }

++

++ bool QAndroidMediaPlayer::isAudioAvailable() const

++ {

++     return mAudioAvailable;

++ }

++

++ bool QAndroidMediaPlayer::isVideoAvailable() const

++ {

++     return mVideoAvailable;

++ }

++

++ QMediaTimeRange QAndroidMediaPlayer::availablePlaybackRanges() const

++ {

++     return mAvailablePlaybackRange;

++ }

++

++ void QAndroidMediaPlayer::updateAvailablePlaybackRanges()

++ {

++     if (mBuffering) {

++         const qint64 pos = position();

++         const qint64 end = (duration() / 100) * mBufferPercent;

++         mAvailablePlaybackRange.addInterval(pos, end);

++     } else if (isSeekable()) {

++         mAvailablePlaybackRange = QMediaTimeRange(0, duration());

++     } else {

++         mAvailablePlaybackRange = QMediaTimeRange();

++     }

++

++ // ####    Q_EMIT availablePlaybackRangesChanged(mAvailablePlaybackRange);

++ }

++

++ qreal QAndroidMediaPlayer::playbackRate() const

++ {

++     return mCurrentPlaybackRate;

++ }

++

++ void QAndroidMediaPlayer::setPlaybackRate(qreal rate)

++ {

++     if (mState != AndroidMediaPlayer::Started) {

++         // If video isn't playing, changing speed rate may start it automatically

++         // It need to be postponed

++         if (mCurrentPlaybackRate != rate) {

++             mCurrentPlaybackRate = rate;

++             mHasPendingPlaybackRate = true;

++             Q_EMIT playbackRateChanged(rate);

++         }

++         return;

++     }

++

++     if (mMediaPlayer->setPlaybackRate(rate)) {

++         mCurrentPlaybackRate = rate;

++         Q_EMIT playbackRateChanged(rate);

++     }

++ }

++

++ QUrl QAndroidMediaPlayer::media() const

++ {

++     return mMediaContent;

++ }

++

++ const QIODevice *QAndroidMediaPlayer::mediaStream() const

++ {

++     return mMediaStream;

++ }

++

++ void QAndroidMediaPlayer::setMedia(const QUrl &mediaContent,

++                                           QIODevice *stream)

++ {

++     StateChangeNotifier notifier(this);

++

++     mReloadingMedia = (mMediaContent == mediaContent) && !mPendingSetMedia;

++

++     if (!mReloadingMedia) {

++         mMediaContent = mediaContent;

++         mMediaStream = stream;

++     }

++

++     if (mediaContent.isEmpty()) {

++         setMediaStatus(QMediaPlayer::NoMedia);

++     } else {

++         if (mVideoOutput && !mVideoOutput->isReady()) {

++             // if a video output is set but the video texture is not ready, delay loading the media

++             // since it can cause problems on some hardware

++             mPendingSetMedia = true;

++             return;

++         }

++

++         if (mVideoSize.isValid() && mVideoOutput)

++             mVideoOutput->setVideoSize(mVideoSize);

++

++         if (mVideoOutput &&

++                         (mMediaPlayer->display() == 0 || mVideoOutput->shouldTextureBeUpdated()))

++             mMediaPlayer->setDisplay(mVideoOutput->surfaceTexture());

++         mMediaPlayer->setDataSource(QNetworkRequest(mediaContent));

++         mMediaPlayer->prepareAsync();

++

++         if (!mReloadingMedia)

++             setMediaStatus(QMediaPlayer::LoadingMedia);

++     }

++

++     resetBufferingProgress();

++

++     mReloadingMedia = false;

++ }

++

++ void QAndroidMediaPlayer::setVideoSink(QVideoSink *sink)

++ {

++     if (m_videoSink == sink)

++         return;

++

++     if (m_videoSink)

++         disconnect(m_videoSink->platformVideoSink(), nullptr, this, nullptr);

++

++     m_videoSink = sink;

++

++     if (!m_videoSink) {

++         return;

++     }

++

++     if (mVideoOutput) {

++         delete mVideoOutput;

++         mVideoOutput = nullptr;

++         mMediaPlayer->setDisplay(nullptr);

++     }

++

++     mVideoOutput = new QAndroidTextureVideoOutput(sink, this);

++     connect(mVideoOutput, &QAndroidTextureVideoOutput::readyChanged, this,

++             &QAndroidMediaPlayer::onVideoOutputReady);

++     connect(mMediaPlayer, &AndroidMediaPlayer::timedTextChanged, mVideoOutput,

++             &QAndroidTextureVideoOutput::setSubtitle);

++

++     if (mVideoOutput->isReady())

++         mMediaPlayer->setDisplay(mVideoOutput->surfaceTexture());

++

++     connect(m_videoSink->platformVideoSink(), &QPlatformVideoSink::rhiChanged, this, [&]()

++             { mMediaPlayer->setDisplay(mVideoOutput->surfaceTexture()); });

++ }

++

++ void QAndroidMediaPlayer::setAudioOutput(QPlatformAudioOutput *output)

++ {

++     if (m_audioOutput == output)

++         return;

++     if (m_audioOutput)

++         m_audioOutput->q->disconnect(this);

++     m_audioOutput = static_cast<QAndroidAudioOutput *>(output);

++     if (m_audioOutput) {

++         connect(m_audioOutput->q, &QAudioOutput::deviceChanged, this, &QAndroidMediaPlayer::updateAudioDevice);

++         connect(m_audioOutput->q, &QAudioOutput::volumeChanged, this, &QAndroidMediaPlayer::setVolume);

++         connect(m_audioOutput->q, &QAudioOutput::mutedChanged, this, &QAndroidMediaPlayer::setMuted);

++         updateAudioDevice();

++     }

++ }

++

++ void QAndroidMediaPlayer::updateAudioDevice()

++ {

++     if (m_audioOutput)

++         mMediaPlayer->setAudioOutput(m_audioOutput->device.id());

++ }

++

++ void QAndroidMediaPlayer::play()

++ {

++     StateChangeNotifier notifier(this);

++

++     resetCurrentLoop();

++

++     // We need to prepare the mediaplayer again.

++     if ((mState & AndroidMediaPlayer::Stopped) && !mMediaContent.isEmpty()) {

++         setMedia(mMediaContent, mMediaStream);

++     }

++

++     if (!mMediaContent.isEmpty())

++         stateChanged(QMediaPlayer::PlayingState);

++

++     if ((mState & (AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         mPendingState = QMediaPlayer::PlayingState;

++         return;

++     }

++

++     if (mVideoOutput)

++         mVideoOutput->start();

++

++     updateAudioDevice();

++

++     if (mHasPendingPlaybackRate) {

++         mHasPendingPlaybackRate = false;

++         if (mMediaPlayer->setPlaybackRate(mCurrentPlaybackRate))

++             return;

++         mCurrentPlaybackRate = mMediaPlayer->playbackRate();

++         Q_EMIT playbackRateChanged(mCurrentPlaybackRate);

++     }

++

++     mMediaPlayer->play();

++ }

++

++ void QAndroidMediaPlayer::pause()

++ {

++     // cannot pause without media

++     if (mediaStatus() == QMediaPlayer::NoMedia)

++         return;

++

++     StateChangeNotifier notifier(this);

++

++     stateChanged(QMediaPlayer::PausedState);

++

++     if ((mState & (AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted

++                    | AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Stopped)) == 0) {

++         mPendingState = QMediaPlayer::PausedState;

++         return;

++     }

++

++     const qint64 currentPosition = mMediaPlayer->getCurrentPosition();

++     setPosition(currentPosition);

++

++     mMediaPlayer->pause();

++ }

++

++ void QAndroidMediaPlayer::stop()

++ {

++     StateChangeNotifier notifier(this);

++

++     stateChanged(QMediaPlayer::StoppedState);

++

++     if ((mState & (AndroidMediaPlayer::Prepared

++                    | AndroidMediaPlayer::Started

++                    | AndroidMediaPlayer::Stopped

++                    | AndroidMediaPlayer::Paused

++                    | AndroidMediaPlayer::PlaybackCompleted)) == 0) {

++         if ((mState & (AndroidMediaPlayer::Idle | AndroidMediaPlayer::Uninitialized | AndroidMediaPlayer::Error)) == 0)

++             mPendingState = QMediaPlayer::StoppedState;

++         return;

++     }

++

++     if (mCurrentPlaybackRate != 1.)

++         // Playback rate need to by reapplied

++         mHasPendingPlaybackRate = true;

++

++     if (mVideoOutput)

++         mVideoOutput->stop();

++

++     mMediaPlayer->stop();

++ }

++

++ void QAndroidMediaPlayer::onInfo(qint32 what, qint32 extra)

++ {

++     StateChangeNotifier notifier(this);

++

++     Q_UNUSED(extra);

++     switch (what) {

++     case AndroidMediaPlayer::MEDIA_INFO_UNKNOWN:

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_VIDEO_TRACK_LAGGING:

++         // IGNORE

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_VIDEO_RENDERING_START:

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_BUFFERING_START:

++         mPendingState = state();

++         stateChanged(QMediaPlayer::PausedState);

++         setMediaStatus(QMediaPlayer::StalledMedia);

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_BUFFERING_END:

++         if (state() != QMediaPlayer::StoppedState)

++             flushPendingStates();

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_BAD_INTERLEAVING:

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_NOT_SEEKABLE:

++         seekableChanged(false);

++         break;

++     case AndroidMediaPlayer::MEDIA_INFO_METADATA_UPDATE:

++         Q_EMIT metaDataChanged();

++         break;

++     }

++ }

++

++ void QAndroidMediaPlayer::onError(qint32 what, qint32 extra)

++ {

++     StateChangeNotifier notifier(this);

++

++     QString errorString;

++     QMediaPlayer::Error error = QMediaPlayer::ResourceError;

++

++     switch (what) {

++     case AndroidMediaPlayer::MEDIA_ERROR_UNKNOWN:

++         errorString = QLatin1String("Error:");

++         break;

++     case AndroidMediaPlayer::MEDIA_ERROR_SERVER_DIED:

++         errorString = QLatin1String("Error: Server died");

++         error = QMediaPlayer::ResourceError;

++         break;

++     case AndroidMediaPlayer::MEDIA_ERROR_INVALID_STATE:

++         errorString = QLatin1String("Error: Invalid state");

++         error = QMediaPlayer::ResourceError;

++         break;

++     }

++

++     switch (extra) {

++     case AndroidMediaPlayer::MEDIA_ERROR_IO: // Network OR file error

++         errorString += QLatin1String(" (I/O operation failed)");

++         setInvalidMediaWithError(QMediaPlayer::NetworkError, errorString);

++         return;

++     case AndroidMediaPlayer::MEDIA_ERROR_MALFORMED:

++         errorString += QLatin1String(" (Malformed bitstream)");

++         setInvalidMediaWithError(QMediaPlayer::FormatError, errorString);

++         return;

++     case AndroidMediaPlayer::MEDIA_ERROR_UNSUPPORTED:

++         errorString += QLatin1String(" (Unsupported media)");

++         setInvalidMediaWithError(QMediaPlayer::FormatError, errorString);

++         return;

++     case AndroidMediaPlayer::MEDIA_ERROR_TIMED_OUT:

++         errorString += QLatin1String(" (Timed out)");

++         break;

++     case AndroidMediaPlayer::MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:

++         errorString += QLatin1String(" (Unable to start progressive playback')");

++         setInvalidMediaWithError(QMediaPlayer::FormatError, errorString);

++         return;

++     case AndroidMediaPlayer::MEDIA_ERROR_BAD_THINGS_ARE_GOING_TO_HAPPEN:

++         errorString += mMediaContent.scheme() == QLatin1String("rtsp")

++             ? QLatin1String(" (Unknown error/Insufficient resources or RTSP may not be supported)")

++             : QLatin1String(" (Unknown error/Insufficient resources)");

++         error = QMediaPlayer::ResourceError;

++         break;

++     }

++

++     Q_EMIT QPlatformMediaPlayer::error(error, errorString);

++ }

++

++ void QAndroidMediaPlayer::onBufferingChanged(qint32 percent)

++ {

++     StateChangeNotifier notifier(this);

++

++     mBuffering = percent != 100;

++     mBufferPercent = percent;

++

++     updateAvailablePlaybackRanges();

++

++     if (state() != QMediaPlayer::StoppedState)

++         setMediaStatus(mBuffering ? QMediaPlayer::BufferingMedia : QMediaPlayer::BufferedMedia);

++

++     updateBufferStatus();

++ }

++

++ void QAndroidMediaPlayer::onVideoSizeChanged(qint32 width, qint32 height)

++ {

++     QSize newSize(width, height);

++

++     if (width == 0 || height == 0 || newSize == mVideoSize)

++         return;

++

++     setVideoAvailable(true);

++     mVideoSize = newSize;

++

++     if (mVideoOutput)

++         mVideoOutput->setVideoSize(mVideoSize);

++ }

++

++ void QAndroidMediaPlayer::onStateChanged(qint32 state)

++ {

++     // If reloading, don't report state changes unless the new state is Prepared or Error.

++     if ((mState & AndroidMediaPlayer::Stopped)

++         && (state & (AndroidMediaPlayer::Prepared | AndroidMediaPlayer::Error | AndroidMediaPlayer::Uninitialized)) == 0) {

++         return;

++     }

++

++     StateChangeNotifier notifier(this);

++

++     mState = state;

++     switch (mState) {

++     case AndroidMediaPlayer::Idle:

++         break;

++     case AndroidMediaPlayer::Initialized:

++         break;

++     case AndroidMediaPlayer::Preparing:

++         if (!mReloadingMedia)

++             setMediaStatus(QMediaPlayer::LoadingMedia);

++         break;

++     case AndroidMediaPlayer::Prepared:

++         setMediaStatus(QMediaPlayer::LoadedMedia);

++         if (mBuffering) {

++             setMediaStatus(mBufferPercent == 100 ? QMediaPlayer::BufferedMedia

++                                                  : QMediaPlayer::BufferingMedia);

++         } else {

++             onBufferingChanged(100);

++         }

++         setPosition(0);

++         Q_EMIT metaDataChanged();

++         setAudioAvailable(true);

++         flushPendingStates();

++         break;

++     case AndroidMediaPlayer::Started:

++         stateChanged(QMediaPlayer::PlayingState);

++         if (mBuffering) {

++             setMediaStatus(mBufferPercent == 100 ? QMediaPlayer::BufferedMedia

++                                                  : QMediaPlayer::BufferingMedia);

++         } else {

++             setMediaStatus(QMediaPlayer::BufferedMedia);

++         }

++         Q_EMIT positionChanged(position());

++         break;

++     case AndroidMediaPlayer::Paused:

++         stateChanged(QMediaPlayer::PausedState);

++         if (mediaStatus() == QMediaPlayer::EndOfMedia) {

++             setPosition(0);

++             setMediaStatus(QMediaPlayer::BufferedMedia);

++         } else {

++             Q_EMIT positionChanged(position());

++         }

++         break;

++     case AndroidMediaPlayer::Error:

++         stateChanged(QMediaPlayer::StoppedState);

++         setMediaStatus(QMediaPlayer::InvalidMedia);

++         mMediaPlayer->release();

++         Q_EMIT positionChanged(0);

++         break;

++     case AndroidMediaPlayer::Stopped:

++         stateChanged(QMediaPlayer::StoppedState);

++         setMediaStatus(QMediaPlayer::LoadedMedia);

++         Q_EMIT positionChanged(0);

++         break;

++     case AndroidMediaPlayer::PlaybackCompleted:

++         if (doLoop()) {

++             setPosition(0);

++             mMediaPlayer->play();

++             break;

++         }

++         stateChanged(QMediaPlayer::StoppedState);

++         setMediaStatus(QMediaPlayer::EndOfMedia);

++         break;

++     case AndroidMediaPlayer::Uninitialized:

++         // reset some properties (unless we reload the same media)

++         if (!mReloadingMedia) {

++             resetBufferingProgress();

++             mPendingPosition = -1;

++             mPendingSetMedia = false;

++             mPendingState = -1;

++

++             Q_EMIT durationChanged(0);

++             Q_EMIT positionChanged(0);

++

++             setAudioAvailable(false);

++             setVideoAvailable(false);

++             seekableChanged(true);

++         }

++         break;

++     default:

++         break;

++     }

++

++     if ((mState & (AndroidMediaPlayer::Stopped | AndroidMediaPlayer::Uninitialized)) != 0) {

++         mMediaPlayer->setDisplay(0);

++         if (mVideoOutput) {

++             mVideoOutput->stop();

++         }

++     }

++ }

++

++ int QAndroidMediaPlayer::trackCount(TrackType trackType)

++ {

++     if (!mTracksMetadata.contains(trackType))

++         return -1;

++

++     auto tracks = mTracksMetadata.value(trackType);

++     return tracks.count();

++ }

++

++ QMediaMetaData QAndroidMediaPlayer::trackMetaData(TrackType trackType, int streamNumber)

++ {

++     if (!mTracksMetadata.contains(trackType))

++         return QMediaMetaData();

++

++     auto tracks = mTracksMetadata.value(trackType);

++     if (tracks.count() < streamNumber)

++         return QMediaMetaData();

++

++     QAndroidMetaData trackInfo = tracks.at(streamNumber);

++     return static_cast<QMediaMetaData>(trackInfo);

++ }

++

++ std::optional<TrackType> convertTrackType(AndroidMediaPlayer::TrackType type)

++ {

++     switch (type) {

++     case AndroidMediaPlayer::TrackType::Video:

++         return TrackType::VideoStream;

++     case AndroidMediaPlayer::TrackType::Audio:

++         return TrackType::AudioStream;

++     case AndroidMediaPlayer::TrackType::TimedText:

++         return TrackType::SubtitleStream;

++     case AndroidMediaPlayer::TrackType::Subtitle:

++         return TrackType::SubtitleStream;

++     case AndroidMediaPlayer::TrackType::Unknown:

++     case AndroidMediaPlayer::TrackType::Metadata:

++         return std::nullopt;

++     }

++

++     return std::nullopt;

++ }

++

++ int QAndroidMediaPlayer::convertTrackNumber(int androidTrackNumber)

++ {

++     int trackNumber = androidTrackNumber;

++

++     int videoTrackCount = trackCount(TrackType::VideoStream);

++     if (trackNumber <= videoTrackCount)

++         return trackNumber;

++

++     trackNumber = trackNumber - videoTrackCount;

++

++     int audioTrackCount = trackCount(TrackType::AudioStream);

++     if (trackNumber <= audioTrackCount)

++         return trackNumber;

++

++     trackNumber = trackNumber - audioTrackCount;

++

++     auto subtitleTracks = mTracksMetadata.value(TrackType::SubtitleStream);

++     int timedTextCount = 0;

++     int subtitleTextCount = 0;

++     for (const auto &track : subtitleTracks) {

++         if (track.androidTrackType() == 3) // 3 == TimedText

++             timedTextCount++;

++

++         if (track.androidTrackType() == 4) // 4 == Subtitle

++             subtitleTextCount++;

++     }

++

++     if (trackNumber <= timedTextCount)

++         return trackNumber;

++

++     trackNumber = trackNumber - timedTextCount;

++

++     if (trackNumber <= subtitleTextCount)

++         return trackNumber;

++

++     return -1;

++ }

++

++ int QAndroidMediaPlayer::activeTrack(TrackType trackType)

++ {

++     int androidTrackNumber = -1;

++

++     switch (trackType) {

++     case TrackType::VideoStream: {

++         if (!mIsVideoTrackEnabled)

++             return -1;

++         androidTrackNumber = mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::Video);

++     }

++     case TrackType::AudioStream: {

++         if (!mIsAudioTrackEnabled)

++             return -1;

++

++         androidTrackNumber = mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::Audio);

++     }

++     case TrackType::SubtitleStream: {

++         int timedTextSelectedTrack =

++                 mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::TimedText);

++

++         if (timedTextSelectedTrack > -1) {

++             androidTrackNumber = timedTextSelectedTrack;

++             break;

++         }

++

++         int subtitleSelectedTrack =

++                 mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::Subtitle);

++         if (subtitleSelectedTrack > -1) {

++             androidTrackNumber = subtitleSelectedTrack;

++             break;

++         }

++

++         return -1;

++     }

++     }

++

++     return convertTrackNumber(androidTrackNumber);

++ }

++

++ void QAndroidMediaPlayer::disableTrack(TrackType trackType)

++ {

++     const auto track = activeTrack(trackType);

++

++     switch (trackType) {

++     case TrackType::VideoStream: {

++         if (track > -1) {

++             mMediaPlayer->setDisplay(nullptr);

++             mIsVideoTrackEnabled = false;

++         }

++         break;

++     }

++     case TrackType::AudioStream: {

++         if (track > -1) {

++             mMediaPlayer->setMuted(true);

++             mMediaPlayer->blockAudio();

++             mIsAudioTrackEnabled = false;

++         }

++         break;

++     }

++     case TrackType::SubtitleStream: {

++         // subtitles and timedtext tracks can be selected at the same time so deselect both

++         int subtitleSelectedTrack =

++                 mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::Subtitle);

++         if (subtitleSelectedTrack > -1)

++             mMediaPlayer->deselectTrack(subtitleSelectedTrack);

++

++         int timedTextSelectedTrack =

++                 mMediaPlayer->activeTrack(AndroidMediaPlayer::TrackType::TimedText);

++         if (timedTextSelectedTrack > -1)

++             mMediaPlayer->deselectTrack(timedTextSelectedTrack);

++

++         break;

++     }

++     }

++ }

++

++ void QAndroidMediaPlayer::setActiveTrack(TrackType trackType, int streamNumber)

++ {

++

++     if (!mTracksMetadata.contains(trackType)) {

++         qCWarning(lcMediaPlayer)

++                 << "Trying to set a active track which type has no available tracks.";

++         return;

++     }

++

++     const auto &tracks = mTracksMetadata.value(trackType);

++     if (streamNumber > tracks.count()) {

++         qCWarning(lcMediaPlayer) << "Trying to set a active track that does not exist.";

++         return;

++     }

++

++     // in case of < 0 deselect tracktype

++     if (streamNumber < 0) {

++         disableTrack(trackType);

++         return;

++     }

++

++     const auto currentTrack = activeTrack(trackType);

++     if (streamNumber == currentTrack) {

++         return;

++     }

++

++     if (trackType == TrackType::VideoStream && !mIsVideoTrackEnabled) {

++         // enable video stream

++         mMediaPlayer->setDisplay(mVideoOutput->surfaceTexture());

++         mIsVideoTrackEnabled = true;

++     }

++

++     if (trackType == TrackType::AudioStream && !mIsAudioTrackEnabled) {

++         // enable audio stream

++         mMediaPlayer->unblockAudio();

++         mMediaPlayer->setMuted(false);

++         mIsAudioTrackEnabled = true;

++     }

++

++     if (trackType == TrackType::SubtitleStream) {

++         // subtitles and timedtext tracks can be selected at the same time so deselect both before

++         // selecting a new one

++         disableTrack(TrackType::SubtitleStream);

++     }

++

++     const auto &trackInfo = tracks.at(streamNumber);

++     const auto &trackNumber = trackInfo.androidTrackNumber();

++     mMediaPlayer->selectTrack(trackNumber);

++

++     Q_EMIT activeTracksChanged();

++ }

++

++ void QAndroidMediaPlayer::positionChanged(qint64 position)

++ {

++     QPlatformMediaPlayer::positionChanged(position);

++ }

++

++ void QAndroidMediaPlayer::durationChanged(qint64 duration)

++ {

++     QPlatformMediaPlayer::durationChanged(duration);

++ }

++

++ void QAndroidMediaPlayer::onVideoOutputReady(bool ready)

++ {

++     if ((mMediaPlayer->display() == 0) && mVideoOutput && ready)

++         mMediaPlayer->setDisplay(mVideoOutput->surfaceTexture());

++

++     flushPendingStates();

++ }

++

++ void QAndroidMediaPlayer::setMediaStatus(QMediaPlayer::MediaStatus status)

++ {

++     mediaStatusChanged(status);

++

++     if (status == QMediaPlayer::NoMedia || status == QMediaPlayer::InvalidMedia) {

++         Q_EMIT durationChanged(0);

++         Q_EMIT metaDataChanged();

++         setAudioAvailable(false);

++         setVideoAvailable(false);

++     }

++

++     if (status == QMediaPlayer::EndOfMedia)

++         Q_EMIT positionChanged(position());

++

++     updateBufferStatus();

++ }

++

++ void QAndroidMediaPlayer::setAudioAvailable(bool available)

++ {

++     if (mAudioAvailable == available)

++         return;

++

++     mAudioAvailable = available;

++     Q_EMIT audioAvailableChanged(mAudioAvailable);

++ }

++

++ void QAndroidMediaPlayer::setVideoAvailable(bool available)

++ {

++     if (mVideoAvailable == available)

++         return;

++

++     if (!available)

++         mVideoSize = QSize();

++

++     mVideoAvailable = available;

++     Q_EMIT videoAvailableChanged(mVideoAvailable);

++ }

++

++ void QAndroidMediaPlayer::resetBufferingProgress()

++ {

++     mBuffering = false;

++     mBufferPercent = 0;

++     mAvailablePlaybackRange = QMediaTimeRange();

++ }

++

++ void QAndroidMediaPlayer::flushPendingStates()

++ {

++     if (mPendingSetMedia) {

++         setMedia(mMediaContent, 0);

++         mPendingSetMedia = false;

++         return;

++     }

++

++     const int newState = mPendingState;

++     mPendingState = -1;

++

++     if (mPendingPosition != -1)

++         setPosition(mPendingPosition);

++     if (mPendingVolume >= 0)

++         setVolume(mPendingVolume);

++     if (mPendingMute != -1)

++         setMuted((mPendingMute == 1));

++

++     switch (newState) {

++     case QMediaPlayer::PlayingState:

++         play();

++         break;

++     case QMediaPlayer::PausedState:

++         pause();

++         break;

++     case QMediaPlayer::StoppedState:

++         stop();

++         break;

++     default:

++         break;

++     }

++ }

++

++ void QAndroidMediaPlayer::updateBufferStatus()

++ {

++     const auto &status = mediaStatus();

++     bool bufferFilled = (status == QMediaPlayer::BufferedMedia || status == QMediaPlayer::BufferingMedia);

++

++     if (mBufferFilled != bufferFilled)

++         mBufferFilled = bufferFilled;

++

++     Q_EMIT bufferProgressChanged(bufferProgress());

++ }

++

++ void QAndroidMediaPlayer::updateTrackInfo()

++ {

++     const auto &androidTracksInfo = mMediaPlayer->tracksInfo();

++

++     // prepare mTracksMetadata

++     mTracksMetadata[TrackType::VideoStream] = QList<QAndroidMetaData>();

++     mTracksMetadata[TrackType::AudioStream] = QList<QAndroidMetaData>();

++     mTracksMetadata[TrackType::SubtitleStream] = QList<QAndroidMetaData>();

++

++     for (const auto &androidTrackInfo : androidTracksInfo) {

++

++         const auto mediaPlayerType = convertTrackType(androidTrackInfo.trackType);

++         if (!mediaPlayerType)

++             continue;

++

++         auto &tracks = mTracksMetadata[*mediaPlayerType];

++

++         const QAndroidMetaData metadata(*mediaPlayerType, androidTrackInfo.trackType,

++                                         androidTrackInfo.trackNumber, androidTrackInfo.mimeType,

++                                         androidTrackInfo.language);

++         tracks.append(metadata);

++     }

++

++     Q_EMIT tracksChanged();

++ }

++

++ QT_END_NAMESPACE

++

++ #include "moc_qandroidmediaplayer_p.cpp"

Revision control