qmediaengineplayer.cpp

Go to the documentation of this file.

// Copyright (C) 2026 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 "qmediaengineplayer_p.h"
 
#include <common/mfmetadata_p.h>
#include <mfstream_p.h>
#include <player/qmediaenginenotify_p.h>
#include <player/qmediaenginetimedtextnotify_p.h>
#include <player/qmediaenginevideobuffer_p.h>
 
#include <QtMultimedia/qaudiooutput.h>
#include <QtMultimedia/qvideosink.h>
#include <QtMultimedia/private/qcomtaskresource_p.h>
#include <QtMultimedia/private/qplatformaudiooutput_p.h>
#include <QtMultimedia/private/qplatformvideosink_p.h>
#include <QtMultimedia/private/qvideoframe_p.h>
#include <QtMultimedia/private/qwindows_scopedpropvariant_p.h>
#include <QtMultimedia/private/qwindowsd3d11rhitextureimporter_p.h>
#include <QtMultimedia/private/qwmf_support_p.h>
#include <QtConcurrent/qtconcurrentrun.h>
#include <QtCore/qfile.h>
#include <QtCore/qlocale.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qscopeguard.h>
#include <QtCore/qtimer.h>
#include <QtCore/private/qbstr_p.h>
#include <QtCore/private/qsystemerror_p.h>
 
#include <dxgi.h>
#include <mfapi.h>
#include <mfidl.h>
 
Q_LOGGING_CATEGORY(lcMediaEngine, "qt.multimedia.mediaengine")
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace std::chrono_literals;
using QtMultimediaPrivate::ScopedPropVariant;
using reference_time = QWMF::reference_time;
 
namespace {
 
QVariant languageVariant(const QString &langStr)
{
    const QLocale::Language lang = QLocale::codeToLanguage(langStr, QLocale::AnyLanguageCode);
    return lang != QLocale::AnyLanguage ? QVariant::fromValue(lang) : QVariant(langStr);
}
 
QMediaPlayer::Error mapMediaEngineError(MF_MEDIA_ENGINE_ERR err)
{
    switch (err) {
    case MF_MEDIA_ENGINE_ERR_NOERROR:
        return QMediaPlayer::NoError;
    case MF_MEDIA_ENGINE_ERR_ABORTED:
        return QMediaPlayer::ResourceError;
    case MF_MEDIA_ENGINE_ERR_NETWORK:
        return QMediaPlayer::NetworkError;
    case MF_MEDIA_ENGINE_ERR_DECODE:
        return QMediaPlayer::FormatError;
    case MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED:
        return QMediaPlayer::ResourceError;
    case MF_MEDIA_ENGINE_ERR_ENCRYPTED:
        return QMediaPlayer::AccessDeniedError;
    default:
        return QMediaPlayer::ResourceError;
    }
}
 
std::chrono::microseconds videoFrameDurationUs(IMFMediaEngineEx *engine)
{
    if (!engine)
        return {};
 
    DWORD streamCount = 0;
    if (FAILED(engine->GetNumberOfStreams(&streamCount)))
        return {};
 
    for (DWORD i = 0; i < streamCount; ++i) {
        ScopedPropVariant majorType;
        if (FAILED(engine->GetStreamAttribute(i, MF_MT_MAJOR_TYPE, majorType.get()))
            || majorType->vt != VT_CLSID || *majorType->puuid != MFMediaType_Video) {
            continue;
        }
 
        ScopedPropVariant rate;
        if (FAILED(engine->GetStreamAttribute(i, MF_MT_FRAME_RATE, rate.get()))
            || rate->vt != VT_UI8) {
            return {};
        }
 
        UINT64 avgTimePerFrame = 0;
        if (SUCCEEDED(MFFrameRateToAverageTimePerFrame(
                    HI32(rate->uhVal.QuadPart), LO32(rate->uhVal.QuadPart), &avgTimePerFrame)))
            return std::chrono::round<std::chrono::microseconds>(reference_time(avgTimePerFrame));
 
        return {};
    }
    return {};
}
 
} // namespace
 
bool QMediaEnginePlayer::initD3D11()
{
    m_textureImporter = std::make_shared<QtMultimediaPrivate::QWindowsD3D11RhiTextureImporter>();
 
    const D3D_FEATURE_LEVEL featureLevels[] = {
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
    };
 
    UINT flags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT | D3D11_CREATE_DEVICE_BGRA_SUPPORT;
 
    HRESULT hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, featureLevels,
                                   ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &m_d3dDevice,
                                   nullptr, nullptr);
 
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "D3D11CreateDevice:" << QSystemError::windowsComString(hr);
        return false;
    }
 
    ComPtr<ID3D10Multithread> multithread;
    if (SUCCEEDED(m_d3dDevice.As(&multithread)))
        multithread->SetMultithreadProtected(TRUE);
 
    return true;
}
 
