Revision control
Copy as Markdown
// 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))
else
}
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] {
applyAudioOutput();
});
QObject::connect(output->q, &QAudioOutput::mutedChanged, context(), [this] {
applyAudioOutput();
});
QObject::connect(output->q, &QAudioOutput::deviceChanged, context(), [this] {
applyAudioOutput();
});
}
applyAudioOutput();
}
void QMediaEnginePlayer::applyAudioOutput()
{
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);
const QByteArray id = m_audioOutput->device.id();
if (!id.isEmpty()) {
ComPtr<IMFMediaEngineAudioEndpointId> endpointId;
if (SUCCEEDED(m_mediaEngine.As(&endpointId))) {
const QString deviceId = QString::fromUtf8(id);
endpointId->SetAudioEndpointId(reinterpret_cast<LPCWSTR>(deviceId.utf16()));
}
}
}
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