Rename QWindowsIUPointer template class to QComPtr

The name QWindowsIUPointer feels clunky and does not add clarity. On the
Windows platform, the term ComPtr, CComPtr or com_ptr is well
established and understood. By renaming the QWindowsIUPointer to QComPtr
we get code that is easier to read, particularly when the pointer is
used in template classes such as std::vector<QComPtr> or
QMaybe<QComPtr>.

Task-number: QTBUG-113460
Pick-to: 6.5
Change-Id: Ia3ef06c4a1c0e45503ba5204a4d2fd6197114b15
Reviewed-by: Lars Knoll <lars@knoll.priv.no>

26 files changed, 135 insertions, 135 deletions

diff --git a/src/multimedia/windows/qwindowsaudiodevice.cpp b/src/multimedia/windows/qwindowsaudiodevice.cpp
index aa56632fc..fbc1cfa02 100644
--- a/src/multimedia/windows/qwindowsaudiodevice.cpp
+++ b/src/multimedia/windows/qwindowsaudiodevice.cpp
@@ -29,7 +29,7 @@
 
 QT_BEGIN_NAMESPACE
 
-QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QWindowsIUPointer<IMMDevice> immDev, int waveID, const QString &description, QAudioDevice::Mode mode)
+QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<IMMDevice> immDev, int waveID, const QString &description, QAudioDevice::Mode mode)
     : QAudioDevicePrivate(dev, mode),
       m_devId(waveID),
       m_immDev(std::move(immDev))
@@ -38,7 +38,7 @@ QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QWindowsIUPoint
 
     this->description = description;
 
-    QWindowsIUPointer<IAudioClient> audioClient;
+    QComPtr<IAudioClient> audioClient;
     HRESULT hr = m_immDev->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, nullptr,
                                     (void **)audioClient.address());
     if (SUCCEEDED(hr)) {
@@ -194,7 +194,7 @@ QWindowsAudioDeviceInfo::QWindowsAudioDeviceInfo(QByteArray dev, QWindowsIUPoint
 
     channelConfiguration = QAudioFormat::defaultChannelConfigForChannelCount(maximumChannelCount);
 
-    QWindowsIUPointer<IPropertyStore> props;
+    QComPtr<IPropertyStore> props;
     hr = m_immDev->OpenPropertyStore(STGM_READ, props.address());
     if (SUCCEEDED(hr)) {
         PROPVARIANT var;
diff --git a/src/multimedia/windows/qwindowsaudiodevice_p.h b/src/multimedia/windows/qwindowsaudiodevice_p.h
index c62f7eebc..b981a0ed6 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, QWindowsIUPointer<IMMDevice> immdev, int waveID, const QString &description, QAudioDevice::Mode mode);
+    QWindowsAudioDeviceInfo(QByteArray dev, QComPtr<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; }
-    QWindowsIUPointer<IMMDevice> immDev() const { return m_immDev; }
+    QComPtr<IMMDevice> immDev() const { return m_immDev; }
 
 private:
     quint32 m_devId;
-    QWindowsIUPointer<IMMDevice> m_immDev;
+    QComPtr<IMMDevice> m_immDev;
 };
 
 
diff --git a/src/multimedia/windows/qwindowsaudiosink.cpp b/src/multimedia/windows/qwindowsaudiosink.cpp
index f0a58ccda..30bf054f1 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(QWindowsIUPointer<IMMDevice> device, QObject *parent) :
+QWindowsAudioSink::QWindowsAudioSink(QComPtr<IMMDevice> device, QObject *parent) :
     QPlatformAudioSink(parent),
     m_timer(new QTimer(this)),
     m_pushSource(new OutputPrivate(*this)),
diff --git a/src/multimedia/windows/qwindowsaudiosink_p.h b/src/multimedia/windows/qwindowsaudiosink_p.h
index 48b948004..c1ca2e81c 100644
--- a/src/multimedia/windows/qwindowsaudiosink_p.h
+++ b/src/multimedia/windows/qwindowsaudiosink_p.h
@@ -41,7 +41,7 @@ class QWindowsAudioSink : public QPlatformAudioSink
 {
     Q_OBJECT
 public:
-    QWindowsAudioSink(QWindowsIUPointer<IMMDevice> device, QObject *parent);
+    QWindowsAudioSink(QComPtr<IMMDevice> device, QObject *parent);
     ~QWindowsAudioSink();
 
     void setFormat(const QAudioFormat& fmt) override;
@@ -84,9 +84,9 @@ private:
     QTimer *m_timer = nullptr;
     QScopedPointer<QIODevice> m_pushSource;
     QIODevice *m_pullSource = nullptr;
-    QWindowsIUPointer<IMMDevice> m_device;
-    QWindowsIUPointer<IAudioClient> m_audioClient;
-    QWindowsIUPointer<IAudioRenderClient> m_renderClient;
+    QComPtr<IMMDevice> m_device;
+    QComPtr<IAudioClient> m_audioClient;
+    QComPtr<IAudioRenderClient> m_renderClient;
     QWindowsResampler m_resampler;
 };
 
diff --git a/src/multimedia/windows/qwindowsaudiosource.cpp b/src/multimedia/windows/qwindowsaudiosource.cpp
index b5680f9ca..fa7a48705 100644
--- a/src/multimedia/windows/qwindowsaudiosource.cpp
+++ b/src/multimedia/windows/qwindowsaudiosource.cpp
@@ -45,7 +45,7 @@ private:
     QWindowsAudioSource &m_audioSource;
 };
 
-QWindowsAudioSource::QWindowsAudioSource(QWindowsIUPointer<IMMDevice> device, QObject *parent)
+QWindowsAudioSource::QWindowsAudioSource(QComPtr<IMMDevice> device, QObject *parent)
     : QPlatformAudioSource(parent),
       m_timer(new QTimer(this)),
       m_device(std::move(device)),