bool QMediaEnginePlayer::initMediaEngine()
{
    HRESULT hr = MFCreateDXGIDeviceManager(&m_resetToken, &m_dxgiManager);
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "MFCreateDXGIDeviceManager:"
                                 << QSystemError::windowsComString(hr);
        return false;
    }
 
    hr = m_dxgiManager->ResetDevice(m_d3dDevice.Get(), m_resetToken);
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "ResetDevice:" << QSystemError::windowsComString(hr);
        return false;
    }
 
    m_notify = makeComObject<QMediaEngineNotify>();
    // Queued: some MF events fire synchronously (e.g. PAUSE from Pause()),
    // must defer to avoid re-entering handleMediaEngineEvent mid-operation.
    QObject::connect(m_notify.Get(), &QMediaEngineNotify::eventNotified, context(),
                     [this](DWORD event, DWORD_PTR param1, DWORD param2) {
        handleMediaEngineEvent(event, param1, param2);
    }, Qt::QueuedConnection);
 
    ComPtr<IMFAttributes> attrs;
    hr = MFCreateAttributes(&attrs, 4);
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "MFCreateAttributes:" << QSystemError::windowsComString(hr);
        return false;
    }
 
    attrs->SetUnknown(MF_MEDIA_ENGINE_CALLBACK, m_notify.Get());
    attrs->SetUnknown(MF_MEDIA_ENGINE_DXGI_MANAGER, m_dxgiManager.Get());
    attrs->SetUINT32(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, DXGI_FORMAT_B8G8R8A8_UNORM);
 
    ComPtr<IMFMediaEngineClassFactory> factory;
    hr = CoCreateInstance(CLSID_MFMediaEngineClassFactory, nullptr, CLSCTX_INPROC_SERVER,
                          IID_PPV_ARGS(&factory));
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "CoCreateInstance(MFMediaEngineClassFactory):"
                                 << QSystemError::windowsComString(hr);
        return false;
    }
 
    hr = factory->CreateInstance(0, attrs.Get(), &m_mediaEngine);
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "IMFMediaEngine::CreateInstance:"
                                 << QSystemError::windowsComString(hr);
        return false;
    }
 
    hr = m_mediaEngine.As(&m_mediaEngineEx);
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "IMFMediaEngineEx:" << QSystemError::windowsComString(hr);
        return false;
    }
 
    // Enable inband timed text (embedded subtitles) discovery.
    // IMFTimedText is obtained via MFGetService with MF_MEDIA_ENGINE_TIMEDTEXT.
    ComPtr<IMFGetService> getService;
    if (SUCCEEDED(m_mediaEngine.As(&getService))) {
        getService->GetService(MF_MEDIA_ENGINE_TIMEDTEXT, IID_PPV_ARGS(&m_timedText));
    }
 
    if (m_timedText) {
        m_timedText->SetInBandEnabled(TRUE);
 
        m_timedTextNotify = makeComObject<QMediaEngineTimedTextNotify>();
 
        QObject::connect(m_timedTextNotify.Get(), &QMediaEngineTimedTextNotify::trackAdded,
                         context(), [this] {
            updateSubtitleTracks();
        });
 
        QObject::connect(m_timedTextNotify.Get(), &QMediaEngineTimedTextNotify::subtitleTextChanged,
                         context(), [this](const QString &text) {
            if (m_videoSink)
                m_videoSink->setSubtitleText(text);
        });
 
        m_timedText->RegisterNotifications(m_timedTextNotify.Get());
    }
 
    // Apply cached playback rate to the newly created engine.
    if (!qFuzzyCompare(m_playbackRate, 1.0)) {
        m_mediaEngine->SetDefaultPlaybackRate(m_playbackRate);
        m_mediaEngine->SetPlaybackRate(m_playbackRate);
    }
 
    return true;
}
 
void QMediaEnginePlayer::releaseMediaEngine()
{
    if (m_mediaEngine) {
        m_mediaEngine->Shutdown();
        m_mediaEngine.Reset();
    }
    m_mediaEngineEx.Reset();
    m_timedText.Reset();
    m_timedTextNotify.Reset();
    m_notify.Reset();
    m_dxgiManager.Reset();
    m_resetToken = 0;
}
 
void QMediaEnginePlayer::startPlaybackTimers()
{
    m_positionUpdateTimer.start();
    m_videoRenderTimer.start();
}
 
void QMediaEnginePlayer::stopPlaybackTimers()
{
    m_positionUpdateTimer.stop();
    m_videoRenderTimer.stop();
}
 
QMediaEnginePlayer::QMediaEnginePlayer(QMediaPlayer *player) : QPlatformMediaPlayer(player)
{
    if (!initD3D11())
        error(QMediaPlayer::ResourceError, u"Failed to initialize D3D11"_s);
 
    m_positionUpdateTimer.callOnTimeout(context(), [this] {
        if (m_mediaEngine && !m_seekTarget)
            positionChanged(currentPositionMs());
    });
 
    m_videoRenderTimer.callOnTimeout(context(), [this] {
        presentVideoFrame();
    });
 
    m_seekTimeoutTimer.setSingleShot(true);
    m_seekTimeoutTimer.callOnTimeout(context(), [this] {
        if (m_seekTarget) {
            qCWarning(lcMediaEngine) << "Seek timeout — SEEKED event not received, resetting";
            m_seekTarget.reset();
        }
    });
}
 
QMediaEnginePlayer::~QMediaEnginePlayer()
{
    stopPlaybackTimers();
    m_seekTimeoutTimer.stop();
 
    m_metadataFuture.cancel();
 
    releaseMediaEngine();
}
 
