qandroidmediaplayer.cpp

Go to the documentation of this file.

// 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 "wrappers/jni/androidmediaplayer_p.h"
#include "common/qandroidvideooutput_p.h"
#include "qandroidmetadata_p.h"
#include "common/qandroidaudiooutput_p.h"
#include "qaudiooutput.h"
 
#include <QtMultimedia/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());
 
    if (auto *rhiSink = qobject_cast<QRhiVideoSink *>(m_videoSink->platformVideoSink()))
        connect(rhiSink, &QRhiVideoSink::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"