DirectShow: Sanitize DirectShowMediaType

The DirectShowMediaType is now a thin data wrapper around AM_MEDIA_TYPE
and will for the most look and work the same way, with the exception
that it cleans up after itself. All utility functions are now static,
except clear() which, for convenience, is also provided as a non-static
member function.

In addition to the changes mentioned above, duplicated methods were
removed, conversion for ARGB32 was added, and an attempt to make
the usage of AM_MEDIA_TYPE and DirectShowMediaType was made more
consistent.

Change-Id: Iad32fb8eeabd9d4183e9bd10426cac3963e5d99a
Reviewed-by: Yoann Lopes <yoann.lopes@qt.io>

13 files changed, 227 insertions, 215 deletions

diff --git a/src/plugins/directshow/camera/directshowcameraglobal.h b/src/plugins/directshow/camera/directshowcameraglobal.h
index 75112a090..8df387b4a 100644
--- a/src/plugins/directshow/camera/directshowcameraglobal.h
+++ b/src/plugins/directshow/camera/directshowcameraglobal.h
@@ -44,9 +44,6 @@
 
 #include <dshow.h>
 
-DEFINE_GUID(MEDIASUBTYPE_I420,
-        0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71);
-
 extern const GUID MEDIASUBTYPE_RGB24;
 extern const GUID MEDIASUBTYPE_RGB32;
 extern const GUID MEDIASUBTYPE_YUY2;
diff --git a/src/plugins/directshow/camera/dscamerasession.cpp b/src/plugins/directshow/camera/dscamerasession.cpp
index 9955a4821..83abd983e 100644
--- a/src/plugins/directshow/camera/dscamerasession.cpp
+++ b/src/plugins/directshow/camera/dscamerasession.cpp
@@ -48,44 +48,12 @@
 #include "dscamerasession.h"
 #include "dsvideorenderer.h"
 #include "directshowcameraglobal.h"
+#include "directshowmediatype.h"
 
 QT_BEGIN_NAMESPACE
 
-
-namespace {
-// DirectShow helper implementation
-void _CopyMediaType(AM_MEDIA_TYPE *pmtTarget, const AM_MEDIA_TYPE *pmtSource)
-{
-    *pmtTarget = *pmtSource;
-    if (pmtTarget->cbFormat != 0) {
-        pmtTarget->pbFormat = reinterpret_cast<BYTE *>(CoTaskMemAlloc(pmtTarget->cbFormat));
-        if (pmtTarget->pbFormat)
-            memcpy(pmtTarget->pbFormat, pmtSource->pbFormat, pmtTarget->cbFormat);
-    }
-    if (pmtTarget->pUnk != NULL) {
-        // pUnk should not be used.
-        pmtTarget->pUnk->AddRef();
-    }
-}
-
-void _FreeMediaType(AM_MEDIA_TYPE& mt)
-{
-    if (mt.cbFormat != 0) {
-        CoTaskMemFree((PVOID)mt.pbFormat);
-        mt.cbFormat = 0;
-        mt.pbFormat = NULL;
-    }
-    if (mt.pUnk != NULL) {
-        // pUnk should not be used.
-        mt.pUnk->Release();
-        mt.pUnk = NULL;
-    }
-}
-} // end namespace
-
 static HRESULT getPin(IBaseFilter *filter, PIN_DIRECTION pinDir, IPin **pin);
 
-
 class SampleGrabberCallbackPrivate : public ISampleGrabberCB
 {
 public:
@@ -150,45 +118,6 @@ private:
     DSCameraSession *m_session;
 };
 
-QVideoFrame::PixelFormat pixelFormatFromMediaSubtype(GUID uid)
-{
-    if (uid == MEDIASUBTYPE_ARGB32)
-        return QVideoFrame::Format_ARGB32;
-    else if (uid == MEDIASUBTYPE_RGB32)
-        return QVideoFrame::Format_RGB32;
-    else if (uid == MEDIASUBTYPE_RGB24)
-        return QVideoFrame::Format_RGB24;
-    else if (uid == MEDIASUBTYPE_RGB565)
-        return QVideoFrame::Format_RGB565;
-    else if (uid == MEDIASUBTYPE_RGB555)
-        return QVideoFrame::Format_RGB555;
-    else if (uid == MEDIASUBTYPE_AYUV)
-        return QVideoFrame::Format_AYUV444;
-    else if (uid == MEDIASUBTYPE_I420 || uid == MEDIASUBTYPE_IYUV)
-        return QVideoFrame::Format_YUV420P;
-    else if (uid == MEDIASUBTYPE_YV12)
-        return QVideoFrame::Format_YV12;
-    else if (uid == MEDIASUBTYPE_UYVY)
-        return QVideoFrame::Format_UYVY;
-    else if (uid == MEDIASUBTYPE_YUYV || uid == MEDIASUBTYPE_YUY2)
-        return QVideoFrame::Format_YUYV;
-    else if (uid == MEDIASUBTYPE_NV12)
-        return QVideoFrame::Format_NV12;
-    else if (uid == MEDIASUBTYPE_MJPG)
-        return QVideoFrame::Format_Jpeg;
-    else if (uid == MEDIASUBTYPE_IMC1)
-        return QVideoFrame::Format_IMC1;
-    else if (uid == MEDIASUBTYPE_IMC2)
-        return QVideoFrame::Format_IMC2;
-    else if (uid == MEDIASUBTYPE_IMC3)
-        return QVideoFrame::Format_IMC3;
-    else if (uid == MEDIASUBTYPE_IMC4)
-        return QVideoFrame::Format_IMC4;
-    else
-        return QVideoFrame::Format_Invalid;
-}
-
-
 DSCameraSession::DSCameraSession(QObject *parent)
     : QObject(parent)
     , m_graphBuilder(Q_NULLPTR)