void QMediaEnginePlayer::handleMediaEngineEvent(DWORD event, DWORD_PTR param1, DWORD param2)
{
    Q_UNUSED(param2);
 
    if (!m_mediaEngine)
        return;
 
    switch (event) {
    case MF_MEDIA_ENGINE_EVENT_LOADEDMETADATA:
        qCDebug(lcMediaEngine) << "LOADEDMETADATA";
        updateMetaData();
        updateTracks();
        updateDuration();
        break;
 
    case MF_MEDIA_ENGINE_EVENT_LOADEDDATA: {
        qCDebug(lcMediaEngine) << "LOADEDDATA";
        audioAvailableChanged(m_mediaEngine->HasAudio());
        videoAvailableChanged(m_mediaEngine->HasVideo());
        updateVideoFrameFormat();
        updateNativeSize();
        seekableChanged(!m_stream || !m_stream->isSequential());
        mediaStatusChanged(QMediaPlayer::LoadedMedia);
 
        if (const float bp = bufferProgress(); bp > 0)
            bufferProgressChanged(bp);
 
        if (m_pendingPlay) {
            m_pendingPlay = false;
            play();
        }
        break;
    }
 
    case MF_MEDIA_ENGINE_EVENT_CANPLAY:
        qCDebug(lcMediaEngine) << "CANPLAY";
        if (state() == QMediaPlayer::PlayingState || mediaStatus() == QMediaPlayer::BufferingMedia
            || m_pendingPlay) {
            mediaStatusChanged(QMediaPlayer::BufferedMedia);
        }
        bufferProgressChanged(1.0f);
        break;
 
    case MF_MEDIA_ENGINE_EVENT_PLAYING:
        qCDebug(lcMediaEngine) << "PLAYING";
        if (state() != QMediaPlayer::PlayingState)
            stateChanged(QMediaPlayer::PlayingState);
        if (mediaStatus() == QMediaPlayer::BufferingMedia)
            mediaStatusChanged(QMediaPlayer::BufferedMedia);
        startPlaybackTimers();
        break;
 
    case MF_MEDIA_ENGINE_EVENT_PAUSE:
        qCDebug(lcMediaEngine) << "PAUSE";
        // Events are queued: ignore a stale PAUSE if playback was resumed meanwhile.
        if (!m_mediaEngine->IsPaused())
            break;
        if (state() != QMediaPlayer::StoppedState && state() != QMediaPlayer::PausedState) {
            stateChanged(QMediaPlayer::PausedState);
            stopPlaybackTimers();
        }
        break;
 
    case MF_MEDIA_ENGINE_EVENT_ENDED: {
        qCDebug(lcMediaEngine) << "ENDED";
        stopPlaybackTimers();
 
        if (mediaStatus() == QMediaPlayer::BufferingMedia)
            mediaStatusChanged(QMediaPlayer::BufferedMedia);
 
        if (doLoop()) {
            m_mediaEngine->SetCurrentTime(0);
            m_mediaEngine->Play();
        } else {
            if (m_videoSink)
                m_videoSink->setVideoFrame({});
            positionChanged(m_duration.count());
            stateChanged(QMediaPlayer::StoppedState);
            mediaStatusChanged(QMediaPlayer::EndOfMedia);
            bufferProgressChanged(0.f);
            resetCurrentLoop();
        }
        break;
    }
 
    case MF_MEDIA_ENGINE_EVENT_TIMEUPDATE:
        if (!m_seekTarget)
            positionChanged(currentPositionMs());
        break;
 
    case MF_MEDIA_ENGINE_EVENT_ERROR: {
        const auto mfErr = static_cast<MF_MEDIA_ENGINE_ERR>(param1);
 
        QString detail;
        switch (mfErr) {
        case MF_MEDIA_ENGINE_ERR_ABORTED:
            detail = u"Playback aborted"_s;
            break;
        case MF_MEDIA_ENGINE_ERR_NETWORK:
            detail = u"Network error"_s;
            break;
        case MF_MEDIA_ENGINE_ERR_DECODE:
            detail = u"Unsupported or corrupt media"_s;
            break;
        case MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED:
            detail = u"Source not supported"_s;
            break;
        case MF_MEDIA_ENGINE_ERR_ENCRYPTED:
            detail = u"Encrypted content"_s;
            break;
        default:
            detail = u"Unknown error %1"_s.arg(param1);
            break;
        }
 
        qCWarning(lcMediaEngine) << "Error:" << detail;
        error(mapMediaEngineError(mfErr), detail);
        mediaStatusChanged(QMediaPlayer::InvalidMedia);
        stopPlaybackTimers();
        break;
    }
 
    case MF_MEDIA_ENGINE_EVENT_BUFFERINGSTARTED:
        qCDebug(lcMediaEngine) << "BUFFERINGSTARTED";
        mediaStatusChanged(QMediaPlayer::BufferingMedia);
        bufferProgressChanged(bufferProgress());
        break;
 
    case MF_MEDIA_ENGINE_EVENT_BUFFERINGENDED:
        qCDebug(lcMediaEngine) << "BUFFERINGENDED";
        mediaStatusChanged(QMediaPlayer::BufferedMedia);
        bufferProgressChanged(bufferProgress());
        break;
 
    case MF_MEDIA_ENGINE_EVENT_DURATIONCHANGE:
        qCDebug(lcMediaEngine) << "DURATIONCHANGE";
        updateDuration();
        break;
 
    case MF_MEDIA_ENGINE_EVENT_FORMATCHANGE:
        qCDebug(lcMediaEngine) << "FORMATCHANGE";
        updateVideoFrameFormat();
        break;
 
    case MF_MEDIA_ENGINE_EVENT_FIRSTFRAMEREADY:
        qCDebug(lcMediaEngine) << "FIRSTFRAMEREADY";
        if (state() != QMediaPlayer::StoppedState)
            presentVideoFrame();
        break;
 
    case MF_MEDIA_ENGINE_EVENT_SEEKED:
        qCDebug(lcMediaEngine) << "SEEKED";
        m_seekTimeoutTimer.stop();
        m_seekTarget.reset();
        break;
 
    default:
        break;
    }
}
 
