Replace QComPtr with Microsoft's WRL::ComPtr in QtMultimedia

This way we can rely on a 'standard' implementation that behaves the
same way as other COM smart pointers, and we don't have to maintain our
own implementation any longer.

This also fixes a latent bug that could cause double release when facing
circular dependencies between COM objects.

Change-Id: I339faac2f5045c0379b61ad72be033510eca4958
Reviewed-by: Lars Knoll <lars@knoll.priv.no>
Reviewed-by: Pavel Dubsky <pavel.dubsky@qt.io>
(cherry picked from commit a93ee88315035c366d87e1bc2e07ddd24e67ffb9)

26 files changed, 278 insertions, 335 deletions

diff --git a/src/multimedia/windows/qcomptr_p.h b/src/multimedia/windows/qcomptr_p.h
index a6d98fa59..3a29d8fd4 100644
--- a/src/multimedia/windows/qcomptr_p.h
+++ b/src/multimedia/windows/qcomptr_p.h
@@ -16,72 +16,15 @@
 //
 
 #include <qt_windows.h>
+#include <wrl/client.h>
 
-template <class T>
-class QComPtr
-{
-public:
-    // Calls AddRef on ptr if it is not a nullptr
-    explicit QComPtr(T *ptr) : m_ptr(ptr)
-    {
-        if (m_ptr)
-            m_ptr->AddRef();
-    }
-    QComPtr() : m_ptr(nullptr) {}
-    QComPtr(const QComPtr<T> &uiPtr) : m_ptr(uiPtr.m_ptr) { if (m_ptr) m_ptr->AddRef(); }
-    QComPtr(QComPtr<T> &&uiPtr) : m_ptr(uiPtr.m_ptr) { uiPtr.m_ptr = nullptr; }
-    ~QComPtr() { if (m_ptr) m_ptr->Release(); }
-
-    QComPtr& operator=(const QComPtr<T> &rhs) {
-        if (this != &rhs) {
-            if (m_ptr)
-                m_ptr->Release();
-            m_ptr = rhs.m_ptr;
-            m_ptr->AddRef();
-        }
-        return *this;
-    }
-
-    QComPtr& operator=(QComPtr<T> &&rhs) noexcept {
-        if (m_ptr)
-            m_ptr->Release();
-        m_ptr = rhs.m_ptr;
-        rhs.m_ptr = nullptr;
-        return *this;
-    }
-
-    explicit operator bool() const { return m_ptr != nullptr; }
-    T *operator->() const { return m_ptr; }
-
-    T **address() { Q_ASSERT(m_ptr == nullptr); return &m_ptr; }
-
-    void reset()
-    {
-        if (m_ptr)
-            m_ptr->Release();
-        m_ptr = nullptr;
-    }
-
-    // Takes ownership of interface without calling AddRef
-    void attach(T *ptr)
-    {
-        if (m_ptr)
-            m_ptr->Release();
-        m_ptr = ptr;
-    }
-
-    T *release() { T *ptr = m_ptr; m_ptr = nullptr; return ptr; }
-    T *get() const { return m_ptr; }
-
-private:
-    T *m_ptr;
-};
+using Microsoft::WRL::ComPtr;
 
 template<typename T, typename... Args>
-QComPtr<T> makeComObject(Args &&...args)
+ComPtr<T> makeComObject(Args &&...args)
 {
-    QComPtr<T> p;
-    p.attach(new T(std::forward<Args>(args)...));
+    ComPtr<T> p;
+    p.Attach(new T(std::forward<Args>(args)...));
     return p;
 }
 
diff --git a/src/multimedia/windows/qwindowsaudiodevice.cpp b/src/multimedia/windows/qwindowsaudiodevice.cpp
index fbc1cfa02..f22567cbf 100644
--- a/src/multimedia/windows/qwindowsaudiodevice.cpp
+++ b/src/multimedia/windows/qwindowsaudiodevice.cpp
@@ -29,7 +29,7 @@
 
 QT_BEGIN_NAMESPACE
 
-QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<IMMDevice> immDev, int waveID, const QString &description, QAudioDevice::Mode mode)
+QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, ComPtr<IMMDevice> immDev, int waveID, const QString &description, QAudioDevice::Mode mode)
     : QAudioDevicePrivate(dev, mode),
       m_devId(waveID),
       m_immDev(std::move(immDev))
@@ -38,9 +38,9 @@ QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<IMMDevi
 
     this->description = description;
 
-    QComPtr<IAudioClient> audioClient;
+    ComPtr<IAudioClient> audioClient;
     HRESULT hr = m_immDev->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, nullptr,
-                                    (void **)audioClient.address());
+                                    (void **)audioClient.GetAddressOf());
     if (SUCCEEDED(hr)) {
         WAVEFORMATEX *pwfx = nullptr;
         hr = audioClient->GetMixFormat(&pwfx);
@@ -194,8 +194,8 @@ QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<IMMDevi
 
     channelConfiguration = QAudioFormat::defaultChannelConfigForChannelCount(maximumChannelCount);
 
-    QComPtr<IPropertyStore> props;
-    hr = m_immDev->OpenPropertyStore(STGM_READ, props.address());
+    ComPtr<IPropertyStore> props;
+    hr = m_immDev->OpenPropertyStore(STGM_READ, props.GetAddressOf());
     if (SUCCEEDED(hr)) {
         PROPVARIANT var;
         PropVariantInit(&var);
diff --git a/src/multimedia/windows/qwindowsaudiodevice_p.h b/src/multimedia/windows/qwindowsaudiodevice_p.h
index 12ee0e58e..b2af4bfe0 100644
--- a/src/multimedia/windows/qwindowsaudiodevice_p.h
+++ b/src/multimedia/windows/qwindowsaudiodevice_p.h
@@ -36,7 +36,7 @@ const unsigned int SAMPLE_RATES[] = { 8000, 11025, 22050, 44100, 48000 };
 class QWindowsAudioDeviceInfo : public QAudioDevicePrivate
 {
 public:
-    QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<IMMDevice> immdev, int waveID, const QString &description, QAudioDevice::Mode mode);
+    QWindowsAudioDeviceInfo(QByteArray dev, ComPtr<IMMDevice> immdev, int waveID, const QString &description, QAudioDevice::Mode mode);
     ~QWindowsAudioDeviceInfo();
 
     bool open();
@@ -45,11 +45,11 @@ public:
     bool testSettings(const QAudioFormat& format) const;
 
     int waveId() const { return m_devId; }
-    QComPtr<IMMDevice> immDev() const { return m_immDev; }
+    ComPtr<IMMDevice> immDev() const { return m_immDev; }
 
 private:
     quint32 m_devId;
-    QComPtr<IMMDevice> m_immDev;
+    ComPtr<IMMDevice> m_immDev;
 };
 
 
diff --git a/src/multimedia/windows/qwindowsaudiosink.cpp b/src/multimedia/windows/qwindowsaudiosink.cpp
index f585b83e2..137b4216a 100644
--- a/src/multimedia/windows/qwindowsaudiosink.cpp
+++ b/src/multimedia/windows/qwindowsaudiosink.cpp
@@ -56,7 +56,7 @@ std::optional<quint32> audioClientFramesAvailable(IAudioClient *client)
     return {};
 }
 
-QWindowsAudioSink::QWindowsAudioSink(QComPtr<IMMDevice> device, QObject *parent) :
+QWindowsAudioSink::QWindowsAudioSink(ComPtr<IMMDevice> device, QObject *parent) :
     QPlatformAudioSink(parent),
     m_timer(new QTimer(this)),
     m_pushSource(new OutputPrivate(*this)),
@@ -74,7 +74,7 @@ QWindowsAudioSink::~QWindowsAudioSink()
 
 qint64 QWindowsAudioSink::remainingPlayTimeUs()
 {
-    auto framesInUse = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.get());
+    auto framesInUse = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.Get());
     return m_resampler.outputFormat().durationForFrames(framesInUse ? *framesInUse : 0);
 }
 
@@ -207,13 +207,13 @@ bool QWindowsAudioSink::open()
         return true;
 
     HRESULT hr = m_device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER,
-                            nullptr, (void**)m_audioClient.address());
+                            nullptr, (void**)m_audioClient.GetAddressOf());
     if (FAILED(hr)) {
         qCWarning(qLcAudioOutput) << "Failed to activate audio device" << errorString(hr);
         return false;
     }
 
-    auto resetClient = qScopeGuard([this](){ m_audioClient.reset(); });
+    auto resetClient = qScopeGuard([this](){ m_audioClient.Reset(); });
 
     WAVEFORMATEX *pwfx = nullptr;
     hr = m_audioClient->GetMixFormat(&pwfx);
@@ -248,7 +248,7 @@ bool QWindowsAudioSink::open()
         return false;
     }
 
-    auto framesAllocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.get());
+    auto framesAllocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.Get());
     if (!framesAllocated) {
         qCWarning(qLcAudioOutput) << "Failed to get audio client buffer size";
         return false;
@@ -257,7 +257,7 @@ bool QWindowsAudioSink::open()
     m_bufferSize = m_format.bytesForDuration(
             m_resampler.outputFormat().durationForFrames(*framesAllocated));
 
-    hr = m_audioClient->GetService(__uuidof(IAudioRenderClient), (void**)m_renderClient.address());
+    hr = m_audioClient->GetService(__uuidof(IAudioRenderClient), (void**)m_renderClient.GetAddressOf());
     if (FAILED(hr)) {
         qCWarning(qLcAudioOutput) << "Failed to obtain audio client rendering service"
                                   << errorString(hr);
@@ -279,8 +279,8 @@ void QWindowsAudioSink::close()
 
     if (m_pullSource)
         disconnect(m_pullSource, &QIODevice::readyRead, this, &QWindowsAudioSink::pullSource);
-    m_audioClient.reset();
-    m_renderClient.reset();
+    m_audioClient.Reset();
+    m_renderClient.Reset();
     m_pullSource = nullptr;
 }
 
@@ -289,7 +289,7 @@ qsizetype QWindowsAudioSink::bytesFree() const
     if (!m_audioClient)
         return 0;
 
-    auto framesAvailable = audioClientFramesAvailable(m_audioClient.get());
+    auto framesAvailable = audioClientFramesAvailable(m_audioClient.Get());
     if (framesAvailable)
         return m_resampler.inputBufferSize(*framesAvailable * m_resampler.outputFormat().bytesPerFrame());
     return 0;
@@ -316,7 +316,7 @@ qint64 QWindowsAudioSink::write(const char *data, qint64 len)
 
     qCDebug(qLcAudioOutput) << "write()" << len;
 
-    auto framesAvailable = audioClientFramesAvailable(m_audioClient.get());
+    auto framesAvailable = audioClientFramesAvailable(m_audioClient.Get());
     if (!framesAvailable)
         return -1;
 
diff --git a/src/multimedia/windows/qwindowsaudiosink_p.h b/src/multimedia/windows/qwindowsaudiosink_p.h
index 1178d8ad0..1a98bc296 100644
--- a/src/multimedia/windows/qwindowsaudiosink_p.h
+++ b/src/multimedia/windows/qwindowsaudiosink_p.h
@@ -42,7 +42,7 @@ class QWindowsAudioSink : public QPlatformAudioSink
 {
     Q_OBJECT
 public:
-    QWindowsAudioSink(QComPtr<IMMDevice> device, QObject *parent);
+    QWindowsAudioSink(ComPtr<IMMDevice> device, QObject *parent);
     ~QWindowsAudioSink();
 
     void setFormat(const QAudioFormat& fmt) override;
@@ -85,9 +85,9 @@ private:
     QTimer *m_timer = nullptr;
     QScopedPointer<QIODevice> m_pushSource;
     QPointer<QIODevice> m_pullSource;
-    QComPtr<IMMDevice> m_device;
-    QComPtr<IAudioClient> m_audioClient;
-    QComPtr<IAudioRenderClient> m_renderClient;
+    ComPtr<IMMDevice> m_device;
+    ComPtr<IAudioClient> m_audioClient;
+    ComPtr<IAudioRenderClient> m_renderClient;
     QWindowsResampler m_resampler;
 };
 
diff --git a/src/multimedia/windows/qwindowsaudiosource.cpp b/src/multimedia/windows/qwindowsaudiosource.cpp
index f17434dd7..0082f526b 100644
--- a/src/multimedia/windows/qwindowsaudiosource.cpp
+++ b/src/multimedia/windows/qwindowsaudiosource.cpp
@@ -45,7 +45,7 @@ private:
     QWindowsAudioSource &m_audioSource;
 };
 