diff --git a/src/multimedia/windows/qwindowsaudiosource_p.h b/src/multimedia/windows/qwindowsaudiosource_p.h
index 6b7d41db1..56355d525 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(QWindowsIUPointer<IMMDevice> device, QObject *parent);
+    QWindowsAudioSource(QComPtr<IMMDevice> device, QObject *parent);
     ~QWindowsAudioSource();
 
     qint64 read(char* data, qint64 len);
@@ -72,9 +72,9 @@ private:
     QByteArray readCaptureClientBuffer();
 
     QTimer *m_timer = nullptr;
-    QWindowsIUPointer<IMMDevice> m_device;
-    QWindowsIUPointer<IAudioClient> m_audioClient;
-    QWindowsIUPointer<IAudioCaptureClient> m_captureClient;
+    QComPtr<IMMDevice> m_device;
+    QComPtr<IAudioClient> m_audioClient;
+    QComPtr<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 ff2713f6b..fb9c8671e 100644
--- a/src/multimedia/windows/qwindowsaudioutils.cpp
+++ b/src/multimedia/windows/qwindowsaudioutils.cpp
@@ -157,9 +157,9 @@ QAudioFormat QWindowsAudioUtils::mediaTypeToFormat(IMFMediaType *mediaType)
     return format;
 }
 
-QWindowsIUPointer<IMFMediaType> QWindowsAudioUtils::formatToMediaType(QWindowsMediaFoundation &wmf, const QAudioFormat &format)
+QComPtr<IMFMediaType> QWindowsAudioUtils::formatToMediaType(QWindowsMediaFoundation &wmf, const QAudioFormat &format)
 {
-    QWindowsIUPointer<IMFMediaType> mediaType;
+    QComPtr<IMFMediaType> mediaType;
 
     if (!format.isValid())
         return mediaType;
diff --git a/src/multimedia/windows/qwindowsaudioutils_p.h b/src/multimedia/windows/qwindowsaudioutils_p.h
index 3ae957e35..5254ef704 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);
-    QWindowsIUPointer<IMFMediaType> formatToMediaType(QWindowsMediaFoundation &, const QAudioFormat &format);
+    QComPtr<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/qwindowsiupointer_p.h b/src/multimedia/windows/qwindowsiupointer_p.h
index 0cf73660b..1fff76e2c 100644
--- a/src/multimedia/windows/qwindowsiupointer_p.h
+++ b/src/multimedia/windows/qwindowsiupointer_p.h
@@ -16,16 +16,16 @@
 //
 
 template <class T>
-class QWindowsIUPointer
+class QComPtr
 {
 public:
-    explicit QWindowsIUPointer(T *ptr) : m_ptr(ptr) {}
-    QWindowsIUPointer() : m_ptr(nullptr) {}
-    QWindowsIUPointer(const QWindowsIUPointer<T> &uiPtr) : m_ptr(uiPtr.m_ptr) { if (m_ptr) m_ptr->AddRef(); }
-    QWindowsIUPointer(QWindowsIUPointer<T> &&uiPtr) : m_ptr(uiPtr.m_ptr) { uiPtr.m_ptr = nullptr; }
-    ~QWindowsIUPointer() { if (m_ptr) m_ptr->Release(); }
+    explicit QComPtr(T *ptr) : m_ptr(ptr) {}
+    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(); }
 