void QMediaEnginePlayer::setMedia(const QUrl &media, QIODevice *stream)
{
    qCDebug(lcMediaEngine) << "setMedia:" << media << "stream:" << stream;
 
    if (state() != QMediaPlayer::StoppedState)
        stop();
 
    m_url = media;
    m_stream = stream;
 
    m_duration = {};
    m_pendingPlay = false;
    m_seekTarget.reset();
    m_seekTimeoutTimer.stop();
    seekableChanged(false);
    m_videoSize = {};
    m_transferTexture.Reset();
    m_metaData = {};
    m_metadataFuture.cancel();
 
    if (m_videoSink)
        m_videoSink->setVideoFrame({});
 
    m_tracks = {};
 
    if (media.isEmpty() && !stream) {
        audioAvailableChanged(false);
        videoAvailableChanged(false);
        // IMFMediaEngine has no API to clear the current source without
        // shutting down. Release the engine now; it will be lazily
        // recreated on the next setMedia() call with a real source.
        releaseMediaEngine();
        metaDataChanged();
        mediaStatusChanged(QMediaPlayer::NoMedia);
        return;
    }
 
    // Lazy init: create the MediaEngine on first use,
    // or recreate it after a previous NoMedia release.
    if (!m_mediaEngine) {
        if (!initMediaEngine()) {
            error(QMediaPlayer::ResourceError, u"MediaEngine not initialized"_s);
            mediaStatusChanged(QMediaPlayer::InvalidMedia);
            return;
        }
    }
 
    HRESULT hr = E_FAIL;
 
    if (stream) {
        ComPtr<MFStream> mfStream = makeComObject<MFStream>(stream, false);
        QString urlStr = media.toString();
        // SetSourceFromByteStream requires a non-null URL.
        // Use the real file name when available so that Media Foundation
        // can infer the MIME type from the extension.
        if (urlStr.isEmpty()) {
            if (auto *file = qobject_cast<QFile *>(stream))
                urlStr = u"file:///"_s + file->fileName();
            else
                urlStr = u"stream:///media"_s;
        }
        const QBStr bstrUrl(urlStr);
        hr = m_mediaEngineEx->SetSourceFromByteStream(mfStream.Get(), bstrUrl.bstr());
    } else {
        const QBStr bstrUrl(media.toString());
        hr = m_mediaEngine->SetSource(bstrUrl.bstr());
    }
 
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "SetSource:" << QSystemError::windowsComString(hr);
        error(QMediaPlayer::ResourceError, u"Failed to set media source"_s);
        mediaStatusChanged(QMediaPlayer::InvalidMedia);
        return;
    }
 
    mediaStatusChanged(QMediaPlayer::LoadingMedia);
    applyAudioOutput();
}
 
void QMediaEnginePlayer::play()
{
    if (!m_mediaEngine)
        return;
 
    if (mediaStatus() == QMediaPlayer::NoMedia || mediaStatus() == QMediaPlayer::InvalidMedia) {
        return;
    }
 
    if (mediaStatus() == QMediaPlayer::LoadingMedia) {
        m_pendingPlay = true;
        return;
    }
 
    if (mediaStatus() == QMediaPlayer::EndOfMedia) {
        if (!m_seekTarget) {
            // Play() on an ended engine restarts from the beginning (HTML5 semantics).
            // Seeking explicitly before Play() makes the engine report ENDED again.
            if (!m_mediaEngine->IsEnded())
                m_mediaEngine->SetCurrentTime(0);
            positionChanged(0);
        }
        resetCurrentLoop();
        mediaStatusChanged(QMediaPlayer::BufferingMedia);
    } else if (mediaStatus() == QMediaPlayer::LoadedMedia
               || mediaStatus() == QMediaPlayer::BufferedMedia) {
        mediaStatusChanged(QMediaPlayer::BufferingMedia);
    }
 
    HRESULT hr = m_mediaEngine->Play();
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "Play:" << QSystemError::windowsComString(hr);
        return;
    }
 
    stateChanged(QMediaPlayer::PlayingState);
    startPlaybackTimers();
}
 
void QMediaEnginePlayer::pause()
{
    if (!m_mediaEngine)
        return;
 
    m_pendingPlay = false;
 
    // Like play(), pause() from EndOfMedia rewinds to the beginning.
    const bool fromEndOfMedia = mediaStatus() == QMediaPlayer::EndOfMedia;
    if (fromEndOfMedia) {
        if (!m_seekTarget)
            setPosition(0);
        resetCurrentLoop();
    }
 
    HRESULT hr = m_mediaEngine->Pause();
    if (FAILED(hr)) {
        qCWarning(lcMediaEngine) << "Pause:" << QSystemError::windowsComString(hr);
        return;
    }
 
    if (fromEndOfMedia)
        mediaStatusChanged(QMediaPlayer::BufferedMedia);
 
    if (mediaStatus() != QMediaPlayer::NoMedia && mediaStatus() != QMediaPlayer::InvalidMedia) {
        stateChanged(QMediaPlayer::PausedState);
        m_positionUpdateTimer.stop();
    }
 
    // Briefly start the render timer to deliver the current frame.
    if (isVideoAvailable() && !m_videoRenderTimer.isActive())
        m_videoRenderTimer.start();
}
 