-QWindowsAudioSource::QWindowsAudioSource(QComPtr<IMMDevice> device, QObject *parent)
+QWindowsAudioSource::QWindowsAudioSource(ComPtr<IMMDevice> device, QObject *parent)
     : QPlatformAudioSource(parent),
       m_timer(new QTimer(this)),
       m_device(std::move(device)),
@@ -163,8 +163,8 @@ QByteArray QWindowsAudioSource::readCaptureClientBuffer()
 
 void QWindowsAudioSource::schedulePull()
 {
-    auto allocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.get());
-    auto inUse = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.get());
+    auto allocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.Get());
+    auto inUse = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.Get());
 
     if (!allocated || !inUse) {
         deviceStateChange(QAudio::IdleState, QAudio::IOError);
@@ -250,7 +250,7 @@ void QWindowsAudioSource::stop()
 bool QWindowsAudioSource::open()
 {
     HRESULT hr = m_device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER,
-                                    nullptr, (void**)m_audioClient.address());
+                                    nullptr, (void**)m_audioClient.GetAddressOf());
     if (FAILED(hr)) {
         qCWarning(qLcAudioSource) << "Failed to activate audio device" << errorString(hr);
         return false;
@@ -283,7 +283,7 @@ bool QWindowsAudioSource::open()
         return false;
     }
 