@@ -207,8 +136,6 @@ DSCameraSession::DSCameraSession(QObject *parent)
     , m_currentImageId(-1)
     , m_status(QCamera::UnloadedStatus)
 {
-    ZeroMemory(&m_sourceFormat, sizeof(m_sourceFormat));
-
     connect(this, SIGNAL(statusChanged(QCamera::Status)),
             this, SLOT(updateReadyForCapture()));
 }
@@ -499,8 +426,6 @@ bool DSCameraSession::unload()
 
     m_needsHorizontalMirroring = false;
     m_supportedViewfinderSettings.clear();
-    for (AM_MEDIA_TYPE f : qAsConst(m_supportedFormats))
-        _FreeMediaType(f);
     m_supportedFormats.clear();
     SAFE_RELEASE(m_sourceFilter);
     SAFE_RELEASE(m_previewSampleGrabber);
@@ -587,8 +512,7 @@ bool DSCameraSession::stopPreview()
 
     disconnectGraph();
 
-    _FreeMediaType(m_sourceFormat);
-    ZeroMemory(&m_sourceFormat, sizeof(m_sourceFormat));
+    m_sourceFormat.clear();
 
     m_previewStarted = false;
     setStatus(QCamera::LoadedStatus);
@@ -910,11 +834,11 @@ bool DSCameraSession::configurePreviewFormat()
 
     m_actualViewfinderSettings = resolvedViewfinderSettings;
 
-    _CopyMediaType(&m_sourceFormat, &m_supportedFormats[settingsIndex]);
+    m_sourceFormat = m_supportedFormats[settingsIndex];
     // Set frame rate.
     // We don't care about the minimumFrameRate, DirectShow only allows to set an
     // average frame rate, so set that to the maximumFrameRate.
-    VIDEOINFOHEADER *videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(m_sourceFormat.pbFormat);
+    VIDEOINFOHEADER *videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(m_sourceFormat->pbFormat);
     videoInfo->AvgTimePerFrame = 10000000 / resolvedViewfinderSettings.maximumFrameRate();
 
     // We only support RGB32, if the capture source doesn't support
@@ -955,16 +879,10 @@ bool DSCameraSession::configurePreviewFormat()
     }
 
     // Set sample grabber format (always RGB32)
-    AM_MEDIA_TYPE grabberFormat;
-    ZeroMemory(&grabberFormat, sizeof(grabberFormat));
-    grabberFormat.majortype = MEDIATYPE_Video;
-    grabberFormat.subtype = MEDIASUBTYPE_RGB32;
-    grabberFormat.formattype = FORMAT_VideoInfo;
+    static const AM_MEDIA_TYPE grabberFormat { MEDIATYPE_Video, MEDIASUBTYPE_RGB32, 0, 0, 0, FORMAT_VideoInfo };
     hr = m_previewSampleGrabber->SetMediaType(&grabberFormat);
-    if (FAILED(hr)) {
-        qWarning() << "Failed to set video format on grabber";
+    if (FAILED(hr))
         return false;
-    }
 
     return true;
 }
@@ -1107,8 +1025,6 @@ void DSCameraSession::updateSourceCapabilities()
 
     m_supportedViewfinderSettings.clear();
     m_needsHorizontalMirroring = false;
-    for (AM_MEDIA_TYPE f : qAsConst(m_supportedFormats))
-        _FreeMediaType(f);
     m_supportedFormats.clear();
     m_imageProcessingParametersInfos.clear();
 
@@ -1160,7 +1076,7 @@ void DSCameraSession::updateSourceCapabilities()
     for (int iIndex = 0; iIndex < iCount; ++iIndex) {
         hr = pConfig->GetStreamCaps(iIndex, &pmt, reinterpret_cast<BYTE*>(&scc));
         if (hr == S_OK) {
-            QVideoFrame::PixelFormat pixelFormat = pixelFormatFromMediaSubtype(pmt->subtype);
+            QVideoFrame::PixelFormat pixelFormat = DirectShowMediaType::pixelFormatFromType(pmt);
 
             if (pmt->majortype == MEDIATYPE_Video
                     && pmt->formattype == FORMAT_VideoInfo
@@ -1207,15 +1123,12 @@ void DSCameraSession::updateSourceCapabilities()
                     settings.setPixelFormat(pixelFormat);
                     settings.setPixelAspectRatio(1, 1);
                     m_supportedViewfinderSettings.append(settings);
-
-                    AM_MEDIA_TYPE format;
-                    _CopyMediaType(&format, pmt);
-                    m_supportedFormats.append(format);
+                    m_supportedFormats.append(DirectShowMediaType(*pmt));
                 }
 
 
             }
-            _FreeMediaType(*pmt);
+            DirectShowMediaType::deleteType(pmt);
         }
     }
 
diff --git a/src/plugins/directshow/camera/dscamerasession.h b/src/plugins/directshow/camera/dscamerasession.h
index 61b156d8a..3e5dc5efd 100644
--- a/src/plugins/directshow/camera/dscamerasession.h
+++ b/src/plugins/directshow/camera/dscamerasession.h
@@ -56,6 +56,7 @@
 #include <dshow.h>
 #include <objbase.h>
 #include <initguid.h>
+#include "directshowmediatype.h"
 #ifdef Q_CC_MSVC
 #  pragma comment(lib, "strmiids.lib")
 #  pragma comment(lib, "ole32.lib")
@@ -182,9 +183,9 @@ private:
     QString m_sourceDeviceName;
     IBaseFilter* m_sourceFilter;
     bool m_needsHorizontalMirroring;