void QMediaEnginePlayer::stop()
{
    if (!m_mediaEngine)
        return;
 
    m_pendingPlay = false;
    m_seekTarget.reset();
    m_seekTimeoutTimer.stop();
    stopPlaybackTimers();
 
    // Don't call Pause() if already at EndOfMedia — the engine is already
    // stopped internally, and Pause() in this state can prevent subsequent
    // Play() from working.
    if (mediaStatus() != QMediaPlayer::EndOfMedia) {
        HRESULT hr = m_mediaEngine->Pause();
        if (FAILED(hr))
            qCWarning(lcMediaEngine) << "Pause (in stop):" << QSystemError::windowsComString(hr);
    }
 
    // Flush the current position before SetCurrentTime(0) so that
    // QPlatformMediaPlayer's duplicate filter doesn't suppress positionChanged(0).
    positionChanged(currentPositionMs());
 
    m_mediaEngine->SetCurrentTime(0);
 
    if (m_videoSink)
        m_videoSink->setVideoFrame({});
 
    stateChanged(QMediaPlayer::StoppedState);
 
    positionChanged(0);
 
    if (mediaStatus() == QMediaPlayer::BufferedMedia
        || mediaStatus() == QMediaPlayer::BufferingMedia
        || mediaStatus() == QMediaPlayer::EndOfMedia) {
        mediaStatusChanged(QMediaPlayer::LoadedMedia);
        bufferProgressChanged(0);
    }
 
    resetCurrentLoop();
}
 
qint64 QMediaEnginePlayer::position() const
{
    if (!m_mediaEngine)
        return 0;
 
    if (m_seekTarget.has_value())
        return m_seekTarget->count();
 
    return currentPositionMs();
}
 
qint64 QMediaEnginePlayer::currentPositionMs() const
{
    if (!m_mediaEngine)
        return 0;
    const qint64 pos = qRound64(m_mediaEngine->GetCurrentTime() * 1000.0);
    // GetCurrentTime() can overshoot the reported duration slightly.
    return m_duration.count() > 0 ? qMin(pos, m_duration.count()) : pos;
}
 
QSize QMediaEnginePlayer::nativeVideoSize() const
{
    if (!m_mediaEngine)
        return {};
    DWORD w = 0, h = 0;
    m_mediaEngine->GetNativeVideoSize(&w, &h);
    return { static_cast<int>(w), static_cast<int>(h) };
}
 
void QMediaEnginePlayer::setPosition(qint64 position)
{
    if (!m_mediaEngine)
        return;
 
    position = qMax(qint64(0), position);
    if (const qint64 dur = duration(); dur > 0)
        position = qMin(position, dur);
 
    // IMFMediaEngine auto-resumes after a seek from the ended state
    // (per HTML5 spec). Remember the ended state before SetCurrentTime
    // resets it, so we can pause immediately after to prevent silent
    // playback when our state is Stopped or Paused.
    const bool wasEnded = m_mediaEngine->IsEnded();
 
    m_seekTarget = std::chrono::milliseconds(position);
    m_mediaEngine->SetCurrentTime(position / 1000.0);
 
    if (wasEnded && state() != QMediaPlayer::PlayingState)
        m_mediaEngine->Pause();
 
    // SEEKED may not arrive after device lost or rapid seeks.
    // Reset m_seekTarget on timeout to unblock position/frame updates.
    m_seekTimeoutTimer.start();
 
    if (mediaStatus() == QMediaPlayer::EndOfMedia)
        mediaStatusChanged(QMediaPlayer::LoadedMedia);
 
    positionChanged(position);
 
    if (isVideoAvailable() && state() == QMediaPlayer::PausedState)
        m_videoRenderTimer.start();
}
 
qreal QMediaEnginePlayer::playbackRate() const
{
    return m_playbackRate;
}
 
void QMediaEnginePlayer::setPlaybackRate(qreal rate)
{
    if (qFuzzyCompare(rate, m_playbackRate))
        return;
 
    m_playbackRate = rate;
 
    if (m_mediaEngine) {
        m_mediaEngine->SetDefaultPlaybackRate(rate);
        m_mediaEngine->SetPlaybackRate(rate);
    }
 
    playbackRateChanged(rate);
}
 
float QMediaEnginePlayer::bufferProgress() const
{
    if (!m_mediaEngine)
        return 0;
 
    ComPtr<IMFMediaTimeRange> buffered;
    if (FAILED(m_mediaEngine->GetBuffered(&buffered)) || !buffered)
        return 0;
 
    const DWORD count = buffered->GetLength();
    if (count == 0)
        return 0;
 
    const double dur = m_mediaEngine->GetDuration();
    if (!std::isfinite(dur) || dur <= 0)
        return 0;
 
    double end = 0;
    buffered->GetEnd(count - 1, &end);
    return static_cast<float>(qBound(0.0, end / dur, 1.0));
}
 
QMediaTimeRange QMediaEnginePlayer::availablePlaybackRanges() const
{
    QMediaTimeRange ranges;
    if (!m_mediaEngine)
        return ranges;
 
    ComPtr<IMFMediaTimeRange> buffered;
    if (FAILED(m_mediaEngine->GetBuffered(&buffered)) || !buffered)
        return ranges;
 
    const DWORD count = buffered->GetLength();
 
    for (DWORD i = 0; i < count; ++i) {
        double start = 0, end = 0;
        buffered->GetStart(i, &start);
        buffered->GetEnd(i, &end);
        ranges.addInterval(qRound64(start * 1000), qRound64(end * 1000));
    }
 
    return ranges;
}
 
qint64 QMediaEnginePlayer::duration() const
{
    return m_duration.count();
}
 
QUrl QMediaEnginePlayer::media() const
{
    return m_url;
}
 
const QIODevice *QMediaEnginePlayer::mediaStream() const
{
    return m_stream;
}
 
QMediaEnginePlayer::PitchCompensationAvailability
QMediaEnginePlayer::pitchCompensationAvailability() const
{
    return PitchCompensationAvailability::AlwaysOn;
}
 
QMediaMetaData QMediaEnginePlayer::metaData() const
{
    return m_metaData;
}
 