-    auto framesAllocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.get());
+    auto framesAllocated = QWindowsAudioUtils::audioClientFramesAllocated(m_audioClient.Get());
     if (!framesAllocated) {
         qCWarning(qLcAudioSource) << "Failed to get audio client buffer size";
         return false;
@@ -292,7 +292,7 @@ bool QWindowsAudioSource::open()
     m_bufferSize = m_format.bytesForDuration(
             m_resampler.inputFormat().durationForFrames(*framesAllocated));
 
-    hr = m_audioClient->GetService(__uuidof(IAudioCaptureClient), (void**)m_captureClient.address());
+    hr = m_audioClient->GetService(__uuidof(IAudioCaptureClient), (void**)m_captureClient.GetAddressOf());
     if (FAILED(hr)) {
         qCWarning(qLcAudioSource) << "Failed to obtain audio client rendering service" << errorString(hr);
         return false;
@@ -310,8 +310,8 @@ void QWindowsAudioSource::close()
     deviceStateChange(QAudio::StoppedState, QAudio::NoError);
 
     m_clientBufferResidue.clear();
-    m_captureClient.reset();
-    m_audioClient.reset();
+    m_captureClient.Reset();
+    m_audioClient.Reset();
     m_clientSink = nullptr;
 }
 
@@ -320,7 +320,7 @@ qsizetype QWindowsAudioSource::bytesReady() const
     if (m_deviceState == QAudio::StoppedState || m_deviceState == QAudio::SuspendedState)
         return 0;
 
-    auto frames = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.get());
+    auto frames = QWindowsAudioUtils::audioClientFramesInUse(m_audioClient.Get());
     if (frames) {
         auto clientBufferSize = m_resampler.outputFormat().bytesForDuration(
                 m_resampler.inputFormat().durationForFrames(*frames));
diff --git a/src/multimedia/windows/qwindowsaudiosource_p.h b/src/multimedia/windows/qwindowsaudiosource_p.h
index 56355d525..68d57bbe1 100644
--- a/src/multimedia/windows/qwindowsaudiosource_p.h
+++ b/src/multimedia/windows/qwindowsaudiosource_p.h
@@ -43,7 +43,7 @@ class QWindowsAudioSource : public QPlatformAudioSource
 {
     Q_OBJECT
 public:
-    QWindowsAudioSource(QComPtr<IMMDevice> device, QObject *parent);
+    QWindowsAudioSource(ComPtr<IMMDevice> device, QObject *parent);
     ~QWindowsAudioSource();
 
     qint64 read(char* data, qint64 len);
@@ -72,9 +72,9 @@ private:
     QByteArray readCaptureClientBuffer();
 
     QTimer *m_timer = nullptr;
-    QComPtr<IMMDevice> m_device;
-    QComPtr<IAudioClient> m_audioClient;
-    QComPtr<IAudioCaptureClient> m_captureClient;
+    ComPtr<IMMDevice> m_device;
+    ComPtr<IAudioClient> m_audioClient;
+    ComPtr<IAudioCaptureClient> m_captureClient;
     QWindowsResampler m_resampler;
     int m_bufferSize = 0;
     qreal m_volume = 1.0;
diff --git a/src/multimedia/windows/qwindowsaudioutils.cpp b/src/multimedia/windows/qwindowsaudioutils.cpp
index fb9c8671e..dce4a2135 100644
--- a/src/multimedia/windows/qwindowsaudioutils.cpp
+++ b/src/multimedia/windows/qwindowsaudioutils.cpp
@@ -157,14 +157,14 @@ QAudioFormat QWindowsAudioUtils::mediaTypeToFormat(IMFMediaType *mediaType)
     return format;
 }
 
-QComPtr<IMFMediaType> QWindowsAudioUtils::formatToMediaType(QWindowsMediaFoundation &wmf, const QAudioFormat &format)
+ComPtr<IMFMediaType> QWindowsAudioUtils::formatToMediaType(QWindowsMediaFoundation &wmf, const QAudioFormat &format)
 {
-    QComPtr<IMFMediaType> mediaType;
+    ComPtr<IMFMediaType> mediaType;
 
     if (!format.isValid())
         return mediaType;
 
-    wmf.mfCreateMediaType(mediaType.address());
+    wmf.mfCreateMediaType(mediaType.GetAddressOf());
 
     mediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
     if (format.sampleFormat() == QAudioFormat::Float) {
diff --git a/src/multimedia/windows/qwindowsaudioutils_p.h b/src/multimedia/windows/qwindowsaudioutils_p.h
index 379a8b762..9382f372f 100644
--- a/src/multimedia/windows/qwindowsaudioutils_p.h
+++ b/src/multimedia/windows/qwindowsaudioutils_p.h
@@ -34,7 +34,7 @@ namespace QWindowsAudioUtils
     bool formatToWaveFormatExtensible(const QAudioFormat &format, WAVEFORMATEXTENSIBLE &wfx);
     QAudioFormat waveFormatExToFormat(const WAVEFORMATEX &in);
     Q_MULTIMEDIA_EXPORT QAudioFormat mediaTypeToFormat(IMFMediaType *mediaType);
-    QComPtr<IMFMediaType> formatToMediaType(QWindowsMediaFoundation &, const QAudioFormat &format);
+    ComPtr<IMFMediaType> formatToMediaType(QWindowsMediaFoundation &, const QAudioFormat &format);
     QAudioFormat::ChannelConfig maskToChannelConfig(UINT32 mask, int count);
     std::optional<quint32> audioClientFramesInUse(IAudioClient *client);
     std::optional<quint32> audioClientFramesAllocated(IAudioClient *client);
diff --git a/src/multimedia/windows/qwindowsmediadevices.cpp b/src/multimedia/windows/qwindowsmediadevices.cpp
index 1358c317b..dbf16346b 100644
--- a/src/multimedia/windows/qwindowsmediadevices.cpp
+++ b/src/multimedia/windows/qwindowsmediadevices.cpp
@@ -25,13 +25,13 @@ QT_BEGIN_NAMESPACE
 class CMMNotificationClient : public IMMNotificationClient
 {
     LONG m_cRef;
-    QComPtr<IMMDeviceEnumerator> m_enumerator;
+    ComPtr<IMMDeviceEnumerator> m_enumerator;
     QWindowsMediaDevices *m_windowsMediaDevices;
     QMap<QString, DWORD> m_deviceState;
 
 public:
     CMMNotificationClient(QWindowsMediaDevices *windowsMediaDevices,
-                          QComPtr<IMMDeviceEnumerator> enumerator,
+                          ComPtr<IMMDeviceEnumerator> enumerator,
                           QMap<QString, DWORD> &&deviceState) :
         m_cRef(1),
         m_enumerator(enumerator),
@@ -133,12 +133,12 @@ public:
 
     void emitAudioDevicesChanged(LPCWSTR deviceID)
     {
-        QComPtr<IMMDevice> device;
-        QComPtr<IMMEndpoint> endpoint;
+        ComPtr<IMMDevice> device;
+        ComPtr<IMMEndpoint> endpoint;
         EDataFlow flow;
 
-        if (SUCCEEDED(m_enumerator->GetDevice(deviceID, device.address()))
-            && SUCCEEDED(device->QueryInterface(__uuidof(IMMEndpoint), (void**)endpoint.address()))
+        if (SUCCEEDED(m_enumerator->GetDevice(deviceID, device.GetAddressOf()))
+            && SUCCEEDED(device->QueryInterface(__uuidof(IMMEndpoint), (void**)endpoint.GetAddressOf()))
             && SUCCEEDED(endpoint->GetDataFlow(&flow)))
         {
                     emitAudioDevicesChanged(flow);
@@ -157,18 +157,18 @@ QWindowsMediaDevices::QWindowsMediaDevices()
 
     if (SUCCEEDED(hr)) {
         QMap<QString, DWORD> devState;
-        QComPtr<IMMDeviceCollection> devColl;
+        ComPtr<IMMDeviceCollection> devColl;
         UINT count = 0;
 
-        if (SUCCEEDED(m_deviceEnumerator->EnumAudioEndpoints(EDataFlow::eAll, DEVICE_STATEMASK_ALL, devColl.address()))
+        if (SUCCEEDED(m_deviceEnumerator->EnumAudioEndpoints(EDataFlow::eAll, DEVICE_STATEMASK_ALL, devColl.GetAddressOf()))
             && SUCCEEDED(devColl->GetCount(&count)))
         {
             for (UINT i = 0; i < count; i++) {
-                QComPtr<IMMDevice> device;
+                ComPtr<IMMDevice> device;
                 DWORD state = 0;
                 LPWSTR id = nullptr;
 
-                if (SUCCEEDED(devColl->Item(i, device.address()))
+                if (SUCCEEDED(devColl->Item(i, device.GetAddressOf()))
                     && SUCCEEDED(device->GetState(&state))
                     && SUCCEEDED(device->GetId(&id)))
                 {
@@ -181,7 +181,7 @@ QWindowsMediaDevices::QWindowsMediaDevices()
 
         m_notificationClient =
                 makeComObject<CMMNotificationClient>(this, m_deviceEnumerator, std::move(devState));
-        m_deviceEnumerator->RegisterEndpointNotificationCallback(m_notificationClient.get());
+        m_deviceEnumerator->RegisterEndpointNotificationCallback(m_notificationClient.Get());
 
     } else {
         qWarning() << "Audio device change notification disabled";
@@ -191,7 +191,7 @@ QWindowsMediaDevices::QWindowsMediaDevices()
 QWindowsMediaDevices::~QWindowsMediaDevices()
 {
     if (m_deviceEnumerator) {
-        m_deviceEnumerator->UnregisterEndpointNotificationCallback(m_notificationClient.get());
+        m_deviceEnumerator->UnregisterEndpointNotificationCallback(m_notificationClient.Get());
     }
     if (m_warmUpAudioClient) {
         HRESULT hr = m_warmUpAudioClient->Stop();
@@ -200,9 +200,9 @@ QWindowsMediaDevices::~QWindowsMediaDevices()
         }
     }
 
-    m_deviceEnumerator.reset();
-    m_notificationClient.reset();
-    m_warmUpAudioClient.reset();
+    m_deviceEnumerator.Reset();
+    m_notificationClient.Reset();
+    m_warmUpAudioClient.Reset();
 
     CoUninitialize();
 }
@@ -213,11 +213,11 @@ QList<QAudioDevice> QWindowsMediaDevices::availableDevices(QAudioDevice::Mode mo
 
     const auto defaultAudioDeviceID = [this, audioOut]{
         const auto dataFlow = audioOut ? EDataFlow::eRender : EDataFlow::eCapture;
-        QComPtr<IMMDevice> dev;
+        ComPtr<IMMDevice> dev;
         LPWSTR id = nullptr;
         QString sid;
 
-        if (SUCCEEDED(m_deviceEnumerator->GetDefaultAudioEndpoint(dataFlow, ERole::eMultimedia, dev.address()))) {
+        if (SUCCEEDED(m_deviceEnumerator->GetDefaultAudioEndpoint(dataFlow, ERole::eMultimedia, dev.GetAddressOf()))) {
             if (dev && SUCCEEDED(dev->GetId(&id))) {
                 sid = QString::fromWCharArray(id);
                 CoTaskMemFree(id);
@@ -245,10 +245,10 @@ QList<QAudioDevice> QWindowsMediaDevices::availableDevices(QAudioDevice::Mode mo
         if (waveMessage(DRV_QUERYFUNCTIONINSTANCEID, id.data(), len) != MMSYSERR_NOERROR)
             continue;
 
-        QComPtr<IMMDevice> device;
-        QComPtr<IPropertyStore> props;
-        if (FAILED(m_deviceEnumerator->GetDevice(id.data(), device.address()))
-            || FAILED(device->OpenPropertyStore(STGM_READ, props.address()))) {
+        ComPtr<IMMDevice> device;
+        ComPtr<IPropertyStore> props;
+        if (FAILED(m_deviceEnumerator->GetDevice(id.data(), device.GetAddressOf()))
+            || FAILED(device->OpenPropertyStore(STGM_READ, props.GetAddressOf()))) {
             continue;
         }
 
@@ -299,24 +299,24 @@ void QWindowsMediaDevices::prepareAudio()
     if (m_isAudioClientWarmedUp.exchange(true))
         return;
 
-    QComPtr<IMMDeviceEnumerator> deviceEnumerator;
+    ComPtr<IMMDeviceEnumerator> deviceEnumerator;
     HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_ALL,
                                   __uuidof(IMMDeviceEnumerator),
-                                  reinterpret_cast<void **>(deviceEnumerator.address()));
+                                  reinterpret_cast<void **>(deviceEnumerator.GetAddressOf()));
     if (FAILED(hr)) {
         qWarning() << "Failed to create device enumerator" << hr;
         return;
     }
 
-    QComPtr<IMMDevice> device;
-    hr = deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, device.address());
+    ComPtr<IMMDevice> device;
+    hr = deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, device.GetAddressOf());
     if (FAILED(hr)) {
         qWarning() << "Failed to retrieve default audio endpoint" << hr;
         return;
     }
 
     hr = device->Activate(__uuidof(IAudioClient3), CLSCTX_ALL, nullptr,
-                          reinterpret_cast<void **>(m_warmUpAudioClient.address()));
+                          reinterpret_cast<void **>(m_warmUpAudioClient.GetAddressOf()));
     if (FAILED(hr)) {
         qWarning() << "Failed to activate audio engine" << hr;
         return;
diff --git a/src/multimedia/windows/qwindowsmediadevices_p.h b/src/multimedia/windows/qwindowsmediadevices_p.h
index 1973d4769..6852bdcb4 100644
--- a/src/multimedia/windows/qwindowsmediadevices_p.h
+++ b/src/multimedia/windows/qwindowsmediadevices_p.h
@@ -46,11 +46,11 @@ public:
 private:
     QList<QAudioDevice> availableDevices(QAudioDevice::Mode mode) const;
 
-    QComPtr<IMMDeviceEnumerator> m_deviceEnumerator;
-    QComPtr<CMMNotificationClient> m_notificationClient;
+    ComPtr<IMMDeviceEnumerator> m_deviceEnumerator;
+    ComPtr<CMMNotificationClient> m_notificationClient;
     // The "warm-up" audio client is required to run in the background in order to keep audio engine
     // ready for audio output immediately after creating any other subsequent audio client.
-    QComPtr<IAudioClient3> m_warmUpAudioClient;
+    ComPtr<IAudioClient3> m_warmUpAudioClient;
     std::atomic_bool m_isAudioClientWarmedUp = false;
 
     friend CMMNotificationClient;
diff --git a/src/multimedia/windows/qwindowsresampler.cpp b/src/multimedia/windows/qwindowsresampler.cpp
index d9fb8f8be..642f69cbf 100644
--- a/src/multimedia/windows/qwindowsresampler.cpp
+++ b/src/multimedia/windows/qwindowsresampler.cpp
@@ -26,7 +26,7 @@ QWindowsResampler::QWindowsResampler()
         qWarning() << "Failed attempt to change apartment concurrency model";
 
     CoCreateInstance(qCLSID_CResamplerMediaObject, nullptr, CLSCTX_INPROC_SERVER,
-                     qIID_IMFTransform, (LPVOID*)(m_resampler.address()));
+                     qIID_IMFTransform, (LPVOID*)(m_resampler.GetAddressOf()));
     if (m_resampler)
         m_resampler->AddInputStreams(1, &m_inputStreamID);
 }
@@ -54,13 +54,13 @@ quint64 QWindowsResampler::inputBufferSize(quint64 outputBufferSize) const
 
 HRESULT QWindowsResampler::processInput(const QByteArrayView &in)
 {
-    QComPtr<IMFSample> sample;
-    HRESULT hr = m_wmf->mfCreateSample(sample.address());
+    ComPtr<IMFSample> sample;
+    HRESULT hr = m_wmf->mfCreateSample(sample.GetAddressOf());
     if (FAILED(hr))
         return hr;
 
-    QComPtr<IMFMediaBuffer> buffer;
-    hr = m_wmf->mfCreateMemoryBuffer(in.size(), buffer.address());
+    ComPtr<IMFMediaBuffer> buffer;
+    hr = m_wmf->mfCreateMemoryBuffer(in.size(), buffer.GetAddressOf());
     if (FAILED(hr))
         return hr;
 
@@ -81,29 +81,29 @@ HRESULT QWindowsResampler::processInput(const QByteArrayView &in)
     if (FAILED(hr))
         return hr;
 
-    hr = sample->AddBuffer(buffer.get());
+    hr = sample->AddBuffer(buffer.Get());
     if (FAILED(hr))
         return hr;
 
-    return m_resampler->ProcessInput(m_inputStreamID, sample.get(), 0);
+    return m_resampler->ProcessInput(m_inputStreamID, sample.Get(), 0);
 }
 
 HRESULT QWindowsResampler::processOutput(QByteArray &out)
 {
-    QComPtr<IMFSample> sample;
-    QComPtr<IMFMediaBuffer> buffer;
+    ComPtr<IMFSample> sample;
+    ComPtr<IMFMediaBuffer> buffer;
 
     if (m_resamplerNeedsSampleBuffer) {
-        HRESULT hr = m_wmf->mfCreateSample(sample.address());
+        HRESULT hr = m_wmf->mfCreateSample(sample.GetAddressOf());
         if (FAILED(hr))
             return hr;
 
         auto expectedOutputSize = outputBufferSize(m_totalInputBytes) - m_totalOutputBytes;
-        hr = m_wmf->mfCreateMemoryBuffer(expectedOutputSize, buffer.address());
+        hr = m_wmf->mfCreateMemoryBuffer(expectedOutputSize, buffer.GetAddressOf());
         if (FAILED(hr))
             return hr;
 
-        hr = sample->AddBuffer(buffer.get());
+        hr = sample->AddBuffer(buffer.Get());
         if (FAILED(hr))
             return hr;
     }
@@ -115,12 +115,12 @@ HRESULT QWindowsResampler::processOutput(QByteArray &out)
     do {
         outputDataBuffer.pEvents = nullptr;
         outputDataBuffer.dwStatus = 0;
-        outputDataBuffer.pSample = m_resamplerNeedsSampleBuffer ? sample.get() : nullptr;
+        outputDataBuffer.pSample = m_resamplerNeedsSampleBuffer ? sample.Get() : nullptr;
         DWORD status = 0;
         hr = m_resampler->ProcessOutput(0, 1, &outputDataBuffer, &status);
         if (SUCCEEDED(hr)) {
-            QComPtr<IMFMediaBuffer> outputBuffer;
-            outputDataBuffer.pSample->ConvertToContiguousBuffer(outputBuffer.address());
+            ComPtr<IMFMediaBuffer> outputBuffer;
+            outputDataBuffer.pSample->ConvertToContiguousBuffer(outputBuffer.GetAddressOf());
             DWORD len = 0;
             BYTE *data = nullptr;
             hr = outputBuffer->Lock(&data, nullptr, &len);
@@ -174,8 +174,8 @@ QByteArray QWindowsResampler::resample(IMFSample *sample)
     QByteArray out;
 
     if (m_inputFormat == m_outputFormat) {
-        QComPtr<IMFMediaBuffer> outputBuffer;
-        sample->ConvertToContiguousBuffer(outputBuffer.address());
+        ComPtr<IMFMediaBuffer> outputBuffer;
+        sample->ConvertToContiguousBuffer(outputBuffer.GetAddressOf());
         DWORD len = 0;
         BYTE *data = nullptr;
         hr = outputBuffer->Lock(&data, nullptr, &len);
@@ -216,16 +216,16 @@ bool QWindowsResampler::setup(const QAudioFormat &fin, const QAudioFormat &fout)
     if (!m_resampler || !m_wmf)
         return false;
 
-    QComPtr<IMFMediaType> min = QWindowsAudioUtils::formatToMediaType(*m_wmf, fin);
-    QComPtr<IMFMediaType> mout = QWindowsAudioUtils::formatToMediaType(*m_wmf, fout);
+    ComPtr<IMFMediaType> min = QWindowsAudioUtils::formatToMediaType(*m_wmf, fin);
+    ComPtr<IMFMediaType> mout = QWindowsAudioUtils::formatToMediaType(*m_wmf, fout);
 
-    HRESULT hr = m_resampler->SetInputType(m_inputStreamID, min.get(), 0);
+    HRESULT hr = m_resampler->SetInputType(m_inputStreamID, min.Get(), 0);
     if (FAILED(hr)) {
         qCWarning(qLcAudioResampler) << "Failed to set input type" << hr;
         return false;
     }
 
-    hr = m_resampler->SetOutputType(0, mout.get(), 0);
+    hr = m_resampler->SetOutputType(0, mout.Get(), 0);
     if (FAILED(hr)) {
         qCWarning(qLcAudioResampler) << "Failed to set output type" << hr;
         return false;
diff --git a/src/multimedia/windows/qwindowsresampler_p.h b/src/multimedia/windows/qwindowsresampler_p.h
index 351c4259c..03c3d0183 100644
--- a/src/multimedia/windows/qwindowsresampler_p.h
+++ b/src/multimedia/windows/qwindowsresampler_p.h
@@ -54,7 +54,7 @@ private:
     HRESULT processInput(const QByteArrayView &in);
     HRESULT processOutput(QByteArray &out);
 
-    QComPtr<IMFTransform> m_resampler;
+    ComPtr<IMFTransform> m_resampler;
     QWindowsMediaFoundation *m_wmf = nullptr;
 
     bool m_resamplerNeedsSampleBuffer = false;
diff --git a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp
index 44cd4e0c8..1480eaeac 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp
@@ -27,17 +27,17 @@ namespace QFFmpeg {
 class D3D11TextureSet : public TextureSet
 {
 public:
-    D3D11TextureSet(QComPtr<ID3D11Texture2D> &&tex)
+    D3D11TextureSet(ComPtr<ID3D11Texture2D> &&tex)
         : m_tex(tex)
     {}
 
     qint64 textureHandle(int /*plane*/) override
     {
-        return qint64(m_tex.get());
+        return qint64(m_tex.Get());
     }
 
 private:
-    QComPtr<ID3D11Texture2D> m_tex;
+    ComPtr<ID3D11Texture2D> m_tex;
 };
 
 
@@ -46,10 +46,10 @@ D3D11TextureConverter::D3D11TextureConverter(QRhi *rhi)
 {
 }
 
-static QComPtr<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device *dev, ID3D11Texture2D *tex)
+static ComPtr<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device *dev, ID3D11Texture2D *tex)
 {
-    QComPtr<IDXGIResource> dxgiResource;
-    HRESULT hr = tex->QueryInterface(__uuidof(IDXGIResource), reinterpret_cast<void **>(dxgiResource.address()));
+    ComPtr<IDXGIResource> dxgiResource;
+    HRESULT hr = tex->QueryInterface(__uuidof(IDXGIResource), reinterpret_cast<void **>(dxgiResource.GetAddressOf()));
     if (FAILED(hr)) {
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to obtain resource handle from FFMpeg texture" << hr;
         return {};
@@ -61,14 +61,14 @@ static QComPtr<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device *dev, ID3
         return {};
     }
 
-    QComPtr<ID3D11Texture2D> sharedTex;
-    hr = dev->OpenSharedResource(shared, __uuidof(ID3D11Texture2D), reinterpret_cast<void **>(sharedTex.address()));
+    ComPtr<ID3D11Texture2D> sharedTex;
+    hr = dev->OpenSharedResource(shared, __uuidof(ID3D11Texture2D), reinterpret_cast<void **>(sharedTex.GetAddressOf()));
     if (FAILED(hr))
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to share FFmpeg texture" << hr;
     return sharedTex;
 }
 
-static QComPtr<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev, ID3D11Texture2D *array, int index)
+static ComPtr<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev, ID3D11Texture2D *array, int index)
 {
     D3D11_TEXTURE2D_DESC arrayDesc = {};
     array->GetDesc(&arrayDesc);
@@ -83,16 +83,16 @@ static QComPtr<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev, ID3D11Te
     texDesc.MiscFlags = 0;
     texDesc.SampleDesc = { 1, 0};
 
-    QComPtr<ID3D11Texture2D> texCopy;
-    HRESULT hr = dev->CreateTexture2D(&texDesc, nullptr, texCopy.address());
+    ComPtr<ID3D11Texture2D> texCopy;
+    HRESULT hr = dev->CreateTexture2D(&texDesc, nullptr, texCopy.GetAddressOf());
     if (FAILED(hr)) {
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to create texture" << hr;
         return {};
     }
 
-    QComPtr<ID3D11DeviceContext> ctx;
-    dev->GetImmediateContext(ctx.address());
-    ctx->CopySubresourceRegion(texCopy.get(), 0, 0, 0, 0, array, index, nullptr);
+    ComPtr<ID3D11DeviceContext> ctx;
+    dev->GetImmediateContext(ctx.GetAddressOf());
+    ctx->CopySubresourceRegion(texCopy.Get(), 0, 0, 0, 0, array, index, nullptr);
 
     return texCopy;
 }
@@ -120,7 +120,7 @@ TextureSet *D3D11TextureConverter::getTextures(AVFrame *frame)
             return nullptr;
         auto sharedTex = getSharedTextureForDevice(dev, ffmpegTex);
         if (sharedTex) {
-            auto tex = copyTextureFromArray(dev, sharedTex.get(), index);
+            auto tex = copyTextureFromArray(dev, sharedTex.Get(), index);
             if (tex) {
                 return new D3D11TextureSet(std::move(tex));
             }
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp b/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp
index 1c88e1c44..66ccb9e6f 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp
@@ -32,8 +32,8 @@ using namespace QWindowsMultimediaUtils;
 class QD3D11TextureVideoBuffer : public QAbstractVideoBuffer
 {
 public:
-    QD3D11TextureVideoBuffer(QComPtr<ID3D11Device> &device, std::shared_ptr<QMutex> &mutex,
-                             QComPtr<ID3D11Texture2D> &texture, QSize size)
+    QD3D11TextureVideoBuffer(ComPtr<ID3D11Device> &device, std::shared_ptr<QMutex> &mutex,
+                             ComPtr<ID3D11Texture2D> &texture, QSize size)
         : QAbstractVideoBuffer(QVideoFrame::NoHandle)
         , m_device(device)
         , m_texture(texture)
@@ -62,7 +62,7 @@ public:
             texDesc.MiscFlags = 0;
             texDesc.BindFlags = 0;
 
-            HRESULT hr = m_device->CreateTexture2D(&texDesc, nullptr, m_cpuTexture.address());
+            HRESULT hr = m_device->CreateTexture2D(&texDesc, nullptr, m_cpuTexture.GetAddressOf());
             if (FAILED(hr)) {
                 qCDebug(qLcScreenCaptureDxgi) << "Failed to create texture with CPU access"
                                               << std::system_category().message(hr).c_str();
@@ -70,15 +70,15 @@ public:
                 return {};
             }
 
-            m_device->GetImmediateContext(m_ctx.address());
+            m_device->GetImmediateContext(m_ctx.GetAddressOf());
             m_ctxMutex->lock();
-            m_ctx->CopyResource(m_cpuTexture.get(), m_texture.get());
+            m_ctx->CopyResource(m_cpuTexture.Get(), m_texture.Get());
 
             D3D11_MAPPED_SUBRESOURCE resource = {};
-            hr = m_ctx->Map(m_cpuTexture.get(), 0, D3D11_MAP_READ, 0, &resource);
+            hr = m_ctx->Map(m_cpuTexture.Get(), 0, D3D11_MAP_READ, 0, &resource);
             m_ctxMutex->unlock();
             if (FAILED(hr)) {
-                qCDebug(qLcScreenCaptureDxgi) << "Failed to map texture" << m_cpuTexture.get()
+                qCDebug(qLcScreenCaptureDxgi) << "Failed to map texture" << m_cpuTexture.Get()
                                               << std::system_category().message(hr).c_str();
                 return {};
             }
@@ -99,19 +99,19 @@ public:
             return;
         if (m_ctx) {
             m_ctxMutex->lock();
-            m_ctx->Unmap(m_cpuTexture.get(), 0);
+            m_ctx->Unmap(m_cpuTexture.Get(), 0);
             m_ctxMutex->unlock();
-            m_ctx.reset();
+            m_ctx.Reset();
         }
-        m_cpuTexture.reset();
+        m_cpuTexture.Reset();
         m_mapMode = QVideoFrame::NotMapped;
     }
 
 private:
-    QComPtr<ID3D11Device> m_device;
-    QComPtr<ID3D11Texture2D> m_texture;
-    QComPtr<ID3D11Texture2D> m_cpuTexture;
-    QComPtr<ID3D11DeviceContext> m_ctx;
+    ComPtr<ID3D11Device> m_device;
+    ComPtr<ID3D11Texture2D> m_texture;
+    ComPtr<ID3D11Texture2D> m_cpuTexture;
+    ComPtr<ID3D11DeviceContext> m_ctx;
     std::shared_ptr<QMutex> m_ctxMutex;
     QSize m_size;
     QVideoFrame::MapMode m_mapMode = QVideoFrame::NotMapped;
@@ -120,8 +120,8 @@ private:
 class QFFmpegScreenCaptureDxgi::Grabber : public QFFmpegScreenCaptureThread
 {
 public:
-    Grabber(QFFmpegScreenCaptureDxgi &screenCapture, QScreen *screen, QComPtr<ID3D11Device> &device,
-            QComPtr<IDXGIOutputDuplication> &duplication)
+    Grabber(QFFmpegScreenCaptureDxgi &screenCapture, QScreen *screen, ComPtr<ID3D11Device> &device,
+            ComPtr<IDXGIOutputDuplication> &duplication)
         : QFFmpegScreenCaptureThread()
         , m_duplication(duplication)
         , m_device(device)
@@ -179,7 +179,7 @@ public:
     };
 
 private:
-    QMaybe<QComPtr<ID3D11Texture2D>> getNextFrame()
+    QMaybe<ComPtr<ID3D11Texture2D>> getNextFrame()
     {
         if (m_releaseFrame) {
             m_releaseFrame = false;
@@ -189,17 +189,17 @@ private:
                 return "Failed to release duplication frame. " + ::errorString(hr);
         }
 
-        QComPtr<IDXGIResource> frame;
+        ComPtr<IDXGIResource> frame;
         DXGI_OUTDUPL_FRAME_INFO info;
-        HRESULT hr = m_duplication->AcquireNextFrame(0, &info, frame.address());
+        HRESULT hr = m_duplication->AcquireNextFrame(0, &info, frame.GetAddressOf());
         if (FAILED(hr))
             return hr == DXGI_ERROR_WAIT_TIMEOUT ? QString{}
                                                  : "Failed to grab the screen content" + ::errorString(hr);
 
         m_releaseFrame = true;
 
-        QComPtr<ID3D11Texture2D> tex;
-        hr = frame->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void **>(tex.address()));
+        ComPtr<ID3D11Texture2D> tex;
+        hr = frame->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void **>(tex.GetAddressOf()));
         if (FAILED(hr))
             return "Failed to obtain D3D11 texture" + ::errorString(hr);
 
@@ -207,20 +207,20 @@ private:
         tex->GetDesc(&texDesc);
         texDesc.MiscFlags = 0;
         texDesc.BindFlags = 0;
-        QComPtr<ID3D11Texture2D> texCopy;
-        hr = m_device->CreateTexture2D(&texDesc, nullptr, texCopy.address());
+        ComPtr<ID3D11Texture2D> texCopy;
+        hr = m_device->CreateTexture2D(&texDesc, nullptr, texCopy.GetAddressOf());
         if (FAILED(hr))
             return "Failed to create texture with CPU access" + ::errorString(hr);
 
-        QComPtr<ID3D11DeviceContext> ctx;
-        m_device->GetImmediateContext(ctx.address());
-        ctx->CopyResource(texCopy.get(), tex.get());
+        ComPtr<ID3D11DeviceContext> ctx;
+        m_device->GetImmediateContext(ctx.GetAddressOf());
+        ctx->CopyResource(texCopy.Get(), tex.Get());
 
         return texCopy;
     }
 
-    QComPtr<IDXGIOutputDuplication> m_duplication;
-    QComPtr<ID3D11Device> m_device;
+    ComPtr<IDXGIOutputDuplication> m_duplication;
+    ComPtr<ID3D11Device> m_device;
     QWaitCondition m_waitForFormat;
     QVideoFrameFormat m_format;
     QMutex m_formatMutex;
@@ -229,15 +229,15 @@ private:
     bool m_releaseFrame = false;
 };
 
-static QMaybe<QComPtr<IDXGIOutputDuplication>> duplicateOutput(ID3D11Device* device, IDXGIOutput *output)
+static QMaybe<ComPtr<IDXGIOutputDuplication>> duplicateOutput(ID3D11Device* device, IDXGIOutput *output)
 {
-    QComPtr<IDXGIOutput1> output1;
-    HRESULT hr = output->QueryInterface(__uuidof(IDXGIOutput1), reinterpret_cast<void**>(output1.address()));
+    ComPtr<IDXGIOutput1> output1;
+    HRESULT hr = output->QueryInterface(__uuidof(IDXGIOutput1), reinterpret_cast<void**>(output1.GetAddressOf()));
     if (FAILED(hr))
         return  { "Failed to create IDXGIOutput1" + QString(std::system_category().message(hr).c_str()) };
 
-    QComPtr<IDXGIOutputDuplication> dup;
-    hr = output1->DuplicateOutput(device, dup.address());
+    ComPtr<IDXGIOutputDuplication> dup;
+    hr = output1->DuplicateOutput(device, dup.GetAddressOf());
     if (SUCCEEDED(hr))
         return dup;
     else
@@ -245,8 +245,8 @@ static QMaybe<QComPtr<IDXGIOutputDuplication>> duplicateOutput(ID3D11Device* dev
 }
 
 struct DxgiScreen {
-    QComPtr<IDXGIAdapter1> adapter;
-    QComPtr<IDXGIOutput> output;
+    ComPtr<IDXGIAdapter1> adapter;
+    ComPtr<IDXGIOutput> output;
 };
 
 static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
@@ -257,15 +257,15 @@ static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
     auto *winScreen = screen->nativeInterface<QNativeInterface::Private::QWindowsScreen>();
     HMONITOR handle = winScreen ? winScreen->handle() : nullptr;
 
-    QComPtr<IDXGIFactory1> factory;
-    HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(factory.address()));
+    ComPtr<IDXGIFactory1> factory;
+    HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(factory.GetAddressOf()));
     if (FAILED(hr))
         return "Failed to create IDXGIFactory" + errorString(hr);
 
-    QComPtr<IDXGIAdapter1> adapter;
-    for (quint32 i = 0; SUCCEEDED(factory->EnumAdapters1(i, adapter.address())); i++, adapter.reset()) {
-        QComPtr<IDXGIOutput> output;
-        for (quint32 j = 0; SUCCEEDED(adapter->EnumOutputs(j, output.address())); j++, output.reset()) {
+    ComPtr<IDXGIAdapter1> adapter;
+    for (quint32 i = 0; SUCCEEDED(factory->EnumAdapters1(i, adapter.GetAddressOf())); i++, adapter.Reset()) {
+        ComPtr<IDXGIOutput> output;
+        for (quint32 j = 0; SUCCEEDED(adapter->EnumOutputs(j, output.GetAddressOf())); j++, output.Reset()) {
             DXGI_OUTPUT_DESC desc = {};
             output->GetDesc(&desc);
             qCDebug(qLcScreenCaptureDxgi) << i << j << QString::fromWCharArray(desc.DeviceName);
@@ -278,12 +278,12 @@ static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
     return "Could not find screen adapter" + screen->name();
 }
 
-static QMaybe<QComPtr<ID3D11Device>> createD3D11Device(IDXGIAdapter1 *adapter)
+static QMaybe<ComPtr<ID3D11Device>> createD3D11Device(IDXGIAdapter1 *adapter)
 {
-    QComPtr<ID3D11Device> d3d11dev;
+    ComPtr<ID3D11Device> d3d11dev;
     HRESULT hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
                                    0, nullptr, 0, D3D11_SDK_VERSION,
-                                   d3d11dev.address(), nullptr, nullptr);
+                                   d3d11dev.GetAddressOf(), nullptr, nullptr);
     if (SUCCEEDED(hr))
         return d3d11dev;
     else
@@ -320,14 +320,14 @@ bool QFFmpegScreenCaptureDxgi::setActiveInternal(bool active)
             return false;
         }
 
-        auto maybeDev = createD3D11Device(maybeDxgiScreen.value().adapter.get());
+        auto maybeDev = createD3D11Device(maybeDxgiScreen.value().adapter.Get());
         if (!maybeDev) {
             qCDebug(qLcScreenCaptureDxgi) << maybeDev.error();
             updateError(QScreenCapture::InternalError, maybeDev.error());
             return false;
         }
 
-        auto maybeDupOutput = duplicateOutput(maybeDev.value().get(), maybeDxgiScreen.value().output.get());
+        auto maybeDupOutput = duplicateOutput(maybeDev.value().Get(), maybeDxgiScreen.value().output.Get());
         if (!maybeDupOutput) {
             qCDebug(qLcScreenCaptureDxgi) << maybeDupOutput.error();
             updateError(QScreenCapture::InternalError, maybeDupOutput.error());
diff --git a/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp b/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
index 70053117d..3f60cfc37 100644
--- a/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
+++ b/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
@@ -73,17 +73,17 @@ private:
     QMutex m_mutex;
 };
 
-static QComPtr<IMFSourceReader> createCameraReader(IMFMediaSource *mediaSource,
-                                                             const QComPtr<CameraReaderCallback> &callback)
+static ComPtr<IMFSourceReader> createCameraReader(IMFMediaSource *mediaSource,
+                                                             const ComPtr<CameraReaderCallback> &callback)
 {
-    QComPtr<IMFSourceReader> sourceReader;
-    QComPtr<IMFAttributes> readerAttributes;
+    ComPtr<IMFSourceReader> sourceReader;
+    ComPtr<IMFAttributes> readerAttributes;
 
-    HRESULT hr = MFCreateAttributes(readerAttributes.address(), 1);
+    HRESULT hr = MFCreateAttributes(readerAttributes.GetAddressOf(), 1);
     if (SUCCEEDED(hr)) {
-        hr = readerAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, callback.get());
+        hr = readerAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, callback.Get());
         if (SUCCEEDED(hr)) {
-            hr = MFCreateSourceReaderFromMediaSource(mediaSource, readerAttributes.get(), sourceReader.address());
+            hr = MFCreateSourceReaderFromMediaSource(mediaSource, readerAttributes.Get(), sourceReader.GetAddressOf());
             if (SUCCEEDED(hr))
                 return sourceReader;
         }
@@ -93,18 +93,18 @@ static QComPtr<IMFSourceReader> createCameraReader(IMFMediaSource *mediaSource,
     return sourceReader;
 }
 
-static QComPtr<IMFMediaSource> createCameraSource(const QString &deviceId)
+static ComPtr<IMFMediaSource> createCameraSource(const QString &deviceId)
 {
-    QComPtr<IMFMediaSource> mediaSource;
-    QComPtr<IMFAttributes> sourceAttributes;
-    HRESULT hr = MFCreateAttributes(sourceAttributes.address(), 2);
+    ComPtr<IMFMediaSource> mediaSource;
+    ComPtr<IMFAttributes> sourceAttributes;
+    HRESULT hr = MFCreateAttributes(sourceAttributes.GetAddressOf(), 2);
     if (SUCCEEDED(hr)) {
         hr = sourceAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, QMM_MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
         if (SUCCEEDED(hr)) {
             hr = sourceAttributes->SetString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
                                              reinterpret_cast<LPCWSTR>(deviceId.utf16()));
             if (SUCCEEDED(hr)) {
-                hr = MFCreateDeviceSource(sourceAttributes.get(), mediaSource.address());
+                hr = MFCreateDeviceSource(sourceAttributes.Get(), mediaSource.GetAddressOf());
                 if (SUCCEEDED(hr))
                     return mediaSource;
             }
@@ -144,13 +144,13 @@ static bool setCameraReaderFormat(IMFSourceReader *sourceReader, IMFMediaType *v
     return SUCCEEDED(hr);
 }
 
-static QComPtr<IMFMediaType> findVideoType(IMFSourceReader *reader,
+static ComPtr<IMFMediaType> findVideoType(IMFSourceReader *reader,
                                                      const QCameraFormat &format)
 {
     for (DWORD i = 0;; ++i) {
-        QComPtr<IMFMediaType> candidate;
+        ComPtr<IMFMediaType> candidate;
         HRESULT hr = reader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, i,
-                                                candidate.address());
+                                                candidate.GetAddressOf());
         if (FAILED(hr))
             break;
 
@@ -163,7 +163,7 @@ static QComPtr<IMFMediaType> findVideoType(IMFSourceReader *reader,
 
         UINT32 width = 0u;
         UINT32 height = 0u;
-        if (FAILED(MFGetAttributeSize(candidate.get(), MF_MT_FRAME_SIZE, &width, &height)))
+        if (FAILED(MFGetAttributeSize(candidate.Get(), MF_MT_FRAME_SIZE, &width, &height)))
             continue;
 
         if (format.resolution() != QSize{ int(width), int(height) })
@@ -187,7 +187,7 @@ public:
 
         ac->m_readerCallback = makeComObject<CameraReaderCallback>();
         ac->m_readerCallback->setActiveCamera(ac.get());
-        ac->m_reader = createCameraReader(ac->m_source.get(), ac->m_readerCallback);
+        ac->m_reader = createCameraReader(ac->m_source.Get(), ac->m_readerCallback);
         if (!ac->m_reader)
             return {};
 
@@ -202,12 +202,12 @@ public:
         m_reader->Flush(MF_SOURCE_READER_FIRST_VIDEO_STREAM);
         m_flushWait.acquire();
 
-        auto videoType = findVideoType(m_reader.get(), format);
+        auto videoType = findVideoType(m_reader.Get(), format);
         if (videoType) {
-            if (setCameraReaderFormat(m_reader.get(), videoType.get())) {
+            if (setCameraReaderFormat(m_reader.Get(), videoType.Get())) {
                 m_frameFormat = { format.resolution(), format.pixelFormat() };
                 m_videoFrameStride =
-                        calculateVideoFrameStride(videoType.get(), format.resolution().width());
+                        calculateVideoFrameStride(videoType.Get(), format.resolution().width());
             }
         }
 
@@ -224,8 +224,8 @@ public:
         }
 
         if (sample) {
-            QComPtr<IMFMediaBuffer> mediaBuffer;
-            if (SUCCEEDED(sample->ConvertToContiguousBuffer(mediaBuffer.address()))) {
+            ComPtr<IMFMediaBuffer> mediaBuffer;
+            if (SUCCEEDED(sample->ConvertToContiguousBuffer(mediaBuffer.GetAddressOf()))) {
 
                 DWORD bufLen = 0;
                 BYTE *buffer = nullptr;
@@ -269,9 +269,9 @@ private:
 
     QSemaphore m_flushWait;
 
-    QComPtr<IMFMediaSource> m_source;
-    QComPtr<IMFSourceReader> m_reader;
-    QComPtr<CameraReaderCallback> m_readerCallback;
+    ComPtr<IMFMediaSource> m_source;
+    ComPtr<IMFSourceReader> m_reader;
+    ComPtr<CameraReaderCallback> m_readerCallback;
 
     QVideoFrameFormat m_frameFormat;
     int m_videoFrameStride = 0;
diff --git a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp
index cab650d3d..10680394a 100644
--- a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp
+++ b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp
@@ -94,15 +94,15 @@ void MFAudioDecoderControl::startReadingSource(IMFMediaSource *source)
     }
 
     auto mediaType = m_decoderSourceReader->setSource(source, m_outputFormat.sampleFormat());
-    QAudioFormat mediaFormat = QWindowsAudioUtils::mediaTypeToFormat(mediaType.get());
+    QAudioFormat mediaFormat = QWindowsAudioUtils::mediaTypeToFormat(mediaType.Get());
     if (!mediaFormat.isValid()) {
         error(QAudioDecoder::FormatError, tr("Invalid media format"));
-        m_decoderSourceReader.reset();
+        m_decoderSourceReader.Reset();
         return;
     }
 
-    QComPtr<IMFPresentationDescriptor> pd;
-    if (SUCCEEDED(source->CreatePresentationDescriptor(pd.address()))) {
+    ComPtr<IMFPresentationDescriptor> pd;
+    if (SUCCEEDED(source->CreatePresentationDescriptor(pd.GetAddressOf()))) {
         UINT64 duration = 0;
         pd->GetUINT64(MF_PD_DURATION, &duration);
         duration /= 10000;
@@ -115,8 +115,8 @@ void MFAudioDecoderControl::startReadingSource(IMFMediaSource *source)
         return;
     }
 
-    connect(m_decoderSourceReader.get(), &MFDecoderSourceReader::finished, this, &MFAudioDecoderControl::handleSourceFinished);
-    connect(m_decoderSourceReader.get(), &MFDecoderSourceReader::newSample, this, &MFAudioDecoderControl::handleNewSample);
+    connect(m_decoderSourceReader.Get(), &MFDecoderSourceReader::finished, this, &MFAudioDecoderControl::handleSourceFinished);
+    connect(m_decoderSourceReader.Get(), &MFDecoderSourceReader::newSample, this, &MFAudioDecoderControl::handleNewSample);
 
     setIsDecoding(true);
 
@@ -152,9 +152,9 @@ void MFAudioDecoderControl::stop()
     if (!isDecoding())
         return;
 
-    disconnect(m_decoderSourceReader.get());
+    disconnect(m_decoderSourceReader.Get());
     m_decoderSourceReader->clearSource();
-    m_decoderSourceReader.reset();
+    m_decoderSourceReader.Reset();
 
     if (bufferAvailable()) {
         QAudioBuffer buffer;
@@ -173,12 +173,12 @@ void MFAudioDecoderControl::stop()
     }
 }
 
-void MFAudioDecoderControl::handleNewSample(QComPtr<IMFSample> sample)
+void MFAudioDecoderControl::handleNewSample(ComPtr<IMFSample> sample)
 {
     Q_ASSERT(sample);
 
     qint64 sampleStartTimeUs = m_resampler.outputFormat().durationForBytes(m_resampler.totalOutputBytes());
-    QByteArray out = m_resampler.resample(sample.get());
+    QByteArray out = m_resampler.resample(sample.Get());
 
     if (out.isEmpty()) {
         error(QAudioDecoder::Error::ResourceError, tr("Failed processing a sample"));
diff --git a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h
index 1912af175..9bb2371ec 100644
--- a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h
+++ b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h
@@ -51,13 +51,13 @@ public:
 private Q_SLOTS:
     void handleMediaSourceReady();
     void handleMediaSourceError(long hr);
-    void handleNewSample(QComPtr<IMFSample>);
+    void handleNewSample(ComPtr<IMFSample>);
     void handleSourceFinished();
 
 private:
     void startReadingSource(IMFMediaSource *source);
 
-    QComPtr<MFDecoderSourceReader>  m_decoderSourceReader;
+    ComPtr<MFDecoderSourceReader>  m_decoderSourceReader;
     SourceResolver         *m_sourceResolver;
     QWindowsResampler       m_resampler;
     QUrl                    m_source;
diff --git a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp
index 609be2961..097f83437 100644
--- a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp
+++ b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp
@@ -9,22 +9,22 @@
 
 QT_BEGIN_NAMESPACE
 
-QComPtr<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource *source, QAudioFormat::SampleFormat sampleFormat)
+ComPtr<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource *source, QAudioFormat::SampleFormat sampleFormat)
 {
-    QComPtr<IMFMediaType> mediaType;
-    m_sourceReader.reset();
+    ComPtr<IMFMediaType> mediaType;
+    m_sourceReader.Reset();
 
     if (!source)
         return mediaType;
 
-    QComPtr<IMFAttributes> attr;
-    MFCreateAttributes(attr.address(), 1);
+    ComPtr<IMFAttributes> attr;
+    MFCreateAttributes(attr.GetAddressOf(), 1);
     if (FAILED(attr->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this)))
         return mediaType;
     if (FAILED(attr->SetUINT32(MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN, TRUE)))
         return mediaType;
 
-    HRESULT hr = MFCreateSourceReaderFromMediaSource(source, attr.get(), m_sourceReader.address());
+    HRESULT hr = MFCreateSourceReaderFromMediaSource(source, attr.Get(), m_sourceReader.GetAddressOf());
     if (FAILED(hr)) {
         qWarning() << "MFDecoderSourceReader: failed to set up source reader: "
                    << std::system_category().message(hr).c_str();
@@ -34,12 +34,12 @@ QComPtr<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource *source, Q
     m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_ALL_STREAMS), FALSE);
     m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE);
 
-    QComPtr<IMFMediaType> pPartialType;
-    MFCreateMediaType(pPartialType.address());
+    ComPtr<IMFMediaType> pPartialType;
+    MFCreateMediaType(pPartialType.GetAddressOf());
     pPartialType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
     pPartialType->SetGUID(MF_MT_SUBTYPE, sampleFormat == QAudioFormat::Float ? MFAudioFormat_Float : MFAudioFormat_PCM);
-    m_sourceReader->SetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), nullptr, pPartialType.get());
-    m_sourceReader->GetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), mediaType.address());
+    m_sourceReader->SetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), nullptr, pPartialType.Get());
+    m_sourceReader->GetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), mediaType.GetAddressOf());
     // Ensure the stream is selected.
     m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE);
 
@@ -91,7 +91,7 @@ STDMETHODIMP MFDecoderSourceReader::OnReadSample(HRESULT hrStatus, DWORD dwStrea
     Q_UNUSED(dwStreamIndex);
     Q_UNUSED(llTimestamp);
     if (pSample) {
-        emit newSample(QComPtr{pSample});
+        emit newSample(ComPtr<IMFSample>{pSample});
     } else if ((dwStreamFlags & MF_SOURCE_READERF_ENDOFSTREAM) == MF_SOURCE_READERF_ENDOFSTREAM) {
         emit finished();
     }
diff --git a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h
index 43ebbd222..dee6f8bf5 100644
--- a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h
+++ b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h
@@ -32,8 +32,8 @@ public:
     MFDecoderSourceReader() {}
     ~MFDecoderSourceReader() override {}
 
-    void clearSource() { m_sourceReader.reset(); }
-    QComPtr<IMFMediaType> setSource(IMFMediaSource *source, QAudioFormat::SampleFormat);
+    void clearSource() { m_sourceReader.Reset(); }
+    ComPtr<IMFMediaType> setSource(IMFMediaSource *source, QAudioFormat::SampleFormat);
 
     void readNextSample();
 
@@ -49,12 +49,12 @@ public:
     STDMETHODIMP OnEvent(DWORD, IMFMediaEvent *) override { return S_OK; }
 
 Q_SIGNALS:
-    void newSample(QComPtr<IMFSample>);
+    void newSample(ComPtr<IMFSample>);
     void finished();
 
 private:
     long m_cRef = 1;
-    QComPtr<IMFSourceReader> m_sourceReader;
+    ComPtr<IMFSourceReader> m_sourceReader;
 
 };
 
diff --git a/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp b/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
index bb6d0390f..41935d0a1 100644
--- a/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
+++ b/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
@@ -1898,9 +1898,9 @@ void EVRCustomPresenter::presentSample(IMFSample *sample)
             frame.setEndTime(frame.endTime() + m_positionOffset);
     }
 
-    QComPtr<IMFMediaType> inputStreamType;
-    if (SUCCEEDED(m_mixer->GetInputCurrentType(0, inputStreamType.address()))) {
-        auto rotation = static_cast<MFVideoRotationFormat>(MFGetAttributeUINT32(inputStreamType.get(), MF_MT_VIDEO_ROTATION, 0));
+    ComPtr<IMFMediaType> inputStreamType;
+    if (SUCCEEDED(m_mixer->GetInputCurrentType(0, inputStreamType.GetAddressOf()))) {
+        auto rotation = static_cast<MFVideoRotationFormat>(MFGetAttributeUINT32(inputStreamType.Get(), MF_MT_VIDEO_ROTATION, 0));
         switch (rotation) {
         case MFVideoRotationFormat_0: frame.setRotationAngle(QVideoFrame::Rotation0); break;
         case MFVideoRotationFormat_90: frame.setRotationAngle(QVideoFrame::Rotation90); break;
diff --git a/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp b/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp
index 1c2c2c1aa..5b45d22cb 100644
--- a/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp
+++ b/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp
@@ -30,7 +30,7 @@ static Q_LOGGING_CATEGORY(qLcEvrD3DPresentEngine, "qt.multimedia.evrd3dpresenten
 class IMFSampleVideoBuffer: public QAbstractVideoBuffer
 {
 public:
-    IMFSampleVideoBuffer(QComPtr<IDirect3DDevice9Ex> device,
+    IMFSampleVideoBuffer(ComPtr<IDirect3DDevice9Ex> device,
                           IMFSample *sample, QRhi *rhi, QVideoFrame::HandleType type = QVideoFrame::NoHandle)
         : QAbstractVideoBuffer(type, rhi)
         , m_device(device)
@@ -58,24 +58,24 @@ public:
                 return {};
 
         } else {
-            QComPtr<IMFMediaBuffer> buffer;
-            HRESULT hr = m_sample->GetBufferByIndex(0, buffer.address());
+            ComPtr<IMFMediaBuffer> buffer;
+            HRESULT hr = m_sample->GetBufferByIndex(0, buffer.GetAddressOf());
             if (FAILED(hr))
                 return {};
 
-            QComPtr<IDirect3DSurface9> surface;
-            hr = MFGetService(buffer.get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9, (void **)(surface.address()));
+            ComPtr<IDirect3DSurface9> surface;
+            hr = MFGetService(buffer.Get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9, (void **)(surface.GetAddressOf()));
             if (FAILED(hr))
                 return {};
 
             if (FAILED(surface->GetDesc(&desc)))
                 return {};
 
-            if (FAILED(m_device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, m_memSurface.address(), nullptr)))
+            if (FAILED(m_device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, m_memSurface.GetAddressOf(), nullptr)))
                 return {};
 
-            if (FAILED(m_device->GetRenderTargetData(surface.get(), m_memSurface.get()))) {
-                m_memSurface.reset();
+            if (FAILED(m_device->GetRenderTargetData(surface.Get(), m_memSurface.Get()))) {
+                m_memSurface.Reset();
                 return {};
             }
         }
@@ -105,18 +105,18 @@ public:
     }
 
 protected:
-    QComPtr<IDirect3DDevice9Ex> m_device;
-    QComPtr<IMFSample> m_sample;
+    ComPtr<IDirect3DDevice9Ex> m_device;
+    ComPtr<IMFSample> m_sample;
 
 private:
-    QComPtr<IDirect3DSurface9> m_memSurface;
+    ComPtr<IDirect3DSurface9> m_memSurface;
     QVideoFrame::MapMode m_mapMode;
 };
 
 class QVideoFrameD3D11Textures: public QVideoFrameTextures
 {
 public:
-    QVideoFrameD3D11Textures(std::unique_ptr<QRhiTexture> &&tex, QComPtr<ID3D11Texture2D> &&d3d11tex)
+    QVideoFrameD3D11Textures(std::unique_ptr<QRhiTexture> &&tex, ComPtr<ID3D11Texture2D> &&d3d11tex)
        : m_tex(std::move(tex))
        , m_d3d11tex(std::move(d3d11tex))
     {}
@@ -128,13 +128,13 @@ public:
 
 private:
     std::unique_ptr<QRhiTexture> m_tex;
-    QComPtr<ID3D11Texture2D> m_d3d11tex;
+    ComPtr<ID3D11Texture2D> m_d3d11tex;
 };
 
 class D3D11TextureVideoBuffer: public IMFSampleVideoBuffer
 {
 public:
-    D3D11TextureVideoBuffer(QComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
+    D3D11TextureVideoBuffer(ComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
                             HANDLE sharedHandle, QRhi *rhi)
         : IMFSampleVideoBuffer(std::move(device), sample, rhi, QVideoFrame::RhiTextureHandle)
         , m_sharedHandle(sharedHandle)
@@ -153,8 +153,8 @@ public:
         if (!dev)
             return {};
 
-        QComPtr<ID3D11Texture2D> d3d11tex;
-        HRESULT hr = dev->OpenSharedResource(m_sharedHandle, __uuidof(ID3D11Texture2D), (void**)(d3d11tex.address()));
+        ComPtr<ID3D11Texture2D> d3d11tex;
+        HRESULT hr = dev->OpenSharedResource(m_sharedHandle, __uuidof(ID3D11Texture2D), (void**)(d3d11tex.GetAddressOf()));
         if (SUCCEEDED(hr)) {
             D3D11_TEXTURE2D_DESC desc = {};
             d3d11tex->GetDesc(&desc);
@@ -167,7 +167,7 @@ public:
                 return {};
 
             std::unique_ptr<QRhiTexture> tex(rhi->newTexture(format, QSize{int(desc.Width), int(desc.Height)}, 1, {}));
-            tex->createFrom({quint64(d3d11tex.get()), 0});
+            tex->createFrom({quint64(d3d11tex.Get()), 0});
             return std::make_unique<QVideoFrameD3D11Textures>(std::move(tex), std::move(d3d11tex));
 
         } else {
@@ -287,7 +287,7 @@ private:
 class OpenGlVideoBuffer: public IMFSampleVideoBuffer
 {
 public:
-    OpenGlVideoBuffer(QComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
+    OpenGlVideoBuffer(ComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
                       const WglNvDxInterop &wglNvDxInterop, HANDLE sharedHandle, QRhi *rhi)
         : IMFSampleVideoBuffer(std::move(device), sample, rhi, QVideoFrame::RhiTextureHandle)
         , m_sharedHandle(sharedHandle)
@@ -297,29 +297,29 @@ public:
     std::unique_ptr<QVideoFrameTextures> mapTextures(QRhi *rhi) override
     {
         if (!m_texture) {
-            QComPtr<IMFMediaBuffer> buffer;
-            HRESULT hr = m_sample->GetBufferByIndex(0, buffer.address());
+            ComPtr<IMFMediaBuffer> buffer;
+            HRESULT hr = m_sample->GetBufferByIndex(0, buffer.GetAddressOf());
             if (FAILED(hr))
                 return {};
 
-            QComPtr<IDirect3DSurface9> surface;
-            hr = MFGetService(buffer.get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9,
-                              (void **)(surface.address()));
+            ComPtr<IDirect3DSurface9> surface;
+            hr = MFGetService(buffer.Get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9,
+                              (void **)(surface.GetAddressOf()));
             if (FAILED(hr))
                 return {};
 
-            hr = surface->GetContainer(IID_IDirect3DTexture9, (void **)m_texture.address());
+            hr = surface->GetContainer(IID_IDirect3DTexture9, (void **)m_texture.GetAddressOf());
             if (FAILED(hr))
                 return {};
         }
 
-        return QVideoFrameOpenGlTextures::create(m_wgl, rhi, m_device.get(), m_texture.get(), m_sharedHandle);
+        return QVideoFrameOpenGlTextures::create(m_wgl, rhi, m_device.Get(), m_texture.Get(), m_sharedHandle);
     }
 
 private:
     HANDLE m_sharedHandle = nullptr;
     WglNvDxInterop m_wgl;
-    QComPtr<IDirect3DTexture9> m_texture;
+    ComPtr<IDirect3DTexture9> m_texture;
 };
 #endif
 
@@ -343,9 +343,9 @@ void D3DPresentEngine::setSink(QVideoSink *sink)
     m_sink = sink;
 
     releaseResources();
-    m_device.reset();
-    m_devices.reset();
-    m_D3D9.reset();
+    m_device.Reset();
+    m_devices.Reset();
+    m_D3D9.Reset();
 
     if (!m_sink)
         return;
@@ -363,10 +363,10 @@ void D3DPresentEngine::setSink(QVideoSink *sink)
 
 HRESULT D3DPresentEngine::initializeD3D()
 {
-    HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, m_D3D9.address());
+    HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, m_D3D9.GetAddressOf());
 
     if (SUCCEEDED(hr))
-        hr = DXVA2CreateDirect3DDeviceManager9(&m_deviceResetToken, m_devices.address());
+        hr = DXVA2CreateDirect3DDeviceManager9(&m_deviceResetToken, m_devices.GetAddressOf());
 
     return hr;
 }
@@ -440,7 +440,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
     QRhi *rhi = m_sink ? m_sink->rhi() : nullptr;
     if (rhi) {
         if (rhi->backend() == QRhi::D3D11) {
-            m_useTextureRendering = findD3D11AdapterID(*rhi, m_D3D9.get(), adapterID);
+            m_useTextureRendering = findD3D11AdapterID(*rhi, m_D3D9.Get(), adapterID);
 #if QT_CONFIG(opengl)
         } else if (rhi->backend() == QRhi::OpenGLES2)  {
             m_useTextureRendering = readWglNvDxInteropProc(m_wglNvDxInterop);
@@ -481,7 +481,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
     pp.Flags = D3DPRESENTFLAG_VIDEO;
     pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
 
-    QComPtr<IDirect3DDevice9Ex> device;
+    ComPtr<IDirect3DDevice9Ex> device;
 
     hr = m_D3D9->CreateDeviceEx(
                 adapterID,
@@ -490,7 +490,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
                 vp | D3DCREATE_NOWINDOWCHANGES | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE,
                 &pp,
                 NULL,
-                device.address()
+                device.GetAddressOf()
                 );
     if (FAILED(hr))
         return hr;
@@ -499,7 +499,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
     if (FAILED(hr))
         return hr;
 
-    hr = m_devices->ResetDevice(device.get(), m_deviceResetToken);
+    hr = m_devices->ResetDevice(device.Get(), m_deviceResetToken);
     if (FAILED(hr))
         return hr;
 
@@ -509,7 +509,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
 
 bool D3DPresentEngine::isValid() const
 {
-    return m_device.get() != nullptr;
+    return m_device.Get() != nullptr;
 }
 
 void D3DPresentEngine::releaseResources()
@@ -525,7 +525,7 @@ HRESULT D3DPresentEngine::getService(REFGUID, REFIID riid, void** ppv)
         if (!m_devices) {
             hr = MF_E_UNSUPPORTED_SERVICE;
         } else {
-            *ppv = m_devices.get();
+            *ppv = m_devices.Get();
             m_devices->AddRef();
         }
     } else {
@@ -603,24 +603,24 @@ HRESULT D3DPresentEngine::createVideoSamples(IMFMediaType *format, QList<IMFSamp
     for (int i = 0; i < PRESENTER_BUFFER_COUNT; i++) {
         // texture ref cnt is increased by GetSurfaceLevel()/MFCreateVideoSampleFromSurface()
         // below, so it will be destroyed only when the sample pool is released.
-        QComPtr<IDirect3DTexture9> texture;
+        ComPtr<IDirect3DTexture9> texture;
         HANDLE sharedHandle = nullptr;
-        hr = m_device->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, (D3DFORMAT)d3dFormat,  D3DPOOL_DEFAULT, texture.address(), &sharedHandle);
+        hr = m_device->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, (D3DFORMAT)d3dFormat,  D3DPOOL_DEFAULT, texture.GetAddressOf(), &sharedHandle);
         if (FAILED(hr))
             break;
 
-        QComPtr<IDirect3DSurface9> surface;
-        hr = texture->GetSurfaceLevel(0, surface.address());
+        ComPtr<IDirect3DSurface9> surface;
+        hr = texture->GetSurfaceLevel(0, surface.GetAddressOf());
         if (FAILED(hr))
             break;
 
-        QComPtr<IMFSample> videoSample;
-        hr = MFCreateVideoSampleFromSurface(surface.get(), videoSample.address());
+        ComPtr<IMFSample> videoSample;
+        hr = MFCreateVideoSampleFromSurface(surface.Get(), videoSample.GetAddressOf());
         if (FAILED(hr))
             break;
 
-        m_sampleTextureHandle[i] = {videoSample.get(), sharedHandle};
-        videoSampleQueue.append(videoSample.release());
+        m_sampleTextureHandle[i] = {videoSample.Get(), sharedHandle};
+        videoSampleQueue.append(videoSample.Detach());
     }
 
     if (SUCCEEDED(hr)) {
diff --git a/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h b/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h
index 3459c7b5c..3abf07835 100644
--- a/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h
+++ b/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h
@@ -125,9 +125,9 @@ private:
     UINT m_deviceResetToken;
     D3DDISPLAYMODE m_displayMode;
 
-    QComPtr<IDirect3D9Ex> m_D3D9;
-    QComPtr<IDirect3DDevice9Ex> m_device;
-    QComPtr<IDirect3DDeviceManager9> m_devices;
+    ComPtr<IDirect3D9Ex> m_D3D9;
+    ComPtr<IDirect3DDevice9Ex> m_device;
+    ComPtr<IDirect3DDeviceManager9> m_devices;
 
     QVideoFrameFormat m_surfaceFormat;
 
diff --git a/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp b/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp
index d01fb24ae..2bdc4ea7d 100644
--- a/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp
+++ b/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp
@@ -638,9 +638,9 @@ QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
     if (!m_active || m_recording || (videoFormat == GUID_NULL && audioFormat == GUID_NULL))
         return QMediaRecorder::ResourceError;
 
-    QComPtr<IMFAttributes> writerAttributes;
+    ComPtr<IMFAttributes> writerAttributes;
 
-    HRESULT hr = MFCreateAttributes(writerAttributes.address(), 2);
+    HRESULT hr = MFCreateAttributes(writerAttributes.GetAddressOf(), 2);
     if (FAILED(hr))
         return QMediaRecorder::ResourceError;
 
@@ -654,9 +654,9 @@ QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
     if (FAILED(hr))
         return QMediaRecorder::ResourceError;
 
-    QComPtr<IMFSinkWriter> sinkWriter;
+    ComPtr<IMFSinkWriter> sinkWriter;
     hr = MFCreateSinkWriterFromURL(reinterpret_cast<LPCWSTR>(fileName.utf16()),
-                                   nullptr, writerAttributes.get(), sinkWriter.address());
+                                   nullptr, writerAttributes.Get(), sinkWriter.GetAddressOf());
     if (FAILED(hr))
         return QMediaRecorder::LocationNotWritable;
 
@@ -702,7 +702,7 @@ QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
     if (FAILED(hr))
         return QMediaRecorder::ResourceError;
 
-    m_sinkWriter = sinkWriter.release();
+    m_sinkWriter = sinkWriter.Detach();
     m_lastDuration = -1;
     m_currentDuration = 0;
     updateDuration();
diff --git a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
index 28f89c97b..a587f6759 100644
--- a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
+++ b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
@@ -40,18 +40,18 @@ static QSet<T> getCodecSet(GUID category)
 
     if (SUCCEEDED(hr)) {
         for (UINT32 i = 0; i < num; ++i) {
-            QComPtr<IMFTransform> transform;
+            ComPtr<IMFTransform> transform;
             UINT32 typeIndex = 0;
 
-            hr = activateArray[i]->ActivateObject(IID_PPV_ARGS(transform.address()));
+            hr = activateArray[i]->ActivateObject(IID_PPV_ARGS(transform.GetAddressOf()));
 
             while (SUCCEEDED(hr)) {
-                QComPtr<IMFMediaType> mediaType;
+                ComPtr<IMFMediaType> mediaType;
 
                 if (category == MFT_CATEGORY_AUDIO_ENCODER || category == MFT_CATEGORY_VIDEO_ENCODER)
-                    hr = transform->GetOutputAvailableType(0, typeIndex++, mediaType.address());
+                    hr = transform->GetOutputAvailableType(0, typeIndex++, mediaType.GetAddressOf());
                 else
-                    hr = transform->GetInputAvailableType(0, typeIndex++, mediaType.address());
+                    hr = transform->GetInputAvailableType(0, typeIndex++, mediaType.GetAddressOf());
 
                 if (SUCCEEDED(hr)) {
                     GUID subtype = GUID_NULL;
diff --git a/src/plugins/multimedia/windows/qwindowsvideodevices.cpp b/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
index 2dae560b9..daa0a8185 100644
--- a/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
+++ b/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
@@ -155,8 +155,8 @@ static std::optional<QCameraDevice> createCameraDevice(IMFActivate *device)
     if (FAILED(hr))
         return {};
 
-    QComPtr<IMFSourceReader> reader;
-    hr = MFCreateSourceReaderFromMediaSource(source, NULL, reader.address());
+    ComPtr<IMFSourceReader> reader;
+    hr = MFCreateSourceReaderFromMediaSource(source, NULL, reader.GetAddressOf());
     if (FAILED(hr))
         return {};
 
@@ -164,13 +164,13 @@ static std::optional<QCameraDevice> createCameraDevice(IMFActivate *device)
     QList<QCameraFormat> videoFormats;
     for (DWORD i = 0;; ++i) {
         // Loop through the supported formats for the video device
-        QComPtr<IMFMediaType> mediaFormat;
+        ComPtr<IMFMediaType> mediaFormat;
         hr = reader->GetNativeMediaType((DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, i,
-                                        mediaFormat.address());
+                                        mediaFormat.GetAddressOf());
         if (FAILED(hr))
             break;
 
-        auto maybeCamera = createCameraFormat(mediaFormat.get());
+        auto maybeCamera = createCameraFormat(mediaFormat.Get());
         if (maybeCamera) {
             videoFormats << *maybeCamera;
             photoResolutions << maybeCamera->resolution();
@@ -208,20 +208,20 @@ QList<QCameraDevice> QWindowsVideoDevices::videoDevices() const
 {
     QList<QCameraDevice> cameras;
 
-    QComPtr<IMFAttributes> attr;
-    HRESULT hr = MFCreateAttributes(attr.address(), 2);
+    ComPtr<IMFAttributes> attr;
+    HRESULT hr = MFCreateAttributes(attr.GetAddressOf(), 2);
     if (FAILED(hr))
         return {};
 
     hr = attr->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
                        MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
     if (SUCCEEDED(hr)) {
-        cameras << readCameraDevices(attr.get());
+        cameras << readCameraDevices(attr.Get());
 
         hr = attr->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY,
                            QMM_KSCATEGORY_SENSOR_CAMERA);
         if (SUCCEEDED(hr))
-            cameras << readCameraDevices(attr.get());
+            cameras << readCameraDevices(attr.Get());
     }
 
     return cameras;