-    QList<AM_MEDIA_TYPE> m_supportedFormats;
+    QList<DirectShowMediaType> m_supportedFormats;
     QList<QCameraViewfinderSettings> m_supportedViewfinderSettings;
-    AM_MEDIA_TYPE m_sourceFormat;
+    DirectShowMediaType m_sourceFormat;
     QMap<QCameraImageProcessingControl::ProcessingParameter, ImageProcessingParameterInfo> m_imageProcessingParametersInfos;
 
     // Preview
diff --git a/src/plugins/directshow/helpers/directshowglobal.h b/src/plugins/directshow/helpers/directshowglobal.h
index 1447bff16..5f391710e 100644
--- a/src/plugins/directshow/helpers/directshowglobal.h
+++ b/src/plugins/directshow/helpers/directshowglobal.h
@@ -84,6 +84,9 @@ template <typename T> T *com_new(const IID &clsid, const IID &iid)
         : 0;
 }
 
+DEFINE_GUID(MEDIASUBTYPE_I420,
+        0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71);
+
 #ifndef __IFilterGraph2_INTERFACE_DEFINED__
 #define __IFilterGraph2_INTERFACE_DEFINED__
 #define INTERFACE IFilterGraph2
diff --git a/src/plugins/directshow/helpers/directshowmediatype.cpp b/src/plugins/directshow/helpers/directshowmediatype.cpp
index 60c0ee040..586b6bd80 100644
--- a/src/plugins/directshow/helpers/directshowmediatype.cpp
+++ b/src/plugins/directshow/helpers/directshowmediatype.cpp
@@ -38,6 +38,7 @@
 ****************************************************************************/
 
 #include "directshowmediatype.h"