void QMediaEnginePlayer::presentVideoFrame()
{
    if (!m_mediaEngine || !isVideoAvailable())
        return;
 
    // Auto-stop the render timer when not in playing state, regardless of
    // which code path we take (including early returns). Keep it running
    // while a seek is pending so we can deliver the post-seek frame.
    const bool isPlaying = (state() == QMediaPlayer::PlayingState);
    auto stopGuard = qScopeGuard([&] {
        if (!isPlaying && !m_seekTarget)
            m_videoRenderTimer.stop();
    });
 
    LONGLONG pts = 0;
    if (m_mediaEngine->OnVideoStreamTick(&pts) != S_OK)
        return;
 
    // While a seek is pending, skip frame delivery — the engine may
    // still return a frame from the pre-seek position.
    if (m_seekTarget)
        return;
 
    if (!m_videoSink)
        return;
 
    const QSize videoSize = nativeVideoSize();
    if (videoSize.isEmpty())
        return;
 
    if (videoSize != m_videoSize) {
        m_videoSize = videoSize;
        m_transferTexture.Reset();
    }
 
    if (!m_transferTexture) {
        D3D11_TEXTURE2D_DESC desc = {};
        desc.Width = videoSize.width();
        desc.Height = videoSize.height();
        desc.MipLevels = 1;
        desc.ArraySize = 1;
        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
        desc.SampleDesc.Count = 1;
        desc.Usage = D3D11_USAGE_DEFAULT;
        desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
        desc.MiscFlags = 0;
 
        HRESULT hr = m_d3dDevice->CreateTexture2D(&desc, nullptr, &m_transferTexture);
        if (FAILED(hr)) {
            qCWarning(lcMediaEngine) << "CreateTexture2D:" << QSystemError::windowsComString(hr);
            return;
        }
 
        updateVideoFrameFormat();
    }
 
    MFVideoNormalizedRect srcRect = { 0.0f, 0.0f, 1.0f, 1.0f };
    RECT destRect = { 0, 0, videoSize.width(), videoSize.height() };
 
    HRESULT hr = m_mediaEngine->TransferVideoFrame(m_transferTexture.Get(), &srcRect, &destRect,
                                                   nullptr);
 
    if (FAILED(hr)) {
        if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET) {
 
            if (m_deviceLostRetries >= kMaxDeviceLostRetries) {
                qCWarning(lcMediaEngine) << "Device lost recovery failed after"
                                         << m_deviceLostRetries << "attempts, giving up";
                error(QMediaPlayer::ResourceError, u"D3D11 device lost recovery failed"_s);
                return;
            }
            ++m_deviceLostRetries;
 
            qCWarning(lcMediaEngine) << "Device lost during TransferVideoFrame, recovering"
                                     << "(attempt" << m_deviceLostRetries << ")...";
 
            const qint64 savedPosition = currentPositionMs();
            const auto savedState = state();
            stopPlaybackTimers();
 
            // Release dead resources immediately — the device is already lost.
            releaseMediaEngine();
            m_transferTexture.Reset();
            m_d3dDevice.Reset();
 
            // Defer re-creation to avoid re-entering presentVideoFrame().
            QTimer::singleShot(0, context(), [this, savedPosition, savedState] {
                if (!initD3D11()) {
                    error(QMediaPlayer::ResourceError, u"D3D11 device recreation failed"_s);
                    return;
                }
 
                if (!m_url.isEmpty() || m_stream) {
                    setMedia(m_url, m_stream);
 
                    if (savedPosition > 0)
                        setPosition(savedPosition);
                    if (savedState == QMediaPlayer::PlayingState)
                        play();
                }
            });
            return;
        }
        qCWarning(lcMediaEngine) << "TransferVideoFrame:" << QSystemError::windowsComString(hr);
        return;
    }
 
    // Successful frame transfer — reset device lost counter.
    m_deviceLostRetries = 0;
 
    auto buffer = std::make_unique<QMediaEngineVideoBuffer>(m_transferTexture, m_d3dDevice,
                                                            videoSize, m_textureImporter);
 
    QVideoFrame frame = QVideoFramePrivate::createFrame(std::move(buffer), m_videoFormat);
 
    auto startTime = std::chrono::round<std::chrono::microseconds>(reference_time(pts));
 
    frame.setStartTime(startTime.count());
    if (m_frameDuration > 0us)
        frame.setEndTime((startTime + m_frameDuration).count());
 
    m_videoSink->setVideoFrame(frame);
    m_videoSink->setNativeSize(videoSize);
}
 
// IMFMediaEngine already applies rotation to the decoded pixels, so
// the video format does not include rotation — VideoOutput would apply
// it a second time.
void QMediaEnginePlayer::updateVideoFrameFormat()
{
    const QSize size = nativeVideoSize();
    if (size.isEmpty())
        return;
 
    m_videoFormat = QVideoFrameFormat(size, QVideoFrameFormat::Format_BGRA8888);
    m_frameDuration = videoFrameDurationUs(m_mediaEngineEx.Get());
}
 
void QMediaEnginePlayer::updateNativeSize()
{
    if (!m_videoSink)
        return;
 
    const QSize size = nativeVideoSize();
    if (!size.isEmpty())
        m_videoSink->setNativeSize(size);
}
 
void QMediaEnginePlayer::setVideoSink(QVideoSink *sink)
{
    auto *newSink = sink ? sink->platformVideoSink() : nullptr;
    auto *oldSink = m_videoSink;
    m_videoSink = newSink;
    updateNativeSize();
 
    // Transfer the current frame to the new sink (e.g. when switching
    // sinks while paused — OnVideoStreamTick won't return the same frame).
    if (newSink && oldSink)
        newSink->setVideoFrame(oldSink->currentVideoFrame());
}
 