-    QWindowsIUPointer& operator=(const QWindowsIUPointer<T> &rhs) {
+    QComPtr& operator=(const QComPtr<T> &rhs) {
         if (this != &rhs) {
             if (m_ptr)
                 m_ptr->Release();
@@ -35,7 +35,7 @@ public:
         return *this;
     }
 
-    QWindowsIUPointer& operator=(QWindowsIUPointer<T> &&rhs) noexcept {
+    QComPtr& operator=(QComPtr<T> &&rhs) noexcept {
         if (m_ptr)
             m_ptr->Release();
         m_ptr = rhs.m_ptr;
diff --git a/src/multimedia/windows/qwindowsmediadevices.cpp b/src/multimedia/windows/qwindowsmediadevices.cpp
index c1135f0cb..9dd2db383 100644
--- a/src/multimedia/windows/qwindowsmediadevices.cpp
+++ b/src/multimedia/windows/qwindowsmediadevices.cpp
@@ -24,13 +24,13 @@ QT_BEGIN_NAMESPACE
 class CMMNotificationClient : public IMMNotificationClient
 {
     LONG m_cRef;
-    QWindowsIUPointer<IMMDeviceEnumerator> m_enumerator;
+    QComPtr<IMMDeviceEnumerator> m_enumerator;
     QWindowsMediaDevices *m_windowsMediaDevices;
     QMap<QString, DWORD> m_deviceState;
 
 public:
     CMMNotificationClient(QWindowsMediaDevices *windowsMediaDevices,
-                          QWindowsIUPointer<IMMDeviceEnumerator> enumerator,
+                          QComPtr<IMMDeviceEnumerator> enumerator,
                           QMap<QString, DWORD> &&deviceState) :
         m_cRef(1),
         m_enumerator(enumerator),
@@ -132,8 +132,8 @@ public:
 
     void emitAudioDevicesChanged(LPCWSTR deviceID)
     {
-        QWindowsIUPointer<IMMDevice> device;
-        QWindowsIUPointer<IMMEndpoint> endpoint;
+        QComPtr<IMMDevice> device;
+        QComPtr<IMMEndpoint> endpoint;
         EDataFlow flow;
 
         if (SUCCEEDED(m_enumerator->GetDevice(deviceID, device.address()))
@@ -156,14 +156,14 @@ QWindowsMediaDevices::QWindowsMediaDevices()
 
     if (SUCCEEDED(hr)) {
         QMap<QString, DWORD> devState;
-        QWindowsIUPointer<IMMDeviceCollection> devColl;
+        QComPtr<IMMDeviceCollection> devColl;
         UINT count = 0;
 
         if (SUCCEEDED(m_deviceEnumerator->EnumAudioEndpoints(EDataFlow::eAll, DEVICE_STATEMASK_ALL, devColl.address()))
             && SUCCEEDED(devColl->GetCount(&count)))
         {
             for (UINT i = 0; i < count; i++) {
-                QWindowsIUPointer<IMMDevice> device;
+                QComPtr<IMMDevice> device;
                 DWORD state = 0;
                 LPWSTR id = nullptr;
 
@@ -204,7 +204,7 @@ QList<QAudioDevice> QWindowsMediaDevices::availableDevices(QAudioDevice::Mode mo
 
     const auto defaultAudioDeviceID = [this, audioOut]{
         const auto dataFlow = audioOut ? EDataFlow::eRender : EDataFlow::eCapture;
-        QWindowsIUPointer<IMMDevice> dev;
+        QComPtr<IMMDevice> dev;
         LPWSTR id = nullptr;
         QString sid;
 
@@ -236,8 +236,8 @@ QList<QAudioDevice> QWindowsMediaDevices::availableDevices(QAudioDevice::Mode mo
         if (waveMessage(DRV_QUERYFUNCTIONINSTANCEID, id.data(), len) != MMSYSERR_NOERROR)
             continue;
 
-        QWindowsIUPointer<IMMDevice> device;
-        QWindowsIUPointer<IPropertyStore> props;
+        QComPtr<IMMDevice> device;
+        QComPtr<IPropertyStore> props;
         if (FAILED(m_deviceEnumerator->GetDevice(id.data(), device.address()))
             || FAILED(device->OpenPropertyStore(STGM_READ, props.address()))) {
             continue;
diff --git a/src/multimedia/windows/qwindowsmediadevices_p.h b/src/multimedia/windows/qwindowsmediadevices_p.h
index f32577535..154f29c6e 100644
--- a/src/multimedia/windows/qwindowsmediadevices_p.h
+++ b/src/multimedia/windows/qwindowsmediadevices_p.h
@@ -43,8 +43,8 @@ public:
 private:
     QList<QAudioDevice> availableDevices(QAudioDevice::Mode mode) const;
 
-    QWindowsIUPointer<IMMDeviceEnumerator> m_deviceEnumerator;
-    QWindowsIUPointer<CMMNotificationClient> m_notificationClient;
+    QComPtr<IMMDeviceEnumerator> m_deviceEnumerator;
+    QComPtr<CMMNotificationClient> m_notificationClient;
 
     friend CMMNotificationClient;
 };
diff --git a/src/multimedia/windows/qwindowsresampler.cpp b/src/multimedia/windows/qwindowsresampler.cpp
index b4b36d5ee..b1922cfec 100644
--- a/src/multimedia/windows/qwindowsresampler.cpp
+++ b/src/multimedia/windows/qwindowsresampler.cpp
@@ -54,12 +54,12 @@ quint64 QWindowsResampler::inputBufferSize(quint64 outputBufferSize) const
 
 HRESULT QWindowsResampler::processInput(const QByteArrayView &in)
 {
-    QWindowsIUPointer<IMFSample> sample;
+    QComPtr<IMFSample> sample;
     HRESULT hr = m_wmf->mfCreateSample(sample.address());
     if (FAILED(hr))
         return hr;
 
-    QWindowsIUPointer<IMFMediaBuffer> buffer;
+    QComPtr<IMFMediaBuffer> buffer;
     hr = m_wmf->mfCreateMemoryBuffer(in.size(), buffer.address());
     if (FAILED(hr))
         return hr;
@@ -90,8 +90,8 @@ HRESULT QWindowsResampler::processInput(const QByteArrayView &in)
 
 HRESULT QWindowsResampler::processOutput(QByteArray &out)
 {
-    QWindowsIUPointer<IMFSample> sample;
-    QWindowsIUPointer<IMFMediaBuffer> buffer;
+    QComPtr<IMFSample> sample;
+    QComPtr<IMFMediaBuffer> buffer;
 
     if (m_resamplerNeedsSampleBuffer) {
         HRESULT hr = m_wmf->mfCreateSample(sample.address());
@@ -119,7 +119,7 @@ HRESULT QWindowsResampler::processOutput(QByteArray &out)
         DWORD status = 0;
         hr = m_resampler->ProcessOutput(0, 1, &outputDataBuffer, &status);
         if (SUCCEEDED(hr)) {
-            QWindowsIUPointer<IMFMediaBuffer> outputBuffer;
+            QComPtr<IMFMediaBuffer> outputBuffer;
             outputDataBuffer.pSample->ConvertToContiguousBuffer(outputBuffer.address());
             DWORD len = 0;
             BYTE *data = nullptr;
@@ -174,7 +174,7 @@ QByteArray QWindowsResampler::resample(IMFSample *sample)
     QByteArray out;
 
     if (m_inputFormat == m_outputFormat) {
-        QWindowsIUPointer<IMFMediaBuffer> outputBuffer;
+        QComPtr<IMFMediaBuffer> outputBuffer;
         sample->ConvertToContiguousBuffer(outputBuffer.address());
         DWORD len = 0;
         BYTE *data = nullptr;
@@ -216,8 +216,8 @@ bool QWindowsResampler::setup(const QAudioFormat &fin, const QAudioFormat &fout)
     if (!m_resampler || !m_wmf)
         return false;
 
-    QWindowsIUPointer<IMFMediaType> min = QWindowsAudioUtils::formatToMediaType(*m_wmf, fin);
-    QWindowsIUPointer<IMFMediaType> mout = QWindowsAudioUtils::formatToMediaType(*m_wmf, fout);
+    QComPtr<IMFMediaType> min = QWindowsAudioUtils::formatToMediaType(*m_wmf, fin);
+    QComPtr<IMFMediaType> mout = QWindowsAudioUtils::formatToMediaType(*m_wmf, fout);
 
     HRESULT hr = m_resampler->SetInputType(m_inputStreamID, min.get(), 0);
     if (FAILED(hr)) {
diff --git a/src/multimedia/windows/qwindowsresampler_p.h b/src/multimedia/windows/qwindowsresampler_p.h
index 3b2e72d00..a59cc5f2e 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);
 
-    QWindowsIUPointer<IMFTransform> m_resampler;
+    QComPtr<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 c6f28543a..99180e5a6 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_d3d11.cpp
@@ -27,7 +27,7 @@ namespace QFFmpeg {
 class D3D11TextureSet : public TextureSet
 {
 public:
-    D3D11TextureSet(QWindowsIUPointer<ID3D11Texture2D> &&tex)
+    D3D11TextureSet(QComPtr<ID3D11Texture2D> &&tex)
         : m_tex(tex)
     {}
 
@@ -37,7 +37,7 @@ public:
     }
 
 private:
-    QWindowsIUPointer<ID3D11Texture2D> m_tex;
+    QComPtr<ID3D11Texture2D> m_tex;
 };
 
 
@@ -46,9 +46,9 @@ D3D11TextureConverter::D3D11TextureConverter(QRhi *rhi)
 {
 }
 
-static QWindowsIUPointer<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device *dev, ID3D11Texture2D *tex)
+static QComPtr<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device *dev, ID3D11Texture2D *tex)
 {
-    QWindowsIUPointer<IDXGIResource> dxgiResource;
+    QComPtr<IDXGIResource> dxgiResource;
     HRESULT hr = tex->QueryInterface(__uuidof(IDXGIResource), reinterpret_cast<void **>(dxgiResource.address()));
     if (FAILED(hr)) {
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to obtain resource handle from FFMpeg texture" << hr;
@@ -61,14 +61,14 @@ static QWindowsIUPointer<ID3D11Texture2D> getSharedTextureForDevice(ID3D11Device
         return {};
     }
 
-    QWindowsIUPointer<ID3D11Texture2D> sharedTex;
+    QComPtr<ID3D11Texture2D> sharedTex;
     hr = dev->OpenSharedResource(shared, __uuidof(ID3D11Texture2D), reinterpret_cast<void **>(sharedTex.address()));
     if (FAILED(hr))
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to share FFmpeg texture" << hr;
     return sharedTex;
 }
 
-static QWindowsIUPointer<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev, ID3D11Texture2D *array, int index)
+static QComPtr<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev, ID3D11Texture2D *array, int index)
 {
     D3D11_TEXTURE2D_DESC arrayDesc = {};
     array->GetDesc(&arrayDesc);
@@ -83,14 +83,14 @@ static QWindowsIUPointer<ID3D11Texture2D> copyTextureFromArray(ID3D11Device *dev
     texDesc.MiscFlags = 0;
     texDesc.SampleDesc = { 1, 0};
 
-    QWindowsIUPointer<ID3D11Texture2D> texCopy;
+    QComPtr<ID3D11Texture2D> texCopy;
     HRESULT hr = dev->CreateTexture2D(&texDesc, nullptr, texCopy.address());
     if (FAILED(hr)) {
         qCDebug(qLcMediaFFmpegHWAccel) << "Failed to create texture" << hr;
         return {};
     }
 
-    QWindowsIUPointer<ID3D11DeviceContext> ctx;
+    QComPtr<ID3D11DeviceContext> ctx;
     dev->GetImmediateContext(ctx.address());
     ctx->CopySubresourceRegion(texCopy.get(), 0, 0, 0, 0, array, index, nullptr);
 
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp b/src/plugins/multimedia/ffmpeg/qffmpegscreencapture_dxgi.cpp
index 040509bb1..16730ca06 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(QWindowsIUPointer<ID3D11Device> &device, std::shared_ptr<QMutex> &mutex,
-                             QWindowsIUPointer<ID3D11Texture2D> &texture, QSize size)
+    QD3D11TextureVideoBuffer(QComPtr<ID3D11Device> &device, std::shared_ptr<QMutex> &mutex,
+                             QComPtr<ID3D11Texture2D> &texture, QSize size)
         : QAbstractVideoBuffer(QVideoFrame::NoHandle)
         , m_device(device)
         , m_texture(texture)
@@ -108,25 +108,25 @@ public:
     }
 
 private:
-    QWindowsIUPointer<ID3D11Device> m_device;
-    QWindowsIUPointer<ID3D11Texture2D> m_texture;
-    QWindowsIUPointer<ID3D11Texture2D> m_cpuTexture;
-    QWindowsIUPointer<ID3D11DeviceContext> m_ctx;
+    QComPtr<ID3D11Device> m_device;
+    QComPtr<ID3D11Texture2D> m_texture;
+    QComPtr<ID3D11Texture2D> m_cpuTexture;
+    QComPtr<ID3D11DeviceContext> m_ctx;
     std::shared_ptr<QMutex> m_ctxMutex;
     QSize m_size;
     QVideoFrame::MapMode m_mapMode = QVideoFrame::NotMapped;
 };
 
-static QMaybe<QWindowsIUPointer<ID3D11Texture2D>> getNextFrame(ID3D11Device *dev, IDXGIOutputDuplication *dup)
+static QMaybe<QComPtr<ID3D11Texture2D>> getNextFrame(ID3D11Device *dev, IDXGIOutputDuplication *dup)
 {
-    QWindowsIUPointer<IDXGIResource> frame;
+    QComPtr<IDXGIResource> frame;
     DXGI_OUTDUPL_FRAME_INFO info;
     HRESULT hr = dup->AcquireNextFrame(0, &info, frame.address());
     if (FAILED(hr))
         return hr == DXGI_ERROR_WAIT_TIMEOUT ? QString{}
                                              : "Failed to grab the screen content" + errorString(hr);
 
-    QWindowsIUPointer<ID3D11Texture2D> tex;
+    QComPtr<ID3D11Texture2D> tex;
     hr = frame->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void **>(tex.address()));
     if (FAILED(hr)) {
         dup->ReleaseFrame();
@@ -137,14 +137,14 @@ static QMaybe<QWindowsIUPointer<ID3D11Texture2D>> getNextFrame(ID3D11Device *dev
     tex->GetDesc(&texDesc);
     texDesc.MiscFlags = 0;
     texDesc.BindFlags = 0;
-    QWindowsIUPointer<ID3D11Texture2D> texCopy;
+    QComPtr<ID3D11Texture2D> texCopy;
     hr = dev->CreateTexture2D(&texDesc, nullptr, texCopy.address());
     if (FAILED(hr)) {
         dup->ReleaseFrame();
         return "Failed to create texture with CPU access" + errorString(hr);
     }
 
-    QWindowsIUPointer<ID3D11DeviceContext> ctx;
+    QComPtr<ID3D11DeviceContext> ctx;
     dev->GetImmediateContext(ctx.address());
     ctx->CopyResource(texCopy.get(), tex.get());
 
@@ -156,8 +156,8 @@ static QMaybe<QWindowsIUPointer<ID3D11Texture2D>> getNextFrame(ID3D11Device *dev
 class QFFmpegScreenCaptureDxgi::Grabber : public QFFmpegScreenCaptureThread
 {
 public:
-    Grabber(QFFmpegScreenCaptureDxgi &screenCapture, QScreen *screen, QWindowsIUPointer<ID3D11Device> &device,
-            QWindowsIUPointer<IDXGIOutputDuplication> &duplication)
+    Grabber(QFFmpegScreenCaptureDxgi &screenCapture, QScreen *screen, QComPtr<ID3D11Device> &device,
+            QComPtr<IDXGIOutputDuplication> &duplication)
         : QFFmpegScreenCaptureThread()
         , m_duplication(duplication)
         , m_device(device)
@@ -213,8 +213,8 @@ public:
     };
 
 private:
-    QWindowsIUPointer<IDXGIOutputDuplication> m_duplication;
-    QWindowsIUPointer<ID3D11Device> m_device;
+    QComPtr<IDXGIOutputDuplication> m_duplication;
+    QComPtr<ID3D11Device> m_device;
     QWaitCondition m_waitForFormat;
     QVideoFrameFormat m_format;
     QMutex m_formatMutex;
@@ -222,14 +222,14 @@ private:
     QSize m_frameSize;
 };
 
-static QMaybe<QWindowsIUPointer<IDXGIOutputDuplication>> duplicateOutput(ID3D11Device* device, IDXGIOutput *output)
+static QMaybe<QComPtr<IDXGIOutputDuplication>> duplicateOutput(ID3D11Device* device, IDXGIOutput *output)
 {
-    QWindowsIUPointer<IDXGIOutput1> output1;
+    QComPtr<IDXGIOutput1> output1;
     HRESULT hr = output->QueryInterface(__uuidof(IDXGIOutput1), reinterpret_cast<void**>(output1.address()));
     if (FAILED(hr))
         return  { "Failed to create IDXGIOutput1" + QString(std::system_category().message(hr).c_str()) };
 
-    QWindowsIUPointer<IDXGIOutputDuplication> dup;
+    QComPtr<IDXGIOutputDuplication> dup;
     hr = output1->DuplicateOutput(device, dup.address());
     if (SUCCEEDED(hr))
         return dup;
@@ -238,8 +238,8 @@ static QMaybe<QWindowsIUPointer<IDXGIOutputDuplication>> duplicateOutput(ID3D11D
 }
 
 struct DxgiScreen {
-    QWindowsIUPointer<IDXGIAdapter1> adapter;
-    QWindowsIUPointer<IDXGIOutput> output;
+    QComPtr<IDXGIAdapter1> adapter;
+    QComPtr<IDXGIOutput> output;
 };
 
 static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
@@ -250,14 +250,14 @@ static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
     auto *winScreen = screen->nativeInterface<QNativeInterface::Private::QWindowsScreen>();
     HMONITOR handle = winScreen ? winScreen->handle() : nullptr;
 
-    QWindowsIUPointer<IDXGIFactory1> factory;
+    QComPtr<IDXGIFactory1> factory;
     HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(factory.address()));
     if (FAILED(hr))
         return "Failed to create IDXGIFactory" + errorString(hr);
 
-    QWindowsIUPointer<IDXGIAdapter1> adapter;
+    QComPtr<IDXGIAdapter1> adapter;
     for (quint32 i = 0; SUCCEEDED(factory->EnumAdapters1(i, adapter.address())); i++, adapter.reset()) {
-        QWindowsIUPointer<IDXGIOutput> output;
+        QComPtr<IDXGIOutput> output;
         for (quint32 j = 0; SUCCEEDED(adapter->EnumOutputs(j, output.address())); j++, output.reset()) {
             DXGI_OUTPUT_DESC desc = {};
             output->GetDesc(&desc);
@@ -271,9 +271,9 @@ static QMaybe<DxgiScreen> findDxgiScreen(const QScreen *screen)
     return "Could not find screen adapter" + screen->name();
 }
 
-static QMaybe<QWindowsIUPointer<ID3D11Device>> createD3D11Device(IDXGIAdapter1 *adapter)
+static QMaybe<QComPtr<ID3D11Device>> createD3D11Device(IDXGIAdapter1 *adapter)
 {
-    QWindowsIUPointer<ID3D11Device> d3d11dev;
+    QComPtr<ID3D11Device> d3d11dev;
     HRESULT hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
                                    0, nullptr, 0, D3D11_SDK_VERSION,
                                    d3d11dev.address(), nullptr, nullptr);
diff --git a/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp b/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
index 4a4e7a921..7a644b88c 100644
--- a/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
+++ b/src/plugins/multimedia/ffmpeg/qwindowscamera.cpp
@@ -73,11 +73,11 @@ private:
     QMutex m_mutex;
 };
 
-static QWindowsIUPointer<IMFSourceReader> createCameraReader(IMFMediaSource *mediaSource,
-                                                             const QWindowsIUPointer<CameraReaderCallback> &callback)
+static QComPtr<IMFSourceReader> createCameraReader(IMFMediaSource *mediaSource,
+                                                             const QComPtr<CameraReaderCallback> &callback)
 {
-    QWindowsIUPointer<IMFSourceReader> sourceReader;
-    QWindowsIUPointer<IMFAttributes> readerAttributes;
+    QComPtr<IMFSourceReader> sourceReader;
+    QComPtr<IMFAttributes> readerAttributes;
 
     HRESULT hr = MFCreateAttributes(readerAttributes.address(), 1);
     if (SUCCEEDED(hr)) {
@@ -93,10 +93,10 @@ static QWindowsIUPointer<IMFSourceReader> createCameraReader(IMFMediaSource *med
     return sourceReader;
 }
 
-static QWindowsIUPointer<IMFMediaSource> createCameraSource(const QString &deviceId)
+static QComPtr<IMFMediaSource> createCameraSource(const QString &deviceId)
 {
-    QWindowsIUPointer<IMFMediaSource> mediaSource;
-    QWindowsIUPointer<IMFAttributes> sourceAttributes;
+    QComPtr<IMFMediaSource> mediaSource;
+    QComPtr<IMFAttributes> sourceAttributes;
     HRESULT hr = MFCreateAttributes(sourceAttributes.address(), 2);
     if (SUCCEEDED(hr)) {
         hr = sourceAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, QMM_MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
@@ -144,11 +144,11 @@ static bool setCameraReaderFormat(IMFSourceReader *sourceReader, IMFMediaType *v
     return SUCCEEDED(hr);
 }
 
-static QWindowsIUPointer<IMFMediaType> findVideoType(IMFSourceReader *reader,
+static QComPtr<IMFMediaType> findVideoType(IMFSourceReader *reader,
                                                      const QCameraFormat &format)
 {
     for (DWORD i = 0;; ++i) {
-        QWindowsIUPointer<IMFMediaType> candidate;
+        QComPtr<IMFMediaType> candidate;
         HRESULT hr = reader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, i,
                                                 candidate.address());
         if (FAILED(hr))
@@ -185,7 +185,7 @@ public:
         if (!ac->m_source)
             return {};
 
-        ac->m_readerCallback = QWindowsIUPointer<CameraReaderCallback>(new CameraReaderCallback);
+        ac->m_readerCallback = QComPtr<CameraReaderCallback>(new CameraReaderCallback);
         ac->m_readerCallback->setActiveCamera(ac.get());
         ac->m_reader = createCameraReader(ac->m_source.get(), ac->m_readerCallback);
         if (!ac->m_reader)
@@ -224,7 +224,7 @@ public:
         }
 
         if (sample) {
-            QWindowsIUPointer<IMFMediaBuffer> mediaBuffer;
+            QComPtr<IMFMediaBuffer> mediaBuffer;
             if (SUCCEEDED(sample->ConvertToContiguousBuffer(mediaBuffer.address()))) {
 
                 DWORD bufLen = 0;
@@ -269,9 +269,9 @@ private:
 
     QSemaphore m_flushWait;
 
-    QWindowsIUPointer<IMFMediaSource> m_source;
-    QWindowsIUPointer<IMFSourceReader> m_reader;
-    QWindowsIUPointer<CameraReaderCallback> m_readerCallback;
+    QComPtr<IMFMediaSource> m_source;
+    QComPtr<IMFSourceReader> m_reader;
+    QComPtr<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 948151916..1f8c01280 100644
--- a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp
+++ b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol.cpp
@@ -101,7 +101,7 @@ void MFAudioDecoderControl::startReadingSource(IMFMediaSource *source)
         return;
     }
 
-    QWindowsIUPointer<IMFPresentationDescriptor> pd;
+    QComPtr<IMFPresentationDescriptor> pd;
     if (SUCCEEDED(source->CreatePresentationDescriptor(pd.address()))) {
         UINT64 duration = 0;
         pd->GetUINT64(MF_PD_DURATION, &duration);
@@ -173,7 +173,7 @@ void MFAudioDecoderControl::stop()
     }
 }
 
-void MFAudioDecoderControl::handleNewSample(QWindowsIUPointer<IMFSample> sample)
+void MFAudioDecoderControl::handleNewSample(QComPtr<IMFSample> sample)
 {
     Q_ASSERT(sample);
 
diff --git a/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h b/src/plugins/multimedia/windows/decoder/mfaudiodecodercontrol_p.h
index 41957f448..3e3a405a3 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(QWindowsIUPointer<IMFSample>);
+    void handleNewSample(QComPtr<IMFSample>);
     void handleSourceFinished();
 
 private:
     void startReadingSource(IMFMediaSource *source);
 
-    QWindowsIUPointer<MFDecoderSourceReader>  m_decoderSourceReader;
+    QComPtr<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 017f3926a..9c69fbd25 100644
--- a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp
+++ b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader.cpp
@@ -9,15 +9,15 @@
 
 QT_BEGIN_NAMESPACE
 
-QWindowsIUPointer<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource *source, QAudioFormat::SampleFormat sampleFormat)
+QComPtr<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource *source, QAudioFormat::SampleFormat sampleFormat)
 {
-    QWindowsIUPointer<IMFMediaType> mediaType;
+    QComPtr<IMFMediaType> mediaType;
     m_sourceReader.reset();
 
     if (!source)
         return mediaType;
 
-    QWindowsIUPointer<IMFAttributes> attr;
+    QComPtr<IMFAttributes> attr;
     MFCreateAttributes(attr.address(), 1);
     if (FAILED(attr->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this)))
         return mediaType;
@@ -34,7 +34,7 @@ QWindowsIUPointer<IMFMediaType> MFDecoderSourceReader::setSource(IMFMediaSource
     m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_ALL_STREAMS), FALSE);
     m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE);
 
-    QWindowsIUPointer<IMFMediaType> pPartialType;
+    QComPtr<IMFMediaType> pPartialType;
     MFCreateMediaType(pPartialType.address());
     pPartialType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
     pPartialType->SetGUID(MF_MT_SUBTYPE, sampleFormat == QAudioFormat::Float ? MFAudioFormat_Float : MFAudioFormat_PCM);
@@ -92,7 +92,7 @@ STDMETHODIMP MFDecoderSourceReader::OnReadSample(HRESULT hrStatus, DWORD dwStrea
     Q_UNUSED(llTimestamp);
     if (pSample) {
         pSample->AddRef();
-        emit newSample(QWindowsIUPointer{pSample});
+        emit newSample(QComPtr{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 584446ba1..d964ff482 100644
--- a/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h
+++ b/src/plugins/multimedia/windows/decoder/mfdecodersourcereader_p.h
@@ -33,7 +33,7 @@ public:
     ~MFDecoderSourceReader() override {}
 
     void clearSource() { m_sourceReader.reset(); }
-    QWindowsIUPointer<IMFMediaType> setSource(IMFMediaSource *source, QAudioFormat::SampleFormat);
+    QComPtr<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(QWindowsIUPointer<IMFSample>);
+    void newSample(QComPtr<IMFSample>);
     void finished();
 
 private:
     long m_cRef = 1;
-    QWindowsIUPointer<IMFSourceReader> m_sourceReader;
+    QComPtr<IMFSourceReader> m_sourceReader;
 
 };
 
diff --git a/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp b/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
index 742608f0f..bb6d0390f 100644
--- a/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
+++ b/src/plugins/multimedia/windows/evr/evrcustompresenter.cpp
@@ -1898,7 +1898,7 @@ void EVRCustomPresenter::presentSample(IMFSample *sample)
             frame.setEndTime(frame.endTime() + m_positionOffset);
     }
 
-    QWindowsIUPointer<IMFMediaType> inputStreamType;
+    QComPtr<IMFMediaType> inputStreamType;
     if (SUCCEEDED(m_mixer->GetInputCurrentType(0, inputStreamType.address()))) {
         auto rotation = static_cast<MFVideoRotationFormat>(MFGetAttributeUINT32(inputStreamType.get(), MF_MT_VIDEO_ROTATION, 0));
         switch (rotation) {
diff --git a/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp b/src/plugins/multimedia/windows/evr/evrd3dpresentengine.cpp
index 2768c3ac7..7fab5b8cd 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(QWindowsIUPointer<IDirect3DDevice9Ex> device,
+    IMFSampleVideoBuffer(QComPtr<IDirect3DDevice9Ex> device,
                           IMFSample *sample, QRhi *rhi, QVideoFrame::HandleType type = QVideoFrame::NoHandle)
         : QAbstractVideoBuffer(type, rhi)
         , m_device(device)
@@ -59,12 +59,12 @@ public:
                 return {};
 
         } else {
-            QWindowsIUPointer<IMFMediaBuffer> buffer;
+            QComPtr<IMFMediaBuffer> buffer;
             HRESULT hr = m_sample->GetBufferByIndex(0, buffer.address());
             if (FAILED(hr))
                 return {};
 
-            QWindowsIUPointer<IDirect3DSurface9> surface;
+            QComPtr<IDirect3DSurface9> surface;
             hr = MFGetService(buffer.get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9, (void **)(surface.address()));
             if (FAILED(hr))
                 return {};
@@ -106,18 +106,18 @@ public:
     }
 
 protected:
-    QWindowsIUPointer<IDirect3DDevice9Ex> m_device;
-    QWindowsIUPointer<IMFSample> m_sample;
+    QComPtr<IDirect3DDevice9Ex> m_device;
+    QComPtr<IMFSample> m_sample;
 
 private:
-    QWindowsIUPointer<IDirect3DSurface9> m_memSurface;
+    QComPtr<IDirect3DSurface9> m_memSurface;
     QVideoFrame::MapMode m_mapMode;
 };
 
 class QVideoFrameD3D11Textures: public QVideoFrameTextures
 {
 public:
-    QVideoFrameD3D11Textures(std::unique_ptr<QRhiTexture> &&tex, QWindowsIUPointer<ID3D11Texture2D> &&d3d11tex)
+    QVideoFrameD3D11Textures(std::unique_ptr<QRhiTexture> &&tex, QComPtr<ID3D11Texture2D> &&d3d11tex)
        : m_tex(std::move(tex))
        , m_d3d11tex(std::move(d3d11tex))
     {}
@@ -129,13 +129,13 @@ public:
 
 private:
     std::unique_ptr<QRhiTexture> m_tex;
-    QWindowsIUPointer<ID3D11Texture2D> m_d3d11tex;
+    QComPtr<ID3D11Texture2D> m_d3d11tex;
 };
 
 class D3D11TextureVideoBuffer: public IMFSampleVideoBuffer
 {
 public:
-    D3D11TextureVideoBuffer(QWindowsIUPointer<IDirect3DDevice9Ex> device, IMFSample *sample,
+    D3D11TextureVideoBuffer(QComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
                             HANDLE sharedHandle, QRhi *rhi)
         : IMFSampleVideoBuffer(std::move(device), sample, rhi, QVideoFrame::RhiTextureHandle)
         , m_sharedHandle(sharedHandle)
@@ -154,7 +154,7 @@ public:
         if (!dev)
             return {};
 
-        QWindowsIUPointer<ID3D11Texture2D> d3d11tex;
+        QComPtr<ID3D11Texture2D> d3d11tex;
         HRESULT hr = dev->OpenSharedResource(m_sharedHandle, __uuidof(ID3D11Texture2D), (void**)(d3d11tex.address()));
         if (SUCCEEDED(hr)) {
             D3D11_TEXTURE2D_DESC desc = {};
@@ -288,7 +288,7 @@ private:
 class OpenGlVideoBuffer: public IMFSampleVideoBuffer
 {
 public:
-    OpenGlVideoBuffer(QWindowsIUPointer<IDirect3DDevice9Ex> device, IMFSample *sample,
+    OpenGlVideoBuffer(QComPtr<IDirect3DDevice9Ex> device, IMFSample *sample,
                       const WglNvDxInterop &wglNvDxInterop, HANDLE sharedHandle, QRhi *rhi)
         : IMFSampleVideoBuffer(std::move(device), sample, rhi, QVideoFrame::RhiTextureHandle)
         , m_sharedHandle(sharedHandle)
@@ -298,12 +298,12 @@ public:
     std::unique_ptr<QVideoFrameTextures> mapTextures(QRhi *rhi) override
     {
         if (!m_texture) {
-            QWindowsIUPointer<IMFMediaBuffer> buffer;
+            QComPtr<IMFMediaBuffer> buffer;
             HRESULT hr = m_sample->GetBufferByIndex(0, buffer.address());
             if (FAILED(hr))
                 return {};
 
-            QWindowsIUPointer<IDirect3DSurface9> surface;
+            QComPtr<IDirect3DSurface9> surface;
             hr = MFGetService(buffer.get(), MR_BUFFER_SERVICE, IID_IDirect3DSurface9,
                               (void **)(surface.address()));
             if (FAILED(hr))
@@ -320,7 +320,7 @@ public:
 private:
     HANDLE m_sharedHandle = nullptr;
     WglNvDxInterop m_wgl;
-    QWindowsIUPointer<IDirect3DTexture9> m_texture;
+    QComPtr<IDirect3DTexture9> m_texture;
 };
 #endif
 
@@ -482,7 +482,7 @@ HRESULT D3DPresentEngine::createD3DDevice()
     pp.Flags = D3DPRESENTFLAG_VIDEO;
     pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
 
-    QWindowsIUPointer<IDirect3DDevice9Ex> device;
+    QComPtr<IDirect3DDevice9Ex> device;
 
     hr = m_D3D9->CreateDeviceEx(
                 adapterID,
@@ -604,18 +604,18 @@ 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.
-        QWindowsIUPointer<IDirect3DTexture9> texture;
+        QComPtr<IDirect3DTexture9> texture;
         HANDLE sharedHandle = nullptr;
         hr = m_device->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, (D3DFORMAT)d3dFormat,  D3DPOOL_DEFAULT, texture.address(), &sharedHandle);
         if (FAILED(hr))
             break;
 
-        QWindowsIUPointer<IDirect3DSurface9> surface;
+        QComPtr<IDirect3DSurface9> surface;
         hr = texture->GetSurfaceLevel(0, surface.address());
         if (FAILED(hr))
             break;
 
-        QWindowsIUPointer<IMFSample> videoSample;
+        QComPtr<IMFSample> videoSample;
         hr = MFCreateVideoSampleFromSurface(surface.get(), videoSample.address());
         if (FAILED(hr))
             break;
diff --git a/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h b/src/plugins/multimedia/windows/evr/evrd3dpresentengine_p.h
index b3be7f560..82a5f7112 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;
 
-    QWindowsIUPointer<IDirect3D9Ex> m_D3D9;
-    QWindowsIUPointer<IDirect3DDevice9Ex> m_device;
-    QWindowsIUPointer<IDirect3DDeviceManager9> m_devices;
+    QComPtr<IDirect3D9Ex> m_D3D9;
+    QComPtr<IDirect3DDevice9Ex> m_device;
+    QComPtr<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 7e27886a7..e52ebf204 100644
--- a/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp
+++ b/src/plugins/multimedia/windows/mediacapture/qwindowsmediadevicereader.cpp
@@ -638,7 +638,7 @@ QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
     if (!m_active || m_recording || (videoFormat == GUID_NULL && audioFormat == GUID_NULL))
         return QMediaRecorder::ResourceError;
 
-    QWindowsIUPointer<IMFAttributes> writerAttributes;
+    QComPtr<IMFAttributes> writerAttributes;
 
     HRESULT hr = MFCreateAttributes(writerAttributes.address(), 2);
     if (FAILED(hr))
@@ -654,7 +654,7 @@ QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
     if (FAILED(hr))
         return QMediaRecorder::ResourceError;
 
-    QWindowsIUPointer<IMFSinkWriter> sinkWriter;
+    QComPtr<IMFSinkWriter> sinkWriter;
     hr = MFCreateSinkWriterFromURL(reinterpret_cast<LPCWSTR>(fileName.utf16()),
                                    nullptr, writerAttributes.get(), sinkWriter.address());
     if (FAILED(hr))
diff --git a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
index 510927b67..509967285 100644
--- a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
+++ b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
@@ -40,13 +40,13 @@ static QSet<T> getCodecSet(GUID category)
 
     if (SUCCEEDED(hr)) {
         for (UINT32 i = 0; i < num; ++i) {
-            QWindowsIUPointer<IMFTransform> transform;
+            QComPtr<IMFTransform> transform;
             UINT32 typeIndex = 0;
 
             hr = activateArray[i]->ActivateObject(IID_PPV_ARGS(transform.address()));
 
             while (SUCCEEDED(hr)) {
-                QWindowsIUPointer<IMFMediaType> mediaType;
+                QComPtr<IMFMediaType> mediaType;
 
                 if (category == MFT_CATEGORY_AUDIO_ENCODER || category == MFT_CATEGORY_VIDEO_ENCODER)
                     hr = transform->GetOutputAvailableType(0, typeIndex++, mediaType.address());
diff --git a/src/plugins/multimedia/windows/qwindowsvideodevices.cpp b/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
index bd0624bfc..78fe92ff2 100644
--- a/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
+++ b/src/plugins/multimedia/windows/qwindowsvideodevices.cpp
@@ -155,7 +155,7 @@ static std::optional<QCameraDevice> createCameraDevice(IMFActivate *device)
     if (FAILED(hr))
         return {};
 
-    QWindowsIUPointer<IMFSourceReader> reader;
+    QComPtr<IMFSourceReader> reader;
     hr = MFCreateSourceReaderFromMediaSource(source, NULL, reader.address());
     if (FAILED(hr))
         return {};
@@ -164,7 +164,7 @@ static std::optional<QCameraDevice> createCameraDevice(IMFActivate *device)
     QList<QCameraFormat> videoFormats;
     for (DWORD i = 0;; ++i) {
         // Loop through the supported formats for the video device
-        QWindowsIUPointer<IMFMediaType> mediaFormat;
+        QComPtr<IMFMediaType> mediaFormat;
         hr = reader->GetNativeMediaType((DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, i,
                                         mediaFormat.address());
         if (FAILED(hr))
@@ -208,7 +208,7 @@ QList<QCameraDevice> QWindowsVideoDevices::videoDevices() const
 {
     QList<QCameraDevice> cameras;
 
-    QWindowsIUPointer<IMFAttributes> attr;
+    QComPtr<IMFAttributes> attr;
     HRESULT hr = MFCreateAttributes(attr.address(), 2);
     if (FAILED(hr))
         return {};