+#include "directshowglobal.h"
 
 namespace
 {
@@ -49,85 +50,168 @@ namespace
 
     static const TypeLookup qt_typeLookup[] =
     {
-        { QVideoFrame::Format_RGB32,   /*MEDIASUBTYPE_RGB32*/  {0xe436eb7e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
-        { QVideoFrame::Format_BGR24,   /*MEDIASUBTYPE_RGB24*/  {0xe436eb7d, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
-        { QVideoFrame::Format_RGB565,  /*MEDIASUBTYPE_RGB565*/ {0xe436eb7b, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
-        { QVideoFrame::Format_RGB555,  /*MEDIASUBTYPE_RGB555*/ {0xe436eb7c, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
-        { QVideoFrame::Format_AYUV444, /*MEDIASUBTYPE_AYUV*/   {0x56555941, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_YUYV,    /*MEDIASUBTYPE_YUY2*/   {0x32595559, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_UYVY,    /*MEDIASUBTYPE_UYVY*/   {0x59565955, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_IMC1,    /*MEDIASUBTYPE_IMC1*/   {0x31434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_IMC2,    /*MEDIASUBTYPE_IMC2*/   {0x32434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_IMC3,    /*MEDIASUBTYPE_IMC3*/   {0x33434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_IMC4,    /*MEDIASUBTYPE_IMC4*/   {0x34434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_YV12,    /*MEDIASUBTYPE_YV12*/   {0x32315659, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_NV12,    /*MEDIASUBTYPE_NV12*/   {0x3231564E, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_YUV420P, /*MEDIASUBTYPE_IYUV*/   {0x56555949, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
-        { QVideoFrame::Format_YUV420P, /*MEDIASUBTYPE_I420*/   {0x30323449, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} }
+        { QVideoFrame::Format_ARGB32, MEDIASUBTYPE_ARGB32 },
+        { QVideoFrame::Format_RGB32, MEDIASUBTYPE_RGB32 },
+        { QVideoFrame::Format_RGB24, MEDIASUBTYPE_RGB24 },
+        { QVideoFrame::Format_RGB565, MEDIASUBTYPE_RGB565 },
+        { QVideoFrame::Format_RGB555, MEDIASUBTYPE_RGB555 },
+        { QVideoFrame::Format_AYUV444, MEDIASUBTYPE_AYUV },
+        { QVideoFrame::Format_YUYV, MEDIASUBTYPE_YUY2 },
+        { QVideoFrame::Format_UYVY, MEDIASUBTYPE_UYVY },
+        { QVideoFrame::Format_IMC1, MEDIASUBTYPE_IMC1 },
+        { QVideoFrame::Format_IMC2, MEDIASUBTYPE_IMC2 },
+        { QVideoFrame::Format_IMC3, MEDIASUBTYPE_IMC3 },
+        { QVideoFrame::Format_IMC4, MEDIASUBTYPE_IMC4 },
+        { QVideoFrame::Format_YV12, MEDIASUBTYPE_YV12 },
+        { QVideoFrame::Format_NV12, MEDIASUBTYPE_NV12 },
+        { QVideoFrame::Format_YUV420P, MEDIASUBTYPE_IYUV },
+        { QVideoFrame::Format_YUV420P, MEDIASUBTYPE_I420 },
+        { QVideoFrame::Format_Jpeg, MEDIASUBTYPE_MJPG }
     };
 }
 
-bool DirectShowMediaType::isPartiallySpecified() const
+bool DirectShowMediaType::isPartiallySpecified(const AM_MEDIA_TYPE *mediaType)
 {
-    return majortype == GUID_NULL || formattype == GUID_NULL;
+    return mediaType->majortype == GUID_NULL || mediaType->formattype == GUID_NULL;
 }
 
-bool DirectShowMediaType::isCompatibleWith(const DirectShowMediaType *type) const
+DirectShowMediaType::DirectShowMediaType()
+    : mediaType({ GUID_NULL, GUID_NULL, TRUE, FALSE, 1 })
 {
-    if (type->majortype != GUID_NULL && majortype != type->majortype)
-        return false;
+}
 
-    if (type->subtype != GUID_NULL && subtype != type->subtype)
-        return false;
+DirectShowMediaType::DirectShowMediaType(const AM_MEDIA_TYPE &type)
+    : DirectShowMediaType()
+{
+    copy(&mediaType, &type);
+}
 
-    if (type->formattype != GUID_NULL) {
-        if (formattype != type->formattype)
-            return false;
-        if (cbFormat != type->cbFormat)
-            return false;
-        if (cbFormat != 0 && memcmp(pbFormat, type->pbFormat, cbFormat) != 0)
-            return false;
-    }
+DirectShowMediaType::DirectShowMediaType(AM_MEDIA_TYPE &&type)
+    : DirectShowMediaType()
+{
+    move(&mediaType, type);
+}
 
-    return true;
+DirectShowMediaType::DirectShowMediaType(const DirectShowMediaType &other)
+    : DirectShowMediaType()
+{
+    copy(&mediaType, &other.mediaType);
+}
+
+DirectShowMediaType::DirectShowMediaType(DirectShowMediaType &&other)
+    : DirectShowMediaType()
+{
+    move(&mediaType, other.mediaType);
+}
+
+DirectShowMediaType &DirectShowMediaType::operator=(const DirectShowMediaType &other)
+{
+    copy(&mediaType, &other.mediaType);
+    return *this;
+}
+
+DirectShowMediaType &DirectShowMediaType::operator=(DirectShowMediaType &&other)
+{
+    move(&mediaType, other.mediaType);
+    return *this;
 }
 
 void DirectShowMediaType::init(AM_MEDIA_TYPE *type)
 {
-    ZeroMemory((PVOID)type, sizeof(*type));
+    Q_ASSERT(type);
+    SecureZeroMemory(reinterpret_cast<void *>(type), sizeof(AM_MEDIA_TYPE));
     type->lSampleSize = 1;
     type->bFixedSizeSamples = TRUE;
 }
 
-void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source)
+void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE *source)
 {
-    if (!target)
+    if (!(target && source))
+        return;
+
+    if (target == source)
         return;
 
-    *target = source;
+    clear(*target);
 
-    if (source.cbFormat > 0) {
-        target->pbFormat = reinterpret_cast<PBYTE>(CoTaskMemAlloc(source.cbFormat));
-        memcpy(target->pbFormat, source.pbFormat, source.cbFormat);
+    *target = *source;
+
+    if (source->cbFormat > 0) {
+        target->pbFormat = reinterpret_cast<PBYTE>(CoTaskMemAlloc(source->cbFormat));
+        memcpy(target->pbFormat, source->pbFormat, source->cbFormat);
     }
     if (target->pUnk)
         target->pUnk->AddRef();
 }
 
+void DirectShowMediaType::move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE **source)
+{
+    if (!target || !source || !(*source))
+        return;
+
+    if (target == *source)
+        return;
+
+    clear(*target);
+    *target = *(*source);
+    SecureZeroMemory(reinterpret_cast<void *>(*source), sizeof(AM_MEDIA_TYPE));
+    *source = nullptr;
+}
+
+void DirectShowMediaType::move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE &source)
+{
+    AM_MEDIA_TYPE *srcPtr = &source;
+    move(target, &srcPtr);
+}
+
+/**
+ * @brief DirectShowMediaType::deleteType - Used for AM_MEDIA_TYPE structures that have
+ *        been allocated by CoTaskMemAlloc or CreateMediaType.
+ * @param type
+ */
 void DirectShowMediaType::deleteType(AM_MEDIA_TYPE *type)
 {
-    freeData(type);
+    if (!type)
+        return;
 
+    clear(*type);
     CoTaskMemFree(type);
 }
 
-void DirectShowMediaType::freeData(AM_MEDIA_TYPE *type)
+bool DirectShowMediaType::isCompatible(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b)
+{
+    if (b->majortype != GUID_NULL && a->majortype != b->majortype)
+        return false;
+
+    if (b->subtype != GUID_NULL && a->subtype != b->subtype)
+        return false;
+
+    if (b->formattype != GUID_NULL) {
+        if (a->formattype != b->formattype)
+            return false;
+        if (a->cbFormat != b->cbFormat)
+            return false;
+        if (a->cbFormat != 0 && memcmp(a->pbFormat, b->pbFormat, a->cbFormat) != 0)
+            return false;
+    }
+
+    return true;
+}
+
+/**
+ * @brief DirectShowMediaType::clear - Clears all member data, and releases allocated buffers.
+ *        Use this to release automatic AM_MEDIA_TYPE structures.
+ * @param type
+ */
+void DirectShowMediaType::clear(AM_MEDIA_TYPE &type)
 {
-    if (type->cbFormat > 0)
-        CoTaskMemFree(type->pbFormat);
+    if (type.cbFormat > 0)
+        CoTaskMemFree(type.pbFormat);
+
+    if (type.pUnk)
+        type.pUnk->Release();
 
-    if (type->pUnk)
-        type->pUnk->Release();
+    SecureZeroMemory(&type, sizeof(type));
 }
 
 
@@ -142,14 +226,17 @@ GUID DirectShowMediaType::convertPixelFormat(QVideoFrame::PixelFormat format)
     return MEDIASUBTYPE_None;
 }
 
-QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &type)
+QVideoSurfaceFormat DirectShowMediaType::videoFormatFromType(const AM_MEDIA_TYPE *type)
 {
+    if (!type)
+        return QVideoSurfaceFormat();
+
     const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
 
     for (int i = 0; i < count; ++i) {
-        if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype) && type.cbFormat > 0) {
-            if (IsEqualGUID(type.formattype, FORMAT_VideoInfo)) {
-                VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER *>(type.pbFormat);
+        if (IsEqualGUID(qt_typeLookup[i].mediaType, type->subtype) && type->cbFormat > 0) {
+            if (IsEqualGUID(type->formattype, FORMAT_VideoInfo)) {
+                VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER *>(type->pbFormat);
 
                 QVideoSurfaceFormat format(
                         QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
@@ -161,8 +248,8 @@ QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &typ
                 format.setScanLineDirection(scanLineDirection(format.pixelFormat(), header->bmiHeader));
 
                 return format;
-            } else if (IsEqualGUID(type.formattype, FORMAT_VideoInfo2)) {
-                VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2 *>(type.pbFormat);
+            } else if (IsEqualGUID(type->formattype, FORMAT_VideoInfo2)) {
+                VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2 *>(type->pbFormat);
 
                 QVideoSurfaceFormat format(
                         QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
@@ -180,12 +267,15 @@ QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &typ
     return QVideoSurfaceFormat();
 }
 
-QVideoFrame::PixelFormat DirectShowMediaType::pixelFormatFromType(const AM_MEDIA_TYPE &type)
+QVideoFrame::PixelFormat DirectShowMediaType::pixelFormatFromType(const AM_MEDIA_TYPE *type)
 {
+    if (!type)
+        return QVideoFrame::Format_Invalid;
+
     const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
 
     for (int i = 0; i < count; ++i) {
-        if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype)) {
+        if (IsEqualGUID(qt_typeLookup[i].mediaType, type->subtype)) {
             return qt_typeLookup[i].pixelFormat;
         }
     }
@@ -198,6 +288,7 @@ int DirectShowMediaType::bytesPerLine(const QVideoSurfaceFormat &format)
 {
     switch (format.pixelFormat()) {
     // 32 bpp packed formats.
+    case QVideoFrame::Format_ARGB32:
     case QVideoFrame::Format_RGB32:
     case QVideoFrame::Format_AYUV444:
         return format.frameWidth() * 4;
@@ -240,8 +331,9 @@ QVideoSurfaceFormat::Direction DirectShowMediaType::scanLineDirection(QVideoFram
      */
     switch (pixelFormat)
     {
+    case QVideoFrame::Format_ARGB32:
     case QVideoFrame::Format_RGB32:
-    case QVideoFrame::Format_BGR24:
+    case QVideoFrame::Format_RGB24:
     case QVideoFrame::Format_RGB565:
     case QVideoFrame::Format_RGB555:
         return bmiHeader.biHeight < 0
diff --git a/src/plugins/directshow/helpers/directshowmediatype.h b/src/plugins/directshow/helpers/directshowmediatype.h
index b2b074ccc..b9aa989f0 100644
--- a/src/plugins/directshow/helpers/directshowmediatype.h
+++ b/src/plugins/directshow/helpers/directshowmediatype.h
@@ -45,39 +45,48 @@
 #include <qvideosurfaceformat.h>
 
 #include <dvdmedia.h>
+#include <QtCore/qglobal.h>
 
 QT_USE_NAMESPACE
 
-class DirectShowMediaType : public AM_MEDIA_TYPE
+class DirectShowMediaType
 {
 public:
-    DirectShowMediaType() { init(this); }
-    DirectShowMediaType(const AM_MEDIA_TYPE &type) { copy(this, type); }
-    DirectShowMediaType(const DirectShowMediaType &other) { copy(this, other); }
-    DirectShowMediaType &operator =(const AM_MEDIA_TYPE &type) {
-        freeData(this); copy(this, type); return *this; }
-    DirectShowMediaType &operator =(const DirectShowMediaType &other) {
-        freeData(this); copy(this, other); return *this; }
-    ~DirectShowMediaType() { freeData(this); }
+    DirectShowMediaType();
+    DirectShowMediaType(const DirectShowMediaType &other);
+    DirectShowMediaType(DirectShowMediaType &&other);
+    explicit DirectShowMediaType(const AM_MEDIA_TYPE &type);
+    explicit DirectShowMediaType(AM_MEDIA_TYPE &&type);
+    ~DirectShowMediaType() { clear(mediaType); }
 
-    void clear() { freeData(this); init(this); }
+    DirectShowMediaType &operator =(const DirectShowMediaType &other);
+    DirectShowMediaType &operator =(DirectShowMediaType &&other);
 
-    bool isPartiallySpecified() const;
-    bool isCompatibleWith(const DirectShowMediaType *type) const;
+    void clear() { clear(mediaType); }
+
+    inline AM_MEDIA_TYPE *operator &() Q_DECL_NOTHROW { return &mediaType; }
+    inline AM_MEDIA_TYPE *operator ->() Q_DECL_NOTHROW { return &mediaType; }
+
+    inline const AM_MEDIA_TYPE *const operator &() const Q_DECL_NOTHROW { return &mediaType; }
+    inline const AM_MEDIA_TYPE *const operator ->() const Q_DECL_NOTHROW { return &mediaType; }
 
     static void init(AM_MEDIA_TYPE *type);
-    static void copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source);
-    static void freeData(AM_MEDIA_TYPE *type);
+    static void copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE *source);
+    static void move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE **source);
+    static void move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE &source);
+    static void clear(AM_MEDIA_TYPE &type);
     static void deleteType(AM_MEDIA_TYPE *type);
-
+    static bool isPartiallySpecified(const AM_MEDIA_TYPE *mediaType);
+    static bool isCompatible(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b);
     static GUID convertPixelFormat(QVideoFrame::PixelFormat format);
-    static QVideoSurfaceFormat formatFromType(const AM_MEDIA_TYPE &type);
-    static QVideoFrame::PixelFormat pixelFormatFromType(const AM_MEDIA_TYPE &type);
 
+    static QVideoSurfaceFormat videoFormatFromType(const AM_MEDIA_TYPE *type);
+    static QVideoFrame::PixelFormat pixelFormatFromType(const AM_MEDIA_TYPE *type);
     static int bytesPerLine(const QVideoSurfaceFormat &format);
+    static QVideoSurfaceFormat::Direction scanLineDirection(QVideoFrame::PixelFormat pixelFormat, const BITMAPINFOHEADER &bmiHeader);
 
 private:
-    static QVideoSurfaceFormat::Direction scanLineDirection(QVideoFrame::PixelFormat pixelFormat, const BITMAPINFOHEADER &bmiHeader);
+    AM_MEDIA_TYPE mediaType;
 };
 
 Q_DECLARE_TYPEINFO(DirectShowMediaType, Q_MOVABLE_TYPE);
diff --git a/src/plugins/directshow/helpers/directshowmediatypeenum.cpp b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
index a1c8b2306..a58993f7f 100644
--- a/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
+++ b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
@@ -72,7 +72,7 @@ HRESULT DirectShowMediaTypeEnum::Next(ULONG cMediaTypes, AM_MEDIA_TYPE **ppMedia
 
         for (ULONG i = 0; i < count; ++i, ++m_index) {
             ppMediaTypes[i] = reinterpret_cast<AM_MEDIA_TYPE *>(CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)));
-            DirectShowMediaType::copy(ppMediaTypes[i], m_mediaTypes.at(m_index));
+            DirectShowMediaType::copy(ppMediaTypes[i], &m_mediaTypes.at(m_index));
         }
 
         if (pcFetched)
diff --git a/src/plugins/directshow/helpers/directshowpin.cpp b/src/plugins/directshow/helpers/directshowpin.cpp
index 6cf4da321..f501747f9 100644
--- a/src/plugins/directshow/helpers/directshowpin.cpp
+++ b/src/plugins/directshow/helpers/directshowpin.cpp
@@ -81,22 +81,20 @@ HRESULT DirectShowPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
     if (pd == m_direction)
         return VFW_E_INVALID_DIRECTION;
 
-    const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
-
-    if (type != NULL && !type->isPartiallySpecified()) {
+    if (pmt != NULL && DirectShowMediaType::isPartiallySpecified(pmt)) {
         // If the type is fully specified, use it
-        hr = tryConnect(pReceivePin, type);
+        hr = tryConnect(pReceivePin, pmt);
     } else {
         IEnumMediaTypes *enumMediaTypes = NULL;
 
         // First, try the receiving pin's preferred types
         if (SUCCEEDED(pReceivePin->EnumMediaTypes(&enumMediaTypes))) {
-            hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+            hr = tryMediaTypes(pReceivePin, pmt, enumMediaTypes);
             enumMediaTypes->Release();
         }
         // Then, try this pin's preferred types
         if (FAILED(hr) && SUCCEEDED(EnumMediaTypes(&enumMediaTypes))) {
-            hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+            hr = tryMediaTypes(pReceivePin, pmt, enumMediaTypes);
             enumMediaTypes->Release();
         }
     }
@@ -109,19 +107,19 @@ HRESULT DirectShowPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
     return S_OK;
 }
 
-HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const DirectShowMediaType *partialType, IEnumMediaTypes *enumMediaTypes)
+HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const AM_MEDIA_TYPE *partialType, IEnumMediaTypes *enumMediaTypes)
 {
     HRESULT hr = enumMediaTypes->Reset();
     if (FAILED(hr))
         return hr;
 
-    DirectShowMediaType *mediaType = NULL;
+    AM_MEDIA_TYPE *mediaType = NULL;
     ULONG mediaCount = 0;
     HRESULT hrFailure = VFW_E_NO_ACCEPTABLE_TYPES;
 
-    for (; enumMediaTypes->Next(1, reinterpret_cast<AM_MEDIA_TYPE**>(&mediaType), &mediaCount) == S_OK;) {
+    for (; enumMediaTypes->Next(1, &mediaType, &mediaCount) == S_OK;) {
 
-        if (mediaType && (partialType == NULL || mediaType->isCompatibleWith(partialType))) {
+        if (mediaType && (partialType == NULL || DirectShowMediaType::isCompatible(mediaType, partialType))) {
             hr = tryConnect(pin, mediaType);
 
             if (FAILED(hr) && (hr != E_FAIL)
@@ -141,7 +139,7 @@ HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const DirectShowMediaType *parti
     return hrFailure;
 }
 
-HRESULT DirectShowPin::tryConnect(IPin *pin, const DirectShowMediaType *type)
+HRESULT DirectShowPin::tryConnect(IPin *pin, const AM_MEDIA_TYPE *type)
 {
     if (!isMediaTypeSupported(type))
         return VFW_E_TYPE_NOT_ACCEPTED;
@@ -189,15 +187,14 @@ HRESULT DirectShowPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *
     if (pd == m_direction)
         return VFW_E_INVALID_DIRECTION;
 
-    const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
-    if (!isMediaTypeSupported(type))
+    if (!isMediaTypeSupported(pmt))
         return VFW_E_TYPE_NOT_ACCEPTED;
 
     m_peerPin = pConnector;
     m_peerPin->AddRef();
 
     HRESULT hr;
-    if (!setMediaType(type))
+    if (!setMediaType(pmt))
         hr = VFW_E_TYPE_NOT_ACCEPTED;
     else
         hr = completeConnection(pConnector);
@@ -265,7 +262,7 @@ HRESULT DirectShowPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
             DirectShowMediaType::init(pmt);
             return VFW_E_NOT_CONNECTED;
         } else {
-            DirectShowMediaType::copy(pmt, m_mediaType);
+            DirectShowMediaType::copy(pmt, &m_mediaType);
             return S_OK;
         }
     }
@@ -309,7 +306,7 @@ HRESULT DirectShowPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
     if (!pmt)
         return E_POINTER;
 
-    if (!isMediaTypeSupported(reinterpret_cast<const DirectShowMediaType*>(pmt)))
+    if (!isMediaTypeSupported(pmt))
         return S_FALSE;
 
     return S_OK;
@@ -370,12 +367,12 @@ QList<DirectShowMediaType> DirectShowPin::supportedMediaTypes()
     return QList<DirectShowMediaType>();
 }
 
-bool DirectShowPin::setMediaType(const DirectShowMediaType *type)
+bool DirectShowPin::setMediaType(const AM_MEDIA_TYPE *type)
 {
     if (!type)
         m_mediaType.clear();
     else
-        m_mediaType = *type;
+        DirectShowMediaType::copy(&m_mediaType, type);
 
     return true;
 }
@@ -673,7 +670,7 @@ HRESULT DirectShowInputPin::Receive(IMediaSample *pSample)
     if (!(m_sampleProperties.dwSampleFlags & AM_SAMPLE_TYPECHANGED))
         return S_OK;
 
-    if (isMediaTypeSupported(reinterpret_cast<DirectShowMediaType*>(m_sampleProperties.pMediaType)))
+    if (isMediaTypeSupported(m_sampleProperties.pMediaType))
         return S_OK;
 
     m_inErrorState = true;
diff --git a/src/plugins/directshow/helpers/directshowpin.h b/src/plugins/directshow/helpers/directshowpin.h
index 823223956..b8207abae 100644
--- a/src/plugins/directshow/helpers/directshowpin.h
+++ b/src/plugins/directshow/helpers/directshowpin.h
@@ -55,9 +55,9 @@ public:
     QString name() const { return m_name; }
     bool isConnected() const { return m_peerPin != NULL; }
 
-    virtual bool isMediaTypeSupported(const DirectShowMediaType *type) = 0;
+    virtual bool isMediaTypeSupported(const AM_MEDIA_TYPE *type) = 0;
     virtual QList<DirectShowMediaType> supportedMediaTypes();
-    virtual bool setMediaType(const DirectShowMediaType *type);
+    virtual bool setMediaType(const AM_MEDIA_TYPE *type);
 
     virtual HRESULT completeConnection(IPin *pin);
     virtual HRESULT connectionEnded();
@@ -107,8 +107,8 @@ protected:
 
 private:
     Q_DISABLE_COPY(DirectShowPin)
-    HRESULT tryMediaTypes(IPin *pin, const DirectShowMediaType *type, IEnumMediaTypes *enumMediaTypes);
-    HRESULT tryConnect(IPin *pin, const DirectShowMediaType *type);
+    HRESULT tryMediaTypes(IPin *pin, const AM_MEDIA_TYPE *type, IEnumMediaTypes *enumMediaTypes);
+    HRESULT tryConnect(IPin *pin, const AM_MEDIA_TYPE *type);
 };
 
 
diff --git a/src/plugins/directshow/player/directshowiosource.cpp b/src/plugins/directshow/player/directshowiosource.cpp
index 3c44dd1ed..96b4b14bf 100644
--- a/src/plugins/directshow/player/directshowiosource.cpp
+++ b/src/plugins/directshow/player/directshowiosource.cpp
@@ -82,7 +82,7 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
     // The filter works in pull mode, the downstream filter is responsible for requesting
     // samples from this one.
     //
-    AM_MEDIA_TYPE type =
+    AM_MEDIA_TYPE type
     {
         MEDIATYPE_Stream,  // majortype
         MEDIASUBTYPE_NULL, // subtype
@@ -99,7 +99,7 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
 
     for (int i = 0; i < count; ++i) {
         type.subtype = directshow_subtypes[i];
-        m_supportedMediaTypes.append(type);
+        m_supportedMediaTypes.append(DirectShowMediaType(type));
     }
 }
 
@@ -371,12 +371,12 @@ HRESULT DirectShowIOSource::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
          hr = pReceivePin->ReceiveConnection(this, pmt);
          // Update the media type for the current connection.
          if (SUCCEEDED(hr))
-             m_connectionMediaType = *pmt;
+             DirectShowMediaType::copy(&m_connectionMediaType, pmt);
     } else if (pmt && pmt->subtype == MEDIATYPE_NULL) { // - Partial type (Stream, but no subtype specified).
-        m_connectionMediaType = *pmt;
+        DirectShowMediaType::copy(&m_connectionMediaType, pmt);
         // Check if the receiving pin accepts any of the streaming subtypes.
         for (const DirectShowMediaType &t : qAsConst(m_supportedMediaTypes)) {
-            m_connectionMediaType.subtype = t.subtype;
+            m_connectionMediaType->subtype = t->subtype;
             hr = pReceivePin->ReceiveConnection(this, &m_connectionMediaType);
             if (SUCCEEDED(hr))
                 break;
@@ -477,7 +477,7 @@ HRESULT DirectShowIOSource::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
 
             return VFW_E_NOT_CONNECTED;
         } else {
-            DirectShowMediaType::copy(pmt, m_connectionMediaType);
+            DirectShowMediaType::copy(pmt, &m_connectionMediaType);
 
             return S_OK;
         }
diff --git a/src/plugins/directshow/player/directshowplayerservice.cpp b/src/plugins/directshow/player/directshowplayerservice.cpp
index 1502c6df3..0b88496af 100644
--- a/src/plugins/directshow/player/directshowplayerservice.cpp
+++ b/src/plugins/directshow/player/directshowplayerservice.cpp
@@ -627,13 +627,13 @@ int DirectShowPlayerService::findStreamTypes(IBaseFilter *source) const
             for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
                 PIN_DIRECTION direction;
                 if (pin->QueryDirection(&direction) == S_OK && direction == PINDIR_OUTPUT) {
-                    AM_MEDIA_TYPE connectionType;
+                    DirectShowMediaType connectionType;
                     if (SUCCEEDED(pin->ConnectionMediaType(&connectionType))) {
                         IPin *peer = 0;
 
-                        if (connectionType.majortype == MEDIATYPE_Audio) {
+                        if (connectionType->majortype == MEDIATYPE_Audio) {
                             streamTypes |= AudioStream;
-                        } else if (connectionType.majortype == MEDIATYPE_Video) {
+                        } else if (connectionType->majortype == MEDIATYPE_Video) {
                             streamTypes |= VideoStream;
                         } else if (SUCCEEDED(pin->ConnectedTo(&peer))) {
                             PIN_INFO peerInfo;
diff --git a/src/plugins/directshow/player/videosurfacefilter.cpp b/src/plugins/directshow/player/videosurfacefilter.cpp
index 4cb97be39..13f767a85 100644
--- a/src/plugins/directshow/player/videosurfacefilter.cpp
+++ b/src/plugins/directshow/player/videosurfacefilter.cpp
@@ -63,8 +63,8 @@ public:
     VideoSurfaceInputPin(VideoSurfaceFilter *filter);
 
     // DirectShowPin
-    bool isMediaTypeSupported(const DirectShowMediaType *type);
-    bool setMediaType(const DirectShowMediaType *type);
+    bool isMediaTypeSupported(const AM_MEDIA_TYPE *type) override;
+    bool setMediaType(const AM_MEDIA_TYPE *type) override;
 
     HRESULT completeConnection(IPin *pin);
     HRESULT connectionEnded();
@@ -90,12 +90,12 @@ VideoSurfaceInputPin::VideoSurfaceInputPin(VideoSurfaceFilter *filter)
 {
 }
 
-bool VideoSurfaceInputPin::isMediaTypeSupported(const DirectShowMediaType *type)
+bool VideoSurfaceInputPin::isMediaTypeSupported(const AM_MEDIA_TYPE *type)
 {
     return m_videoSurfaceFilter->isMediaTypeSupported(type);
 }
 
-bool VideoSurfaceInputPin::setMediaType(const DirectShowMediaType *type)
+bool VideoSurfaceInputPin::setMediaType(const AM_MEDIA_TYPE *type)
 {
     if (!DirectShowInputPin::setMediaType(type))
         return false;
@@ -282,7 +282,7 @@ void VideoSurfaceFilter::supportedFormatsChanged()
     }
 }
 
-bool VideoSurfaceFilter::isMediaTypeSupported(const DirectShowMediaType *type)
+bool VideoSurfaceFilter::isMediaTypeSupported(const AM_MEDIA_TYPE *type)
 {
     if (type->majortype != MEDIATYPE_Video || type->bFixedSizeSamples == FALSE)
         return false;
@@ -297,7 +297,7 @@ bool VideoSurfaceFilter::isMediaTypeSupported(const DirectShowMediaType *type)
     return false;
 }
 
-bool VideoSurfaceFilter::setMediaType(const DirectShowMediaType *type)
+bool VideoSurfaceFilter::setMediaType(const AM_MEDIA_TYPE *type)
 {
     if (!type) {
         qCDebug(qLcRenderFilter, "clear media type");
@@ -305,7 +305,7 @@ bool VideoSurfaceFilter::setMediaType(const DirectShowMediaType *type)
         m_bytesPerLine = 0;
         return true;
     } else {
-        m_surfaceFormat = DirectShowMediaType::formatFromType(*type);
+        m_surfaceFormat = DirectShowMediaType::videoFormatFromType(type);
         m_bytesPerLine = DirectShowMediaType::bytesPerLine(m_surfaceFormat);
         qCDebug(qLcRenderFilter) << "setMediaType -->" << m_surfaceFormat;
         return m_surfaceFormat.isValid();
@@ -478,7 +478,7 @@ HRESULT VideoSurfaceFilter::Receive(IMediaSample *pMediaSample)
         // If the format dynamically changed, the sample contains information about the new format.
         // We need to reset the format and restart the QAbstractVideoSurface.
         if (m_pin->currentSampleProperties()->pMediaType
-                && (!m_pin->setMediaType(reinterpret_cast<const DirectShowMediaType *>(m_pin->currentSampleProperties()->pMediaType))
+                && (!m_pin->setMediaType(m_pin->currentSampleProperties()->pMediaType)
                     || !restartSurface())) {
                 qCWarning(qLcRenderFilter, "  dynamic format change failed, aborting rendering");
                 NotifyEvent(EC_ERRORABORT, VFW_E_TYPE_NOT_ACCEPTED, 0);
diff --git a/src/plugins/directshow/player/videosurfacefilter.h b/src/plugins/directshow/player/videosurfacefilter.h
index 581e33c70..6d6cc7593 100644
--- a/src/plugins/directshow/player/videosurfacefilter.h
+++ b/src/plugins/directshow/player/videosurfacefilter.h
@@ -83,8 +83,8 @@ public:
     STDMETHODIMP_(ULONG) GetMiscFlags();
 
     // DirectShowPin (delegate)
-    bool isMediaTypeSupported(const DirectShowMediaType *type);
-    bool setMediaType(const DirectShowMediaType *type);
+    bool isMediaTypeSupported(const AM_MEDIA_TYPE *type);
+    bool setMediaType(const AM_MEDIA_TYPE *type);
     HRESULT completeConnection(IPin *pin);
     HRESULT connectionEnded();