void QMediaEnginePlayer::setAudioOutput(QPlatformAudioOutput *output)
{
    if (m_audioOutput == output)
        return;
 
    if (m_audioOutput && m_audioOutput->q)
        m_audioOutput->q->disconnect(context());
 
    m_audioOutput = output;
 
    if (output && output->q) {
        QObject::connect(output->q, &QAudioOutput::volumeChanged, context(), [this] {
            applyVolume();
        });
        QObject::connect(output->q, &QAudioOutput::mutedChanged, context(), [this] {
            applyVolume();
        });
        QObject::connect(output->q, &QAudioOutput::deviceChanged, context(), [this] {
            applyAudioDevice();
        });
    }
 
    applyAudioOutput();
}
 
void QMediaEnginePlayer::applyAudioOutput()
{
    applyVolume();
    applyAudioDevice();
}
 
void QMediaEnginePlayer::applyVolume()
{
    if (!m_mediaEngine)
        return;
 
    if (!m_audioOutput) {
        m_mediaEngine->SetMuted(TRUE);
        return;
    }
 
    m_mediaEngine->SetVolume(static_cast<double>(m_audioOutput->volume));
    m_mediaEngine->SetMuted(m_audioOutput->muted ? TRUE : FALSE);
}
 
// SetAudioEndpointId() reconfigures the audio renderer even if the endpoint does not change, so
// it must only be called when the device or the engine changes, not e.g. on volume changes.
void QMediaEnginePlayer::applyAudioDevice()
{
    if (!m_mediaEngine || !m_audioOutput)
        return;
 
    const QByteArray id = m_audioOutput->device.id();
    if (id.isEmpty())
        return;
 
    ComPtr<IMFMediaEngineAudioEndpointId> endpointId;
    if (FAILED(m_mediaEngine.As(&endpointId)))
        return;
 
    const QString deviceId = QString::fromUtf8(id);
    const HRESULT hr = endpointId->SetAudioEndpointId(reinterpret_cast<LPCWSTR>(deviceId.utf16()));
    if (FAILED(hr))
        qCWarning(lcMediaEngine) << "SetAudioEndpointId:" << QSystemError::windowsComString(hr);
}
 
void QMediaEnginePlayer::updateMetaData()
{
    if (!m_mediaEngineEx)
        return;
 
    m_metaData = {};
 
    const QSize size = nativeVideoSize();
    if (!size.isEmpty())
        m_metaData.insert(QMediaMetaData::Resolution, size);
 
    if (m_duration > 0ms)
        m_metaData.insert(QMediaMetaData::Duration, m_duration.count());
 
    m_metadataFuture.cancel();
 
    const QUrl url = m_url;
 
    // IMFSourceResolver needs a URL; skip for pure QIODevice streams.
    if (url.isEmpty()) {
        metaDataChanged();
        return;
    }
 
    m_metadataFuture = QtConcurrent::run([url]() -> QMediaMetaData {
        ComPtr<IMFSourceResolver> resolver;
        if (FAILED(MFCreateSourceResolver(&resolver)))
            return {};
 
        ComPtr<IUnknown> sourceUnk;
        MF_OBJECT_TYPE objectType = MF_OBJECT_INVALID;
        HRESULT hr = E_FAIL;
 
        if (url.scheme() == u"qrc"_s) {
            auto file = std::make_unique<QFile>(u':' + url.path());
            if (!file->open(QIODevice::ReadOnly))
                return {};
 
            // MFStream in synchronous mode: BeginRead performs the read
            // immediately and invokes the callback on the calling thread,
            // so no event loop is needed.  ownStream=true so MFStream
            // takes ownership of the QFile.
            ComPtr<MFStream> mfStream =
                    makeComObject<MFStream>(file.release(), true, true /*synchronous*/);
 
            const auto urlStr = url.toString();
            hr = resolver->CreateObjectFromByteStream(
                    mfStream.Get(), reinterpret_cast<LPCWSTR>(urlStr.utf16()),
                    MF_RESOLUTION_MEDIASOURCE
                            | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE,
                    nullptr, &objectType, &sourceUnk);
        } else {
            const auto urlStr = url.toString();
            hr = resolver->CreateObjectFromURL(
                    reinterpret_cast<LPCWSTR>(urlStr.utf16()),
                    MF_RESOLUTION_MEDIASOURCE
                            | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE,
                    nullptr, &objectType, &sourceUnk);
        }
 
        if (FAILED(hr) || !sourceUnk)
            return {};
 
        ComPtr<IMFMediaSource> mediaSource;
        if (FAILED(sourceUnk.As(&mediaSource)))
            return {};
 
        QMediaMetaData result = MFMetaData::fromNative(mediaSource.Get());
        mediaSource->Shutdown();
        return result;
    }).then(context(), [this](QMediaMetaData rich) {
        if (!rich.isEmpty()) {
            for (const auto &[key, value] : std::as_const(m_metaData).asKeyValueRange())
                rich.insert(key, value);
            m_metaData = rich;
        }
        metaDataChanged();
    });
}
 
void QMediaEnginePlayer::updateTracks()
{
    if (!m_mediaEngineEx)
        return;
 
    m_tracks = {};
 
    DWORD streamCount = 0;
    if (FAILED(m_mediaEngineEx->GetNumberOfStreams(&streamCount)))
        return;
 
    for (DWORD i = 0; i < streamCount; ++i) {
        std::optional<TrackType> trackType;
        {
            ScopedPropVariant var;
            if (FAILED(m_mediaEngineEx->GetStreamAttribute(i, MF_MT_MAJOR_TYPE, var.get())))
                continue;
 
            if (var->vt == VT_CLSID) {
                if (*var->puuid == MFMediaType_Audio)
                    trackType = TrackType::AudioStream;
                else if (*var->puuid == MFMediaType_Video)
                    trackType = TrackType::VideoStream;
            }
        }
 
        if (!trackType)
            continue;
 
        QMediaMetaData trackMeta;
        {
            ScopedPropVariant var;
            if (SUCCEEDED(m_mediaEngineEx->GetStreamAttribute(i, MF_SD_LANGUAGE, var.get()))) {
                if (var->vt == VT_LPWSTR && var->pwszVal)
                    trackMeta.insert(QMediaMetaData::Language,
                                     languageVariant(QString::fromWCharArray(var->pwszVal)));
            }
        }
 
        m_tracks[*trackType].entries.push_back({ trackMeta, i });
 
        BOOL selected = FALSE;
        if (SUCCEEDED(m_mediaEngineEx->GetStreamSelection(i, &selected)) && selected)
            m_tracks[*trackType].currentIndex =
                    static_cast<int>(m_tracks[*trackType].entries.size()) - 1;
    }
 
    updateSubtitleTracks();
 
    tracksChanged();
}
 
void QMediaEnginePlayer::updateSubtitleTracks()
{
    auto &subtitleInfo = m_tracks[TrackType::SubtitleStream];
    subtitleInfo = {};
 
    if (!m_timedText)
        return;
 
    ComPtr<IMFTimedTextTrackList> trackList;
    if (FAILED(m_timedText->GetTextTracks(&trackList)) || !trackList)
        return;
 
    const DWORD count = trackList->GetLength();
    for (DWORD i = 0; i < count; ++i) {
        ComPtr<IMFTimedTextTrack> track;
        if (FAILED(trackList->GetTrack(i, &track)) || !track)
            continue;
 
        QMediaMetaData trackMeta;
 
        QComTaskResource<WCHAR> label;
        if (SUCCEEDED(track->GetLabel(label.address())) && label)
            trackMeta.insert(QMediaMetaData::Title, QString::fromWCharArray(label.get()));
 
        QComTaskResource<WCHAR> lang;
        if (SUCCEEDED(track->GetLanguage(lang.address())) && lang)
            trackMeta.insert(QMediaMetaData::Language,
                             languageVariant(QString::fromWCharArray(lang.get())));
 
        // Store the timed-text track ID as the streamIndex for SelectTrack.
        const DWORD trackId = track->GetId();
 
        subtitleInfo.entries.push_back({ trackMeta, trackId });
 
        if (track->IsActive()) {
            subtitleInfo.currentIndex = static_cast<int>(subtitleInfo.entries.size()) - 1;
        }
    }
}
 
void QMediaEnginePlayer::updateDuration()
{
    if (!m_mediaEngine)
        return;
 
    const double dur = m_mediaEngine->GetDuration();
    const auto newDuration = std::chrono::milliseconds(
            (std::isfinite(dur) && dur >= 0) ? qRound64(dur * 1000.0) : 0);
    if (newDuration != m_duration) {
        m_duration = newDuration;
        durationChanged(m_duration.count());
    }
}
 
int QMediaEnginePlayer::trackCount(TrackType type)
{
    return static_cast<int>(m_tracks[type].entries.size());
}
 
QMediaMetaData QMediaEnginePlayer::trackMetaData(TrackType type, int trackNumber)
{
    if (trackNumber < 0 || trackNumber >= static_cast<int>(m_tracks[type].entries.size()))
        return {};
    return m_tracks[type].entries.at(trackNumber).metaData;
}
 
int QMediaEnginePlayer::activeTrack(TrackType type)
{
    return m_tracks[type].currentIndex;
}
 
void QMediaEnginePlayer::setActiveTrack(TrackType type, int index)
{
    if (index < -1 || index >= static_cast<int>(m_tracks[type].entries.size()))
        return;
 
    if (type == TrackType::SubtitleStream) {
        // Subtitle tracks are managed via IMFTimedText, not stream selection.
        if (!m_timedText)
            return;
 
        const int currentIdx = m_tracks[type].currentIndex;
        if (currentIdx >= 0 && currentIdx < static_cast<int>(m_tracks[type].entries.size())) {
            DWORD trackId = m_tracks[type].entries.at(currentIdx).streamIndex;
            m_timedText->SelectTrack(trackId, FALSE);
        }
 
        if (index >= 0) {
            DWORD trackId = m_tracks[type].entries.at(index).streamIndex;
            m_timedText->SelectTrack(trackId, TRUE);
        }
 
        if (m_videoSink)
            m_videoSink->setSubtitleText({});
 
        m_tracks[type].currentIndex = index;
        activeTracksChanged();
        return;
    }
 
    if (!m_mediaEngineEx)
        return;
 
    const int currentIdx = m_tracks[type].currentIndex;
    if (currentIdx >= 0 && currentIdx < static_cast<int>(m_tracks[type].entries.size())) {
        DWORD streamIdx = m_tracks[type].entries.at(currentIdx).streamIndex;
        m_mediaEngineEx->SetStreamSelection(streamIdx, FALSE);
    }
 
    if (index >= 0) {
        DWORD streamIdx = m_tracks[type].entries.at(index).streamIndex;
        m_mediaEngineEx->SetStreamSelection(streamIdx, TRUE);
    }
 
    m_tracks[type].currentIndex = index;
    activeTracksChanged();
}
 
QT_END_NAMESPACE