DirectShow: refactor custom renderer filter

Refactor out some of the filter and pin logic into the
DirectShowBaseFilter and DirectShowPin abstract classes.
This will avoid code duplication when implementing the probe
filter. The existing source filter (for qrc files) can also be
refactored to use these abstract classes.

Change-Id: Iaf141472dea82579ad085b3318624f9a57aa46d8
Reviewed-by: Christian Stromme <christian.stromme@qt.io>

30 files changed, 2324 insertions, 1371 deletions

diff --git a/src/plugins/directshow/camera/camera.pri b/src/plugins/directshow/camera/camera.pri
index c6b16da59..6c67a8fe2 100644
--- a/src/plugins/directshow/camera/camera.pri
+++ b/src/plugins/directshow/camera/camera.pri
@@ -13,7 +13,7 @@ HEADERS += \
     $$PWD/dsvideodevicecontrol.h \
     $$PWD/dsimagecapturecontrol.h \
     $$PWD/dscamerasession.h \
-    $$PWD/directshowglobal.h \
+    $$PWD/directshowcameraglobal.h \
     $$PWD/dscameraviewfindersettingscontrol.h \
     $$PWD/dscameraimageprocessingcontrol.h
 
diff --git a/src/plugins/directshow/camera/directshowglobal.h b/src/plugins/directshow/camera/directshowcameraglobal.h
index 46d161336..75112a090 100644
--- a/src/plugins/directshow/camera/directshowglobal.h
+++ b/src/plugins/directshow/camera/directshowcameraglobal.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef DIRECTSHOWGLOBAL_H
-#define DIRECTSHOWGLOBAL_H
+#ifndef DIRECTSHOWCAMERAGLOBAL_H
+#define DIRECTSHOWCAMERAGLOBAL_H
 
 #include <QtCore/qglobal.h>
 
diff --git a/src/plugins/directshow/camera/dscamerasession.cpp b/src/plugins/directshow/camera/dscamerasession.cpp
index 9e1be9606..4208f934f 100644
--- a/src/plugins/directshow/camera/dscamerasession.cpp
+++ b/src/plugins/directshow/camera/dscamerasession.cpp
@@ -47,7 +47,7 @@
 
 #include "dscamerasession.h"
 #include "dsvideorenderer.h"
-#include "directshowglobal.h"
+#include "directshowcameraglobal.h"
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/plugins/directshow/directshow.pro b/src/plugins/directshow/directshow.pro
index 280b52619..5cdf9d1b6 100644
--- a/src/plugins/directshow/directshow.pro
+++ b/src/plugins/directshow/directshow.pro
@@ -12,6 +12,7 @@ SOURCES += dsserviceplugin.cpp
 
 mingw: DEFINES += NO_DSHOW_STRSAFE
 
+include(helpers/helpers.pri)
 !config_wmf: include(player/player.pri)
 include(camera/camera.pri)
 
diff --git a/src/plugins/directshow/helpers/directshowbasefilter.cpp b/src/plugins/directshow/helpers/directshowbasefilter.cpp
new file mode 100644
index 000000000..fbf0f6204
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowbasefilter.cpp
@@ -0,0 +1,267 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowbasefilter.h"
+
+#include "directshowpinenum.h"
+
+DirectShowBaseFilter::DirectShowBaseFilter()
+    : m_mutex(QMutex::Recursive)
+    , m_state(State_Stopped)
+    , m_graph(NULL)
+    , m_clock(NULL)
+    , m_sink(NULL)
+{
+
+}
+
+DirectShowBaseFilter::~DirectShowBaseFilter()
+{
+    if (m_clock) {
+        m_clock->Release();
+        m_clock = NULL;
+    }
+}
+
+HRESULT DirectShowBaseFilter::getInterface(REFIID riid, void **ppvObject)
+{
+    if (riid == IID_IPersist
+            || riid == IID_IMediaFilter
+            || riid == IID_IBaseFilter) {
+        return GetInterface(static_cast<IBaseFilter *>(this), ppvObject);
+    } else {
+        return DirectShowObject::getInterface(riid, ppvObject);
+    }
+}
+
+HRESULT DirectShowBaseFilter::GetClassID(CLSID *pClassID)
+{
+    *pClassID = CLSID_NULL;
+    return S_OK;
+}
+
+HRESULT DirectShowBaseFilter::NotifyEvent(long eventCode, LONG_PTR eventParam1, LONG_PTR eventParam2)
+{
+    IMediaEventSink *sink = m_sink;
+    if (sink) {
+        if (eventCode == EC_COMPLETE)
+            eventParam2 = (LONG_PTR)(IBaseFilter*)this;
+
+        return sink->Notify(eventCode, eventParam1, eventParam2);
+    } else {
+        return E_NOTIMPL;
+    }
+}
+
+HRESULT DirectShowBaseFilter::Run(REFERENCE_TIME tStart)
+{
+    Q_UNUSED(tStart)
+    QMutexLocker locker(&m_mutex);
+
+    m_startTime = tStart;
+
+    if (m_state == State_Stopped){
+        HRESULT hr = Pause();
+        if (FAILED(hr))
+            return hr;
+    }
+
+    m_state = State_Running;
+
+    return S_OK;
+}
+
+HRESULT DirectShowBaseFilter::Pause()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_state == State_Stopped) {
+        const QList<DirectShowPin *> pinList = pins();
+        for (DirectShowPin *pin : pinList) {
+            if (pin->isConnected()) {
+                HRESULT hr = pin->setActive(true);
+                if (FAILED(hr))
+                    return hr;
+            }
+        }
+    }
+
+    m_state = State_Paused;
+
+    return S_OK;
+}
+
+HRESULT DirectShowBaseFilter::Stop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    HRESULT hr = S_OK;
+
+    if (m_state != State_Stopped) {
+        const QList<DirectShowPin *> pinList = pins();
+        for (DirectShowPin *pin : pinList) {
+            if (pin->isConnected()) {
+                HRESULT hrTmp = pin->setActive(false);
+                if (FAILED(hrTmp) && SUCCEEDED(hr))
+                    hr = hrTmp;
+            }
+        }
+    }
+
+    m_state = State_Stopped;
+
+    return hr;
+}
+
+HRESULT DirectShowBaseFilter::GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
+{
+    Q_UNUSED(dwMilliSecsTimeout);
+
+    if (!pState) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        *pState = m_state;
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowBaseFilter::SetSyncSource(IReferenceClock *pClock)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_clock)
+        m_clock->Release();
+
+    m_clock = pClock;
+
+    if (m_clock)
+        m_clock->AddRef();
+
+    return S_OK;
+}
+
+HRESULT DirectShowBaseFilter::GetSyncSource(IReferenceClock **ppClock)
+{
+    if (!ppClock) {
+        return E_POINTER;
+    } else {
+        if (!m_clock) {
+            *ppClock = 0;
+
+            return S_FALSE;
+        } else {
+            m_clock->AddRef();
+
+            *ppClock = m_clock;
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowBaseFilter::EnumPins(IEnumPins **ppEnum)
+{
+    if (!ppEnum) {
+        return E_POINTER;
+    } else {
+        *ppEnum = new DirectShowPinEnum(this);
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowBaseFilter::FindPin(LPCWSTR Id, IPin **ppPin)
+{
+    if (!ppPin || !Id) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+        const QList<DirectShowPin *> pinList = pins();
+        for (DirectShowPin *pin : pinList) {
+            if (QString::fromWCharArray(Id) == pin->name()) {
+                pin->AddRef();
+                *ppPin = pin;
+                return S_OK;
+            }
+        }
+
+        *ppPin = 0;
+        return VFW_E_NOT_FOUND;
+    }
+}
+
+HRESULT DirectShowBaseFilter::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_filterName = QString::fromWCharArray(pName);
+    m_graph = pGraph;
+    m_sink = NULL;
+
+    if (m_graph) {
+        if (SUCCEEDED(m_graph->QueryInterface(IID_PPV_ARGS(&m_sink))))
+            m_sink->Release(); // we don't keep a reference on it
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowBaseFilter::QueryFilterInfo(FILTER_INFO *pInfo)
+{
+    if (!pInfo) {
+        return E_POINTER;
+    } else {
+        QString name = m_filterName;
+
+        if (name.length() >= MAX_FILTER_NAME)
+            name.truncate(MAX_FILTER_NAME - 1);
+
+        int length = name.toWCharArray(pInfo->achName);
+        pInfo->achName[length] = '\0';
+
+        if (m_graph)
+            m_graph->AddRef();
+
+        pInfo->pGraph = m_graph;
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowBaseFilter::QueryVendorInfo(LPWSTR *pVendorInfo)
+{
+    Q_UNUSED(pVendorInfo);
+    return E_NOTIMPL;
+}
diff --git a/src/plugins/directshow/helpers/directshowbasefilter.h b/src/plugins/directshow/helpers/directshowbasefilter.h
new file mode 100644
index 000000000..cc8588044
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowbasefilter.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWBASEFILTER_H
+#define DIRECTSHOWBASEFILTER_H
+
+#include "directshowpin.h"
+
+QT_USE_NAMESPACE
+
+class DirectShowBaseFilter : public DirectShowObject
+                           , public IBaseFilter
+{
+    DIRECTSHOW_OBJECT
+
+public:
+    DirectShowBaseFilter();
+    virtual ~DirectShowBaseFilter();
+
+    FILTER_STATE state() const { return m_state; }
+    HRESULT NotifyEvent(long eventCode, LONG_PTR eventParam1, LONG_PTR eventParam2);
+
+    virtual QList<DirectShowPin *> pins() = 0;
+
+    // DirectShowObject
+    HRESULT getInterface(const IID &riid, void **ppvObject);
+
+    // IPersist
+    STDMETHODIMP GetClassID(CLSID *pClassID);
+
+    // IMediaFilter
+    STDMETHODIMP Run(REFERENCE_TIME tStart);
+    STDMETHODIMP Pause();
+    STDMETHODIMP Stop();
+
+    STDMETHODIMP GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState);
+
+    STDMETHODIMP SetSyncSource(IReferenceClock *pClock);
+    STDMETHODIMP GetSyncSource(IReferenceClock **ppClock);
+
+    // IBaseFilter
+    STDMETHODIMP EnumPins(IEnumPins **ppEnum);
+    STDMETHODIMP FindPin(LPCWSTR Id, IPin **ppPin);
+
+    STDMETHODIMP JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName);
+
+    STDMETHODIMP QueryFilterInfo(FILTER_INFO *pInfo);
+    STDMETHODIMP QueryVendorInfo(LPWSTR *pVendorInfo);
+
+protected:
+    QMutex m_mutex;
+    FILTER_STATE m_state;
+    IFilterGraph *m_graph;
+    IReferenceClock *m_clock;
+    IMediaEventSink *m_sink;
+    QString m_filterName;
+    REFERENCE_TIME m_startTime;
+
+private:
+    Q_DISABLE_COPY(DirectShowBaseFilter)
+};
+
+#endif // DIRECTSHOWBASEFILTER_H
diff --git a/src/plugins/directshow/player/directshoweventloop.cpp b/src/plugins/directshow/helpers/directshoweventloop.cpp
index 87f969e42..87f969e42 100644
--- a/src/plugins/directshow/player/directshoweventloop.cpp
+++ b/src/plugins/directshow/helpers/directshoweventloop.cpp
diff --git a/src/plugins/directshow/player/directshoweventloop.h b/src/plugins/directshow/helpers/directshoweventloop.h
index 09d986de7..09d986de7 100644
--- a/src/plugins/directshow/player/directshoweventloop.h
+++ b/src/plugins/directshow/helpers/directshoweventloop.h
diff --git a/src/plugins/directshow/player/directshowglobal.h b/src/plugins/directshow/helpers/directshowglobal.h
index f7890c52b..f7890c52b 100644
--- a/src/plugins/directshow/player/directshowglobal.h
+++ b/src/plugins/directshow/helpers/directshowglobal.h
diff --git a/src/plugins/directshow/player/directshowmediatype.cpp b/src/plugins/directshow/helpers/directshowmediatype.cpp
index cbe1753ae..60c0ee040 100644
--- a/src/plugins/directshow/player/directshowmediatype.cpp
+++ b/src/plugins/directshow/helpers/directshowmediatype.cpp
@@ -62,12 +62,48 @@ namespace
         { 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_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}} }
     };
 }
 
+bool DirectShowMediaType::isPartiallySpecified() const
+{
+    return majortype == GUID_NULL || formattype == GUID_NULL;
+}
+
+bool DirectShowMediaType::isCompatibleWith(const DirectShowMediaType *type) const
+{
+    if (type->majortype != GUID_NULL && majortype != type->majortype)
+        return false;
+
+    if (type->subtype != GUID_NULL && subtype != type->subtype)
+        return false;
+
+    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;
+    }
+
+    return true;
+}
+
+void DirectShowMediaType::init(AM_MEDIA_TYPE *type)
+{
+    ZeroMemory((PVOID)type, sizeof(*type));
+    type->lSampleSize = 1;
+    type->bFixedSizeSamples = TRUE;
+}
+
 void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source)
 {
+    if (!target)
+        return;
+
     *target = source;
 
     if (source.cbFormat > 0) {
@@ -97,16 +133,13 @@ void DirectShowMediaType::freeData(AM_MEDIA_TYPE *type)
 
 GUID DirectShowMediaType::convertPixelFormat(QVideoFrame::PixelFormat format)
 {
-    // MEDIASUBTYPE_None;
-    static const GUID none = {
-        0xe436eb8e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };
-
     const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
 
     for (int i = 0; i < count; ++i)
         if (qt_typeLookup[i].pixelFormat == format)
             return qt_typeLookup[i].mediaType;
-    return none;
+
+    return MEDIASUBTYPE_None;
 }
 
 QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &type)
@@ -147,6 +180,19 @@ QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &typ
     return QVideoSurfaceFormat();
 }
 
+QVideoFrame::PixelFormat DirectShowMediaType::pixelFormatFromType(const AM_MEDIA_TYPE &type)
+{
+    const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
+
+    for (int i = 0; i < count; ++i) {
+        if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype)) {
+            return qt_typeLookup[i].pixelFormat;
+        }
+    }
+
+    return QVideoFrame::Format_Invalid;
+}
+
 #define PAD_TO_DWORD(x)  (((x) + 3) & ~3)
 int DirectShowMediaType::bytesPerLine(const QVideoSurfaceFormat &format)
 {
@@ -165,14 +211,14 @@ int DirectShowMediaType::bytesPerLine(const QVideoSurfaceFormat &format)
     case QVideoFrame::Format_UYVY:
         return PAD_TO_DWORD(format.frameWidth() * 2);
     // Planar formats.
+    case QVideoFrame::Format_YV12:
+    case QVideoFrame::Format_YUV420P:
     case QVideoFrame::Format_IMC1:
     case QVideoFrame::Format_IMC2:
     case QVideoFrame::Format_IMC3:
     case QVideoFrame::Format_IMC4:
-    case QVideoFrame::Format_YV12:
     case QVideoFrame::Format_NV12:
-    case QVideoFrame::Format_YUV420P:
-        return PAD_TO_DWORD(format.frameWidth());
+        return format.frameWidth();
     default:
         return 0;
     }
diff --git a/src/plugins/directshow/player/directshowmediatype.h b/src/plugins/directshow/helpers/directshowmediatype.h
index cf5ac73aa..b2b074ccc 100644
--- a/src/plugins/directshow/player/directshowmediatype.h
+++ b/src/plugins/directshow/helpers/directshowmediatype.h
@@ -46,10 +46,12 @@
 
 #include <dvdmedia.h>
 
+QT_USE_NAMESPACE
+
 class DirectShowMediaType : public AM_MEDIA_TYPE
 {
 public:
-    DirectShowMediaType() { memset(this, 0, sizeof(DirectShowMediaType)); }
+    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) {
@@ -58,14 +60,19 @@ public:
         freeData(this); copy(this, other); return *this; }
     ~DirectShowMediaType() { freeData(this); }
 
-    void clear() { freeData(this); memset(this, 0, sizeof(DirectShowMediaType)); }
+    void clear() { freeData(this); init(this); }
+
+    bool isPartiallySpecified() const;
+    bool isCompatibleWith(const DirectShowMediaType *type) const;
 
+    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 deleteType(AM_MEDIA_TYPE *type);
 
     static GUID convertPixelFormat(QVideoFrame::PixelFormat format);
     static QVideoSurfaceFormat formatFromType(const AM_MEDIA_TYPE &type);
+    static QVideoFrame::PixelFormat pixelFormatFromType(const AM_MEDIA_TYPE &type);
 
     static int bytesPerLine(const QVideoSurfaceFormat &format);
 
@@ -73,4 +80,6 @@ private:
     static QVideoSurfaceFormat::Direction scanLineDirection(QVideoFrame::PixelFormat pixelFormat, const BITMAPINFOHEADER &bmiHeader);
 };
 
+Q_DECLARE_TYPEINFO(DirectShowMediaType, Q_MOVABLE_TYPE);
+
 #endif
diff --git a/src/plugins/directshow/helpers/directshowmediatypeenum.cpp b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
new file mode 100644
index 000000000..a1c8b2306
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowmediatypeenum.h"
+
+#include "directshowpin.h"
+
+DirectShowMediaTypeEnum::DirectShowMediaTypeEnum(DirectShowPin *pin)
+    : m_pin(pin)
+    , m_mediaTypes(pin->supportedMediaTypes())
+    , m_index(0)
+{
+    m_pin->AddRef();
+}
+
+DirectShowMediaTypeEnum::DirectShowMediaTypeEnum(const QList<DirectShowMediaType> &types)
+    : m_pin(NULL)
+    , m_mediaTypes(types)
+    , m_index(0)
+{
+}
+
+DirectShowMediaTypeEnum::~DirectShowMediaTypeEnum()
+{
+    if (m_pin)
+        m_pin->Release();
+}
+
+HRESULT DirectShowMediaTypeEnum::getInterface(REFIID riid, void **ppvObject)
+{
+    if (riid == IID_IEnumMediaTypes) {
+        return GetInterface(static_cast<IEnumMediaTypes *>(this), ppvObject);
+    } else {
+        return DirectShowObject::getInterface(riid, ppvObject);
+    }
+}
+
+HRESULT DirectShowMediaTypeEnum::Next(ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched)
+{
+    if (ppMediaTypes && (pcFetched || cMediaTypes == 1)) {
+        ULONG count = qBound<ULONG>(0, cMediaTypes, m_mediaTypes.count() - m_index);
+
+        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));
+        }
+
+        if (pcFetched)
+            *pcFetched = count;
+
+        return count == cMediaTypes ? S_OK : S_FALSE;
+    } else {
+        return E_POINTER;
+    }
+}
+
+HRESULT DirectShowMediaTypeEnum::Skip(ULONG cMediaTypes)
+{
+    m_index = qMin(int(m_index + cMediaTypes), m_mediaTypes.count());
+    return m_index < m_mediaTypes.count() ? S_OK : S_FALSE;
+}
+
+HRESULT DirectShowMediaTypeEnum::Reset()
+{
+    m_index = 0;
+    return S_OK;
+}
+
+HRESULT DirectShowMediaTypeEnum::Clone(IEnumMediaTypes **ppEnum)
+{
+    if (ppEnum) {
+        if (m_pin)
+            *ppEnum = new DirectShowMediaTypeEnum(m_pin);
+        else
+            *ppEnum = new DirectShowMediaTypeEnum(m_mediaTypes);
+        return S_OK;
+    } else {
+        return E_POINTER;
+    }
+}
+
diff --git a/src/plugins/directshow/helpers/directshowmediatypeenum.h b/src/plugins/directshow/helpers/directshowmediatypeenum.h
new file mode 100644
index 000000000..050df0881
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowmediatypeenum.h
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWMEDIATYPEENUM_H
+#define DIRECTSHOWMEDIATYPEENUM_H
+
+#include "directshowobject.h"
+#include <qlist.h>
+
+QT_USE_NAMESPACE
+
+class DirectShowPin;
+class DirectShowMediaType;
+
+class DirectShowMediaTypeEnum : public DirectShowObject
+                              , public IEnumMediaTypes
+{
+    DIRECTSHOW_OBJECT
+
+public:
+    DirectShowMediaTypeEnum(DirectShowPin *pin);
+    DirectShowMediaTypeEnum(const QList<DirectShowMediaType> &types);
+    ~DirectShowMediaTypeEnum();
+
+    // DirectShowObject
+    HRESULT getInterface(REFIID riid, void **ppvObject);
+
+    // IEnumMediaTypes
+    STDMETHODIMP Next(ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched);
+    STDMETHODIMP Skip(ULONG cMediaTypes);
+    STDMETHODIMP Reset();
+    STDMETHODIMP Clone(IEnumMediaTypes **ppEnum);
+
+private:
+    Q_DISABLE_COPY(DirectShowMediaTypeEnum)
+
+    DirectShowPin *m_pin;
+    QList<DirectShowMediaType> m_mediaTypes;
+    int m_index;
+};
+
+#endif // DIRECTSHOWMEDIATYPEENUM_H
diff --git a/src/plugins/directshow/player/directshowmediatypelist.h b/src/plugins/directshow/helpers/directshowobject.cpp
index c6dac0e9b..b9d989f6e 100644
--- a/src/plugins/directshow/player/directshowmediatypelist.h
+++ b/src/plugins/directshow/helpers/directshowobject.cpp
@@ -37,32 +37,47 @@
 **
 ****************************************************************************/
 
-#ifndef DIRECTSHOWMEDIATYPELIST_H
-#define DIRECTSHOWMEDIATYPELIST_H
+#include "directshowobject.h"
 
-#include <dshow.h>
+DirectShowObject::DirectShowObject()
+    : m_ref(1)
+{
+}
 
-#include <QtCore/qvector.h>
+DirectShowObject::~DirectShowObject()
+{
+    Q_ASSERT(m_ref == 0);
+}
 
-class DirectShowMediaTypeList : public IUnknown
+HRESULT DirectShowObject::getInterface(const IID &riid, void **ppvObject)
 {
-public:
-    DirectShowMediaTypeList();
-    virtual ~DirectShowMediaTypeList();
+    Q_UNUSED(riid)
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
 
-    IEnumMediaTypes *createMediaTypeEnum();
+ULONG DirectShowObject::ref()
+{
+    return InterlockedIncrement(&m_ref);
+}
 
-    void setMediaTypes(const QVector<AM_MEDIA_TYPE> &types);
+ULONG DirectShowObject::unref()
+{
+    ULONG ref = InterlockedDecrement(&m_ref);
+    if (ref == 0)
+        delete this;
+
+    return ref;
+}
+
+HRESULT GetInterface(IUnknown *pUnk, void **ppv)
+{
+    if (!ppv)
+        return E_POINTER;
 
-    virtual int currentMediaTypeToken();
-    virtual HRESULT nextMediaType(
-            int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount);
-    virtual HRESULT skipMediaType(int token, int *index, ULONG count);
-    virtual HRESULT cloneMediaType(int token, int index, IEnumMediaTypes **enumeration);
+    *ppv = pUnk;
+    pUnk->AddRef();
 
-private:
-    int m_mediaTypeToken;
-    QVector<AM_MEDIA_TYPE> m_mediaTypes;
-};
+    return S_OK;
+}
 
-#endif
diff --git a/src/plugins/directshow/helpers/directshowobject.h b/src/plugins/directshow/helpers/directshowobject.h
new file mode 100644
index 000000000..3aba06f46
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowobject.h
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWOBJECT_H
+#define DIRECTSHOWOBJECT_H
+
+#include "directshowglobal.h"
+
+QT_USE_NAMESPACE
+
+class DirectShowObject
+{
+public:
+    DirectShowObject();
+    virtual ~DirectShowObject();
+
+    virtual HRESULT getInterface(REFIID riid, void **ppvObject);
+    ULONG ref();
+    ULONG unref();
+
+private:
+    Q_DISABLE_COPY(DirectShowObject)
+
+    volatile LONG m_ref;
+};
+
+HRESULT GetInterface(IUnknown *pUnk, void **ppv);
+
+#define DIRECTSHOW_OBJECT \
+public: \
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv) {          \
+        if (riid == IID_IUnknown)                                   \
+            return GetInterface(reinterpret_cast<IUnknown*>(this), ppv); \
+        else                                                        \
+            return getInterface(riid, ppv);                         \
+    };                                                              \
+    STDMETHODIMP_(ULONG) AddRef() {                                 \
+        return ref();                                               \
+    };                                                              \
+    STDMETHODIMP_(ULONG) Release() {                                \
+        return unref();                                             \
+    };
+
+#endif // DIRECTSHOWOBJECT_H
diff --git a/src/plugins/directshow/helpers/directshowpin.cpp b/src/plugins/directshow/helpers/directshowpin.cpp
new file mode 100644
index 000000000..6cf4da321
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowpin.cpp
@@ -0,0 +1,733 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowpin.h"
+
+#include "directshowmediatype.h"
+#include "directshowbasefilter.h"
+#include "directshowmediatypeenum.h"
+
+#include <qdebug.h>
+
+DirectShowPin::DirectShowPin(DirectShowBaseFilter *filter, const QString &name, PIN_DIRECTION direction)
+    : m_mutex(QMutex::Recursive)
+    , m_filter(filter)
+    , m_name(name)
+    , m_direction(direction)
+    , m_peerPin(NULL)
+{
+}
+
+DirectShowPin::~DirectShowPin()
+{
+
+}
+
+HRESULT DirectShowPin::getInterface(const IID &riid, void **ppvObject)
+{
+    if (riid == IID_IPin)
+        return GetInterface(static_cast<IPin*>(this), ppvObject);
+    else
+        return DirectShowObject::getInterface(riid, ppvObject);
+}
+
+
+
+HRESULT DirectShowPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
+{
+    if (!pReceivePin)
+        return E_POINTER;
+
+    HRESULT hr = E_FAIL;
+    QMutexLocker locker(&m_mutex);
+
+    if (m_peerPin)
+        return VFW_E_ALREADY_CONNECTED;
+    if (m_filter->state() != State_Stopped)
+        return VFW_E_NOT_STOPPED;
+
+    PIN_DIRECTION pd;
+    pReceivePin->QueryDirection(&pd);
+    if (pd == m_direction)
+        return VFW_E_INVALID_DIRECTION;
+
+    const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
+
+    if (type != NULL && !type->isPartiallySpecified()) {
+        // If the type is fully specified, use it
+        hr = tryConnect(pReceivePin, type);
+    } else {
+        IEnumMediaTypes *enumMediaTypes = NULL;
+
+        // First, try the receiving pin's preferred types
+        if (SUCCEEDED(pReceivePin->EnumMediaTypes(&enumMediaTypes))) {
+            hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+            enumMediaTypes->Release();
+        }
+        // Then, try this pin's preferred types
+        if (FAILED(hr) && SUCCEEDED(EnumMediaTypes(&enumMediaTypes))) {
+            hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+            enumMediaTypes->Release();
+        }
+    }
+
+    if (FAILED(hr)) {
+        return ((hr != E_FAIL) && (hr != E_INVALIDARG) && (hr != VFW_E_TYPE_NOT_ACCEPTED))
+                ? hr : VFW_E_NO_ACCEPTABLE_TYPES;
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const DirectShowMediaType *partialType, IEnumMediaTypes *enumMediaTypes)
+{
+    HRESULT hr = enumMediaTypes->Reset();
+    if (FAILED(hr))
+        return hr;
+
+    DirectShowMediaType *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;) {
+
+        if (mediaType && (partialType == NULL || mediaType->isCompatibleWith(partialType))) {
+            hr = tryConnect(pin, mediaType);
+
+            if (FAILED(hr) && (hr != E_FAIL)
+                    && (hr != E_INVALIDARG)
+                    && (hr != VFW_E_TYPE_NOT_ACCEPTED)) {
+                hrFailure = hr;
+            }
+        }
+
+        if (mediaType)
+            DirectShowMediaType::deleteType(mediaType);
+
+        if (SUCCEEDED(hr))
+            return S_OK;
+    }
+
+    return hrFailure;
+}
+
+HRESULT DirectShowPin::tryConnect(IPin *pin, const DirectShowMediaType *type)
+{
+    if (!isMediaTypeSupported(type))
+        return VFW_E_TYPE_NOT_ACCEPTED;
+
+    m_peerPin = pin;
+    m_peerPin->AddRef();
+
+    HRESULT hr;
+    if (!setMediaType(type)) {
+        hr = VFW_E_TYPE_NOT_ACCEPTED;
+    } else {
+        hr = pin->ReceiveConnection(this, type);
+        if (SUCCEEDED(hr)) {
+            hr = completeConnection(pin);
+            if (FAILED(hr))
+                pin->Disconnect();
+        }
+    }
+
+    if (FAILED(hr)) {
+        connectionEnded();
+        m_peerPin->Release();
+        m_peerPin = NULL;
+        setMediaType(NULL);
+        return hr;
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
+{
+    if (!pConnector || !pmt)
+        return E_POINTER;
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_peerPin)
+        return VFW_E_ALREADY_CONNECTED;
+    if (m_filter->state() != State_Stopped)
+        return VFW_E_NOT_STOPPED;
+
+    PIN_DIRECTION pd;
+    pConnector->QueryDirection(&pd);
+    if (pd == m_direction)
+        return VFW_E_INVALID_DIRECTION;
+
+    const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
+    if (!isMediaTypeSupported(type))
+        return VFW_E_TYPE_NOT_ACCEPTED;
+
+    m_peerPin = pConnector;
+    m_peerPin->AddRef();
+
+    HRESULT hr;
+    if (!setMediaType(type))
+        hr = VFW_E_TYPE_NOT_ACCEPTED;
+    else
+        hr = completeConnection(pConnector);
+
+    if (FAILED(hr)) {
+        connectionEnded();
+        m_peerPin->Release();
+        m_peerPin = NULL;
+        setMediaType(NULL);
+        return hr;
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowPin::Disconnect()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_filter->state() != State_Stopped)
+        return VFW_E_NOT_STOPPED;
+
+    if (m_peerPin) {
+        HRESULT hr = connectionEnded();
+        if (FAILED(hr))
+            return hr;
+
+        m_peerPin->Release();
+        m_peerPin = NULL;
+
+        setMediaType(NULL);
+
+        return S_OK;
+    }
+
+    return S_FALSE;
+}
+
+HRESULT DirectShowPin::ConnectedTo(IPin **ppPin)
+{
+    if (!ppPin) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            *ppPin = 0;
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            m_peerPin->AddRef();
+            *ppPin = m_peerPin;
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
+{
+    if (!pmt) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            DirectShowMediaType::init(pmt);
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            DirectShowMediaType::copy(pmt, m_mediaType);
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowPin::QueryPinInfo(PIN_INFO *pInfo)
+{
+    if (!pInfo) {
+        return E_POINTER;
+    } else {
+        pInfo->pFilter = m_filter;
+        if (m_filter) {
+            m_filter->AddRef();
+        }
+        pInfo->dir = m_direction;
+
+        QString name = m_name;
+        if (name.length() >= MAX_PIN_NAME)
+            name.truncate(MAX_PIN_NAME - 1);
+        int length = name.toWCharArray(pInfo->achName);
+        pInfo->achName[length] = '\0';
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowPin::QueryId(LPWSTR *Id)
+{
+    if (!Id) {
+        return E_POINTER;
+    } else {
+        const int bytes = (m_name.length() + 1) * 2;
+        *Id = static_cast<LPWSTR>(::CoTaskMemAlloc(bytes));
+        ::memcpy(*Id, m_name.utf16(), bytes);
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
+{
+    if (!pmt)
+        return E_POINTER;
+
+    if (!isMediaTypeSupported(reinterpret_cast<const DirectShowMediaType*>(pmt)))
+        return S_FALSE;
+
+    return S_OK;
+}
+
+HRESULT DirectShowPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
+{
+    if (!ppEnum) {
+        return E_POINTER;
+    } else {
+        *ppEnum = new DirectShowMediaTypeEnum(this);
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
+{
+    Q_UNUSED(apPin);
+    Q_UNUSED(nPin);
+    return E_NOTIMPL;
+}
+
+HRESULT DirectShowPin::EndOfStream()
+{
+    return S_OK;
+}
+
+HRESULT DirectShowPin::BeginFlush()
+{
+    return E_UNEXPECTED;
+}
+
+HRESULT DirectShowPin::EndFlush()
+{
+    return E_UNEXPECTED;
+}
+
+HRESULT DirectShowPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
+{
+    Q_UNUSED(tStart);
+    Q_UNUSED(tStop);
+    Q_UNUSED(dRate);
+    return S_OK;
+}
+
+HRESULT DirectShowPin::QueryDirection(PIN_DIRECTION *pPinDir)
+{
+    if (!pPinDir) {
+        return E_POINTER;
+    } else {
+        *pPinDir = m_direction;
+        return S_OK;
+    }
+}
+
+QList<DirectShowMediaType> DirectShowPin::supportedMediaTypes()
+{
+    return QList<DirectShowMediaType>();
+}
+
+bool DirectShowPin::setMediaType(const DirectShowMediaType *type)
+{
+    if (!type)
+        m_mediaType.clear();
+    else
+        m_mediaType = *type;
+
+    return true;
+}
+
+HRESULT DirectShowPin::completeConnection(IPin *pin)
+{
+    Q_UNUSED(pin)
+    return S_OK;
+}
+
+HRESULT DirectShowPin::connectionEnded()
+{
+    return S_OK;
+}
+
+HRESULT DirectShowPin::setActive(bool active)
+{
+    Q_UNUSED(active)
+    return S_OK;
+}
+
+
+/* DirectShowOutputPin */
+
+DirectShowOutputPin::DirectShowOutputPin(DirectShowBaseFilter *filter, const QString &name)
+    : DirectShowPin(filter, name, PINDIR_OUTPUT)
+    , m_allocator(NULL)
+    , m_inputPin(NULL)
+{
+
+}
+
+DirectShowOutputPin::~DirectShowOutputPin()
+{
+}
+
+HRESULT DirectShowOutputPin::completeConnection(IPin *pin)
+{
+    if (!pin)
+        return E_POINTER;
+
+    Q_ASSERT(m_inputPin == NULL);
+    Q_ASSERT(m_allocator == NULL);
+
+    HRESULT hr = pin->QueryInterface(IID_PPV_ARGS(&m_inputPin));
+    if (FAILED(hr))
+        return hr;
+
+    ALLOCATOR_PROPERTIES prop;
+    ZeroMemory(&prop, sizeof(prop));
+    m_inputPin->GetAllocatorRequirements(&prop);
+    if (prop.cBuffers <= 0)
+        prop.cBuffers = 1;
+    if (prop.cbBuffer <= 0)
+        prop.cbBuffer = 1;
+    if (prop.cbAlign <= 0)
+        prop.cbAlign = 1;
+
+    // Use the connected input pin's allocator if it has one
+    hr = m_inputPin->GetAllocator(&m_allocator);
+    if (SUCCEEDED(hr)) {
+        ALLOCATOR_PROPERTIES actualProperties;
+        hr = m_allocator->SetProperties(&prop, &actualProperties);
+
+        if (SUCCEEDED(hr)) {
+            hr = m_inputPin->NotifyAllocator(m_allocator, FALSE);
+            if (SUCCEEDED(hr))
+                return S_OK;
+        }
+
+        m_allocator->Release();
+        m_allocator = NULL;
+    }
+
+    // Otherwise, allocate its own allocator
+    m_allocator = com_new<IMemAllocator>(CLSID_MemoryAllocator);
+    if (!m_allocator) {
+        hr = E_OUTOFMEMORY;
+    } else {
+        ALLOCATOR_PROPERTIES actualProperties;
+        hr = m_allocator->SetProperties(&prop, &actualProperties);
+
+        if (SUCCEEDED(hr)) {
+            hr = m_inputPin->NotifyAllocator(m_allocator, FALSE);
+            if (SUCCEEDED(hr))
+                return S_OK;
+        }
+
+        m_allocator->Release();
+        m_allocator = NULL;
+    }
+
+    return hr;
+}
+
+HRESULT DirectShowOutputPin::connectionEnded()
+{
+    if (m_allocator) {
+        HRESULT hr = m_allocator->Decommit();
+        if (FAILED(hr))
+            return hr;
+
+        m_allocator->Release();
+        m_allocator = NULL;
+    }
+
+    if (m_inputPin) {
+        m_inputPin->Release();
+        m_inputPin = NULL;
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowOutputPin::setActive(bool active)
+{
+    if (!m_allocator)
+        return VFW_E_NO_ALLOCATOR;
+
+    return active ? m_allocator->Commit()
+                  : m_allocator->Decommit();
+}
+
+HRESULT DirectShowOutputPin::EndOfStream()
+{
+    return E_UNEXPECTED;
+}
+
+
+/* DirectShowInputPin */
+
+DirectShowInputPin::DirectShowInputPin(DirectShowBaseFilter *filter, const QString &name)
+    : DirectShowPin(filter, name, PINDIR_INPUT)
+    , m_allocator(NULL)
+    , m_flushing(false)
+    , m_inErrorState(false)
+{
+    ZeroMemory(&m_sampleProperties, sizeof(m_sampleProperties));
+}
+
+DirectShowInputPin::~DirectShowInputPin()
+{
+
+}
+
+HRESULT DirectShowInputPin::getInterface(const IID &riid, void **ppvObject)
+{
+    if (riid == IID_IMemInputPin)
+        return GetInterface(static_cast<IMemInputPin*>(this), ppvObject);
+    else
+        return DirectShowPin::getInterface(riid, ppvObject);
+}
+
+HRESULT DirectShowInputPin::connectionEnded()
+{
+    if (m_allocator) {
+        HRESULT hr = m_allocator->Decommit();
+        if (FAILED(hr))
+            return hr;
+
+        m_allocator->Release();
+        m_allocator = NULL;
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::setActive(bool active)
+{
+    if (!active) {
+        m_inErrorState = false;
+
+        if (!m_allocator)
+            return VFW_E_NO_ALLOCATOR;
+
+        m_flushing = false;
+        return m_allocator->Decommit();
+    }
+
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::EndOfStream()
+{
+    if (m_filter->state() == State_Stopped)
+        return VFW_E_WRONG_STATE;
+    if (m_flushing)
+        return S_FALSE;
+    if (m_inErrorState)
+        return VFW_E_RUNTIME_ERROR;
+
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::BeginFlush()
+{
+    QMutexLocker locker(&m_mutex);
+    m_flushing = true;
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::EndFlush()
+{
+    QMutexLocker locker(&m_mutex);
+    m_flushing = false;
+    m_inErrorState = false;
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::GetAllocator(IMemAllocator **ppAllocator)
+{
+    if (!ppAllocator)
+        return E_POINTER;
+
+    QMutexLocker locker(&m_mutex);
+
+    if (!m_allocator) {
+        m_allocator = com_new<IMemAllocator>(CLSID_MemoryAllocator);;
+        if (!m_allocator)
+            return E_OUTOFMEMORY;
+    }
+
+    *ppAllocator = m_allocator;
+    m_allocator->AddRef();
+
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly)
+{
+    Q_UNUSED(bReadOnly)
+
+    if (!pAllocator)
+        return E_POINTER;
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_allocator)
+        m_allocator->Release();
+
+    m_allocator = pAllocator;
+    m_allocator->AddRef();
+
+    return S_OK;
+}
+
+HRESULT DirectShowInputPin::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps)
+{
+    Q_UNUSED(pProps)
+    return E_NOTIMPL;
+}
+
+HRESULT DirectShowInputPin::Receive(IMediaSample *pSample)
+{
+    if (!pSample)
+        return E_POINTER;
+    if (m_filter->state() == State_Stopped)
+        return VFW_E_WRONG_STATE;
+    if (m_flushing)
+        return S_FALSE;
+    if (m_inErrorState)
+        return VFW_E_RUNTIME_ERROR;
+
+    HRESULT hr = S_OK;
+
+    IMediaSample2 *sample2;
+    if (SUCCEEDED(pSample->QueryInterface(IID_PPV_ARGS(&sample2)))) {
+        hr = sample2->GetProperties(sizeof(m_sampleProperties), (PBYTE)&m_sampleProperties);
+        sample2->Release();
+        if (FAILED(hr))
+            return hr;
+    } else {
+        m_sampleProperties.cbData = sizeof(m_sampleProperties);
+        m_sampleProperties.dwTypeSpecificFlags = 0;
+        m_sampleProperties.dwStreamId = AM_STREAM_MEDIA;
+        m_sampleProperties.dwSampleFlags = 0;
+        if (pSample->IsDiscontinuity() == S_OK)
+            m_sampleProperties.dwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
+        if (pSample->IsPreroll() == S_OK)
+            m_sampleProperties.dwSampleFlags |= AM_SAMPLE_PREROLL;
+        if (pSample->IsSyncPoint() == S_OK)
+            m_sampleProperties.dwSampleFlags |= AM_SAMPLE_SPLICEPOINT;
+        if (SUCCEEDED(pSample->GetTime(&m_sampleProperties.tStart,
+                                       &m_sampleProperties.tStop))) {
+            m_sampleProperties.dwSampleFlags |= AM_SAMPLE_TIMEVALID | AM_SAMPLE_STOPVALID;
+        }
+        if (pSample->GetMediaType(&m_sampleProperties.pMediaType) == S_OK)
+            m_sampleProperties.dwSampleFlags |= AM_SAMPLE_TYPECHANGED;
+        pSample->GetPointer(&m_sampleProperties.pbBuffer);
+        m_sampleProperties.lActual = pSample->GetActualDataLength();
+        m_sampleProperties.cbBuffer = pSample->GetSize();
+    }
+
+
+    if (!(m_sampleProperties.dwSampleFlags & AM_SAMPLE_TYPECHANGED))
+        return S_OK;
+
+    if (isMediaTypeSupported(reinterpret_cast<DirectShowMediaType*>(m_sampleProperties.pMediaType)))
+        return S_OK;
+
+    m_inErrorState = true;
+    EndOfStream();
+    m_filter->NotifyEvent(EC_ERRORABORT, VFW_E_TYPE_NOT_ACCEPTED, 0);
+    return VFW_E_INVALIDMEDIATYPE;
+}
+
+HRESULT DirectShowInputPin::ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed)
+{
+    if (!pSamples || !nSamplesProcessed)
+        return E_POINTER;
+
+    HRESULT hr = S_OK;
+    *nSamplesProcessed = 0;
+    while (nSamples-- > 0) {
+         hr = Receive(pSamples[*nSamplesProcessed]);
+         if (hr != S_OK)
+             break;
+         (*nSamplesProcessed)++;
+    }
+    return hr;
+}
+
+HRESULT DirectShowInputPin::ReceiveCanBlock()
+{
+    int outputPins = 0;
+
+    const QList<DirectShowPin *> pinList = m_filter->pins();
+    for (DirectShowPin *pin : pinList) {
+        PIN_DIRECTION pd;
+        HRESULT hr = pin->QueryDirection(&pd);
+        if (FAILED(hr))
+            return hr;
+
+        if (pd == PINDIR_OUTPUT) {
+            IPin *connected;
+            hr = pin->ConnectedTo(&connected);
+            if (SUCCEEDED(hr)) {
+                ++outputPins;
+                IMemInputPin *inputPin;
+                hr = connected->QueryInterface(IID_PPV_ARGS(&inputPin));
+                connected->Release();
+                if (SUCCEEDED(hr)) {
+                    hr = inputPin->ReceiveCanBlock();
+                    inputPin->Release();
+                    if (hr != S_FALSE)
+                        return S_OK;
+                } else {
+                    return S_OK;
+                }
+            }
+        }
+    }
+
+    return outputPins == 0 ? S_OK : S_FALSE;
+}
diff --git a/src/plugins/directshow/helpers/directshowpin.h b/src/plugins/directshow/helpers/directshowpin.h
new file mode 100644
index 000000000..823223956
--- /dev/null
+++ b/src/plugins/directshow/helpers/directshowpin.h
@@ -0,0 +1,184 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWPIN_H
+#define DIRECTSHOWPIN_H
+
+#include "directshowobject.h"
+
+#include "directshowmediatype.h"
+#include <qstring.h>
+#include <qmutex.h>
+
+QT_USE_NAMESPACE
+
+class DirectShowBaseFilter;
+
+class DirectShowPin : public DirectShowObject
+                    , public IPin
+{
+    DIRECTSHOW_OBJECT
+
+public:
+    virtual ~DirectShowPin();
+
+    QString name() const { return m_name; }
+    bool isConnected() const { return m_peerPin != NULL; }
+
+    virtual bool isMediaTypeSupported(const DirectShowMediaType *type) = 0;
+    virtual QList<DirectShowMediaType> supportedMediaTypes();
+    virtual bool setMediaType(const DirectShowMediaType *type);
+
+    virtual HRESULT completeConnection(IPin *pin);
+    virtual HRESULT connectionEnded();
+
+    virtual HRESULT setActive(bool active);
+
+    // DirectShowObject
+    HRESULT getInterface(REFIID riid, void **ppvObject);
+
+    // IPin
+    STDMETHODIMP Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
+    STDMETHODIMP ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
+    STDMETHODIMP Disconnect();
+    STDMETHODIMP ConnectedTo(IPin **ppPin);
+
+    STDMETHODIMP ConnectionMediaType(AM_MEDIA_TYPE *pmt);
+
+    STDMETHODIMP QueryPinInfo(PIN_INFO *pInfo);
+    STDMETHODIMP QueryId(LPWSTR *Id);
+
+    STDMETHODIMP QueryAccept(const AM_MEDIA_TYPE *pmt);
+
+    STDMETHODIMP EnumMediaTypes(IEnumMediaTypes **ppEnum);
+
+    STDMETHODIMP QueryInternalConnections(IPin **apPin, ULONG *nPin);
+
+    STDMETHODIMP EndOfStream();
+
+    STDMETHODIMP BeginFlush();
+    STDMETHODIMP EndFlush();
+
+    STDMETHODIMP NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
+
+    STDMETHODIMP QueryDirection(PIN_DIRECTION *pPinDir);
+
+protected:
+    DirectShowPin(DirectShowBaseFilter *filter, const QString &name, PIN_DIRECTION direction);
+
+    QMutex m_mutex;
+
+    DirectShowBaseFilter *m_filter;
+    QString m_name;
+    PIN_DIRECTION m_direction;
+
+    IPin *m_peerPin;
+    DirectShowMediaType m_mediaType;
+
+private:
+    Q_DISABLE_COPY(DirectShowPin)
+    HRESULT tryMediaTypes(IPin *pin, const DirectShowMediaType *type, IEnumMediaTypes *enumMediaTypes);
+    HRESULT tryConnect(IPin *pin, const DirectShowMediaType *type);
+};
+
+
+class DirectShowOutputPin : public DirectShowPin
+{
+    DIRECTSHOW_OBJECT
+
+public:
+    virtual ~DirectShowOutputPin();
+
+    // DirectShowPin
+    virtual HRESULT completeConnection(IPin *pin);
+    virtual HRESULT connectionEnded();
+    virtual HRESULT setActive(bool active);
+
+    // IPin
+    STDMETHODIMP EndOfStream();
+
+protected:
+    DirectShowOutputPin(DirectShowBaseFilter *filter, const QString &name);
+
+    IMemAllocator *m_allocator;
+    IMemInputPin *m_inputPin;
+
+private:
+    Q_DISABLE_COPY(DirectShowOutputPin)
+};
+
+
+class DirectShowInputPin : public DirectShowPin
+                         , public IMemInputPin
+{
+    DIRECTSHOW_OBJECT
+
+public:
+    virtual ~DirectShowInputPin();
+
+    const AM_SAMPLE2_PROPERTIES *currentSampleProperties() const { return &m_sampleProperties; }
+
+    // DirectShowObject
+    HRESULT getInterface(REFIID riid, void **ppvObject);
+
+    // DirectShowPin
+    HRESULT connectionEnded();
+    HRESULT setActive(bool active);
+
+    // IPin
+    STDMETHODIMP EndOfStream();
+    STDMETHODIMP BeginFlush();
+    STDMETHODIMP EndFlush();
+
+    // IMemInputPin
+    STDMETHODIMP GetAllocator(IMemAllocator **ppAllocator);
+    STDMETHODIMP NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly);
+    STDMETHODIMP GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps);
+
+    STDMETHODIMP Receive(IMediaSample *pSample);
+    STDMETHODIMP ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed);
+    STDMETHODIMP ReceiveCanBlock();
+
+protected:
+    DirectShowInputPin(DirectShowBaseFilter *filter, const QString &name);
+
+    IMemAllocator *m_allocator;
+    bool m_flushing;
+    bool m_inErrorState;
+    AM_SAMPLE2_PROPERTIES m_sampleProperties;
+
+private:
+    Q_DISABLE_COPY(DirectShowInputPin)
+};
+
+#endif // DIRECTSHOWPIN_H
diff --git a/src/plugins/directshow/player/directshowpinenum.cpp b/src/plugins/directshow/helpers/directshowpinenum.cpp
index 7ef986a26..61aca8b9c 100644
--- a/src/plugins/directshow/player/directshowpinenum.cpp
+++ b/src/plugins/directshow/helpers/directshowpinenum.cpp
@@ -38,10 +38,22 @@
 ****************************************************************************/
 
 #include "directshowpinenum.h"
+#include "directshowbasefilter.h"
 
+DirectShowPinEnum::DirectShowPinEnum(DirectShowBaseFilter *filter)
+    : m_filter(filter)
+    , m_index(0)
+{
+    m_filter->AddRef();
+    const QList<DirectShowPin *> pinList = filter->pins();
+    for (DirectShowPin *pin : pinList) {
+        pin->AddRef();
+        m_pins.append(pin);
+    }
+}
 
 DirectShowPinEnum::DirectShowPinEnum(const QList<IPin *> &pins)
-    : m_ref(1)
+    : m_filter(NULL)
     , m_pins(pins)
     , m_index(0)
 {
@@ -53,40 +65,19 @@ DirectShowPinEnum::~DirectShowPinEnum()
 {
     for (IPin *pin : qAsConst(m_pins))
         pin->Release();
+    if (m_filter)
+        m_filter->Release();
 }
 
-HRESULT DirectShowPinEnum::QueryInterface(REFIID riid, void **ppvObject)
+HRESULT DirectShowPinEnum::getInterface(REFIID riid, void **ppvObject)
 {
-    if (riid == IID_IUnknown
-            || riid == IID_IEnumPins) {
-        AddRef();
-
-        *ppvObject = static_cast<IEnumPins *>(this);
-
-        return S_OK;
+    if (riid == IID_IEnumPins) {
+        return GetInterface(static_cast<IEnumPins *>(this), ppvObject);
     } else {
-        *ppvObject = 0;
-
-        return E_NOINTERFACE;
+        return DirectShowObject::getInterface(riid, ppvObject);
     }
 }
 
-ULONG DirectShowPinEnum::AddRef()
-{
-    return InterlockedIncrement(&m_ref);
-}
-
-ULONG DirectShowPinEnum::Release()
-{
-    ULONG ref = InterlockedDecrement(&m_ref);
-
-    if (ref == 0) {
-        delete this;
-    }
-
-    return ref;
-}
-
 HRESULT DirectShowPinEnum::Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched)
 {
     if (ppPins && (pcFetched || cPins == 1)) {
@@ -123,7 +114,10 @@ HRESULT DirectShowPinEnum::Reset()
 HRESULT DirectShowPinEnum::Clone(IEnumPins **ppEnum)
 {
     if (ppEnum) {
-        *ppEnum = new DirectShowPinEnum(m_pins);
+        if (m_filter)
+            *ppEnum = new DirectShowPinEnum(m_filter);
+        else
+            *ppEnum = new DirectShowPinEnum(m_pins);
 
         return S_OK;
     } else {
diff --git a/src/plugins/directshow/player/directshowpinenum.h b/src/plugins/directshow/helpers/directshowpinenum.h
index 8859f49a5..84c2a7579 100644
--- a/src/plugins/directshow/player/directshowpinenum.h
+++ b/src/plugins/directshow/helpers/directshowpinenum.h
@@ -43,27 +43,35 @@
 #include <dshow.h>
 
 #include <QtCore/qlist.h>
+#include "directshowpin.h"
 
+QT_USE_NAMESPACE
 
-class DirectShowPinEnum : public IEnumPins
+class DirectShowBaseFilter;
+
+class DirectShowPinEnum : public DirectShowObject
+                        , public IEnumPins
 {
+    DIRECTSHOW_OBJECT
+
 public:
+    DirectShowPinEnum(DirectShowBaseFilter *filter);
     DirectShowPinEnum(const QList<IPin *> &pins);
-    virtual ~DirectShowPinEnum();
+    ~DirectShowPinEnum();
 
-    // IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
-    ULONG STDMETHODCALLTYPE AddRef();
-    ULONG STDMETHODCALLTYPE Release();
+    // DirectShowObject
+    HRESULT getInterface(REFIID riid, void **ppvObject);
 
     // IEnumPins
-    HRESULT STDMETHODCALLTYPE Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched);
-    HRESULT STDMETHODCALLTYPE Skip(ULONG cPins);
-    HRESULT STDMETHODCALLTYPE Reset();
-    HRESULT STDMETHODCALLTYPE Clone(IEnumPins **ppEnum);
+    STDMETHODIMP Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched);
+    STDMETHODIMP Skip(ULONG cPins);
+    STDMETHODIMP Reset();
+    STDMETHODIMP Clone(IEnumPins **ppEnum);
 
 private:
-    LONG m_ref;
+    Q_DISABLE_COPY(DirectShowPinEnum)
+
+    DirectShowBaseFilter *m_filter;
     QList<IPin *> m_pins;
     int m_index;
 };
diff --git a/src/plugins/directshow/player/mediasamplevideobuffer.cpp b/src/plugins/directshow/helpers/directshowvideobuffer.cpp
index 58b146a89..3204e9f7e 100644
--- a/src/plugins/directshow/player/mediasamplevideobuffer.cpp
+++ b/src/plugins/directshow/helpers/directshowvideobuffer.cpp
@@ -37,9 +37,9 @@
 **
 ****************************************************************************/
 
-#include "mediasamplevideobuffer.h"
+#include "directshowvideobuffer.h"
 
-MediaSampleVideoBuffer::MediaSampleVideoBuffer(IMediaSample *sample, int bytesPerLine)
+DirectShowVideoBuffer::DirectShowVideoBuffer(IMediaSample *sample, int bytesPerLine)
     : QAbstractVideoBuffer(NoHandle)
     , m_sample(sample)
     , m_bytesPerLine(bytesPerLine)
@@ -48,12 +48,12 @@ MediaSampleVideoBuffer::MediaSampleVideoBuffer(IMediaSample *sample, int bytesPe
     m_sample->AddRef();
 }
 
-MediaSampleVideoBuffer::~MediaSampleVideoBuffer()
+DirectShowVideoBuffer::~DirectShowVideoBuffer()
 {
     m_sample->Release();
 }
 
-uchar *MediaSampleVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPerLine)
+uchar *DirectShowVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPerLine)
 {
     if (m_mapMode == NotMapped && mode != NotMapped) {
         if (numBytes)
@@ -73,12 +73,12 @@ uchar *MediaSampleVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPerLin
     return 0;
 }
 
-void MediaSampleVideoBuffer::unmap()
+void DirectShowVideoBuffer::unmap()
 {
     m_mapMode = NotMapped;
 }
 
-QAbstractVideoBuffer::MapMode MediaSampleVideoBuffer::mapMode() const
+QAbstractVideoBuffer::MapMode DirectShowVideoBuffer::mapMode() const
 {
     return m_mapMode;
 }
diff --git a/src/plugins/directshow/player/mediasamplevideobuffer.h b/src/plugins/directshow/helpers/directshowvideobuffer.h
index 6ec1470c5..10089c75a 100644
--- a/src/plugins/directshow/player/mediasamplevideobuffer.h
+++ b/src/plugins/directshow/helpers/directshowvideobuffer.h
@@ -37,18 +37,18 @@
 **
 ****************************************************************************/
 
-#ifndef MEDIASAMPLEVIDEOBUFFER_H
-#define MEDIASAMPLEVIDEOBUFFER_H
+#ifndef DIRECTSHOWVIDEOBUFFER_H
+#define DIRECTSHOWVIDEOBUFFER_H
 
 #include <dshow.h>
 
 #include <qabstractvideobuffer.h>
 
-class MediaSampleVideoBuffer : public QAbstractVideoBuffer
+class DirectShowVideoBuffer : public QAbstractVideoBuffer
 {
 public:
-    MediaSampleVideoBuffer(IMediaSample *sample, int bytesPerLine);
-    ~MediaSampleVideoBuffer();
+    DirectShowVideoBuffer(IMediaSample *sample, int bytesPerLine);
+    ~DirectShowVideoBuffer();
 
     IMediaSample *sample() { return m_sample; }
 
diff --git a/src/plugins/directshow/helpers/helpers.pri b/src/plugins/directshow/helpers/helpers.pri
new file mode 100644
index 000000000..b3743a680
--- /dev/null
+++ b/src/plugins/directshow/helpers/helpers.pri
@@ -0,0 +1,22 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/directshowbasefilter.h \
+    $$PWD/directshoweventloop.h \
+    $$PWD/directshowglobal.h \
+    $$PWD/directshowmediatype.h \
+    $$PWD/directshowmediatypeenum.h \
+    $$PWD/directshowobject.h \
+    $$PWD/directshowpin.h \
+    $$PWD/directshowpinenum.h \
+    $$PWD/directshowvideobuffer.h
+
+SOURCES += \
+    $$PWD/directshowbasefilter.cpp \
+    $$PWD/directshoweventloop.cpp \
+    $$PWD/directshowmediatype.cpp \
+    $$PWD/directshowmediatypeenum.cpp \
+    $$PWD/directshowobject.cpp \
+    $$PWD/directshowpin.cpp \
+    $$PWD/directshowpinenum.cpp \
+    $$PWD/directshowvideobuffer.cpp
diff --git a/src/plugins/directshow/player/directshowiosource.cpp b/src/plugins/directshow/player/directshowiosource.cpp
index 6dee14fb0..9e71f34d0 100644
--- a/src/plugins/directshow/player/directshowiosource.cpp
+++ b/src/plugins/directshow/player/directshowiosource.cpp
@@ -41,6 +41,7 @@
 
 #include "directshowglobal.h"
 #include "directshowmediatype.h"
+#include "directshowmediatypeenum.h"
 #include "directshowpinenum.h"
 
 #include <QtCore/qcoreapplication.h>
@@ -64,8 +65,6 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
     , m_peerPin(0)
     , m_pinId(QLatin1String("Data"))
 {
-    QVector<AM_MEDIA_TYPE> mediaTypes;
-
     AM_MEDIA_TYPE type =
     {
         MEDIATYPE_Stream,  // majortype
@@ -83,10 +82,8 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
 
     for (int i = 0; i < count; ++i) {
         type.subtype = directshow_subtypes[i];
-        mediaTypes.append(type);
+        m_supportedMediaTypes.append(type);
     }
-
-    setMediaTypes(mediaTypes);
 }
 
 DirectShowIOSource::~DirectShowIOSource()
@@ -566,7 +563,7 @@ HRESULT DirectShowIOSource::EnumMediaTypes(IEnumMediaTypes **ppEnum)
     if (!ppEnum) {
         return E_POINTER;
     } else {
-        *ppEnum = createMediaTypeEnum();
+        *ppEnum = new DirectShowMediaTypeEnum(m_supportedMediaTypes);
 
         return S_OK;
     }
diff --git a/src/plugins/directshow/player/directshowiosource.h b/src/plugins/directshow/player/directshowiosource.h
index bb90ba398..c2add6062 100644
--- a/src/plugins/directshow/player/directshowiosource.h
+++ b/src/plugins/directshow/player/directshowiosource.h
@@ -43,13 +43,11 @@
 #include "directshowglobal.h"
 #include "directshowioreader.h"
 #include "directshowmediatype.h"
-#include "directshowmediatypelist.h"
 
 #include <QtCore/qfile.h>
 
 class DirectShowIOSource
-    : public DirectShowMediaTypeList
-    , public IBaseFilter
+    : public IBaseFilter
     , public IAMFilterMiscFlags
     , public IPin
 {
@@ -128,6 +126,7 @@ private:
     IMemAllocator *m_allocator;
     IPin *m_peerPin;
     DirectShowMediaType m_mediaType;
+    QList<DirectShowMediaType> m_supportedMediaTypes;
     QString m_filterName;
     const QString m_pinId;
     QMutex m_mutex;
diff --git a/src/plugins/directshow/player/directshowmediatypelist.cpp b/src/plugins/directshow/player/directshowmediatypelist.cpp
deleted file mode 100644
index 8d5e572ca..000000000
--- a/src/plugins/directshow/player/directshowmediatypelist.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "directshowmediatypelist.h"
-
-#include "directshowmediatype.h"
-#include "videosurfacefilter.h"
-
-
-class DirectShowMediaTypeEnum : public IEnumMediaTypes
-{
-public:
-    DirectShowMediaTypeEnum(DirectShowMediaTypeList *list, int token, int index = 0);
-    virtual ~DirectShowMediaTypeEnum();
-
-    // IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
-    ULONG STDMETHODCALLTYPE AddRef();
-    ULONG STDMETHODCALLTYPE Release();
-
-    // IEnumMediaTypes
-    HRESULT STDMETHODCALLTYPE Next(
-            ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched);
-    HRESULT STDMETHODCALLTYPE Skip(ULONG cMediaTypes);
-    HRESULT STDMETHODCALLTYPE Reset();
-
-    HRESULT STDMETHODCALLTYPE Clone(IEnumMediaTypes **ppEnum);
-
-private:
-    LONG m_ref;
-    DirectShowMediaTypeList *m_list;
-    int m_mediaTypeToken;
-    int m_index;
-};
-
-
-DirectShowMediaTypeEnum::DirectShowMediaTypeEnum(
-        DirectShowMediaTypeList *list, int token, int index)
-    : m_ref(1)
-    , m_list(list)
-    , m_mediaTypeToken(token)
-    , m_index(index)
-{
-    m_list->AddRef();
-}
-
-DirectShowMediaTypeEnum::~DirectShowMediaTypeEnum()
-{
-    m_list->Release();
-}
-
-HRESULT DirectShowMediaTypeEnum::QueryInterface(REFIID riid, void **ppvObject)
-{
-    if (!ppvObject) {
-        return E_POINTER;
-    } else if (riid == IID_IUnknown
-            || riid == IID_IEnumMediaTypes) {
-        *ppvObject = static_cast<IEnumMediaTypes *>(this);
-    } else {
-        *ppvObject = 0;
-
-        return E_NOINTERFACE;
-    }
-
-    AddRef();
-
-    return S_OK;
-}
-
-ULONG DirectShowMediaTypeEnum::AddRef()
-{
-    return InterlockedIncrement(&m_ref);
-}
-
-ULONG DirectShowMediaTypeEnum::Release()
-{
-    ULONG ref = InterlockedDecrement(&m_ref);
-
-    if (ref == 0) {
-        delete this;
-    }
-
-    return ref;
-}
-
-HRESULT DirectShowMediaTypeEnum::Next(
-        ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched)
-{
-    return m_list->nextMediaType(m_mediaTypeToken, &m_index, cMediaTypes, ppMediaTypes, pcFetched);
-}
-
-HRESULT DirectShowMediaTypeEnum::Skip(ULONG cMediaTypes)
-{
-    return m_list->skipMediaType(m_mediaTypeToken, &m_index, cMediaTypes);
-}
-
-HRESULT DirectShowMediaTypeEnum::Reset()
-{
-    m_mediaTypeToken = m_list->currentMediaTypeToken();
-    m_index = 0;
-
-    return S_OK;
-}
-
-HRESULT DirectShowMediaTypeEnum::Clone(IEnumMediaTypes **ppEnum)
-{
-    return m_list->cloneMediaType(m_mediaTypeToken, m_index, ppEnum);
-}
-
-
-DirectShowMediaTypeList::DirectShowMediaTypeList()
-    : m_mediaTypeToken(0)
-{
-}
-
-DirectShowMediaTypeList::~DirectShowMediaTypeList()
-{
-}
-
-IEnumMediaTypes *DirectShowMediaTypeList::createMediaTypeEnum()
-{
-    return new DirectShowMediaTypeEnum(this, m_mediaTypeToken, 0);
-}
-
-
-void DirectShowMediaTypeList::setMediaTypes(const QVector<AM_MEDIA_TYPE> &types)
-{
-    ++m_mediaTypeToken;
-
-    m_mediaTypes = types;
-}
-
-
-int DirectShowMediaTypeList::currentMediaTypeToken()
-{
-    return m_mediaTypeToken;
-}
-
-HRESULT DirectShowMediaTypeList::nextMediaType(
-        int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount)
-{
-    if (!types || (count != 1 && !fetchedCount)) {
-        return E_POINTER;
-    } else if (m_mediaTypeToken != token) {
-        return VFW_E_ENUM_OUT_OF_SYNC;
-    } else {
-        int boundedCount = qBound<int>(0, count, m_mediaTypes.count() - *index);
-
-        for (int i = 0; i < boundedCount; ++i, ++(*index)) {
-            types[i] = reinterpret_cast<AM_MEDIA_TYPE *>(CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)));
-
-            if (types[i]) {
-                DirectShowMediaType::copy(types[i], m_mediaTypes.at(*index));
-            } else {
-                for (--i; i >= 0; --i)
-                    CoTaskMemFree(types[i]);
-
-                if (fetchedCount)
-                    *fetchedCount = 0;
-
-                return E_OUTOFMEMORY;
-            }
-        }
-        if (fetchedCount)
-            *fetchedCount = boundedCount;
-
-        return boundedCount == int(count) ? S_OK : S_FALSE;
-    }
-}
-
-HRESULT DirectShowMediaTypeList::skipMediaType(int token, int *index, ULONG count)
-{
-    if (m_mediaTypeToken != token) {
-        return VFW_E_ENUM_OUT_OF_SYNC;
-    } else {
-        *index = qMin<int>(*index + count, m_mediaTypes.size());
-
-        return *index < m_mediaTypes.size() ? S_OK : S_FALSE;
-    }
-}
-
-HRESULT DirectShowMediaTypeList::cloneMediaType(int token, int index, IEnumMediaTypes **enumeration)
-{
-    if (m_mediaTypeToken != token) {
-        return VFW_E_ENUM_OUT_OF_SYNC;
-    } else {
-        *enumeration = new DirectShowMediaTypeEnum(this, token, index);
-
-        return S_OK;
-    }
-}
-
diff --git a/src/plugins/directshow/player/directshowsamplescheduler.cpp b/src/plugins/directshow/player/directshowsamplescheduler.cpp
deleted file mode 100644
index 0aa257f7f..000000000
--- a/src/plugins/directshow/player/directshowsamplescheduler.cpp
+++ /dev/null
@@ -1,435 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "directshowsamplescheduler.h"
-
-#include <QtCore/qcoreapplication.h>
-#include <QtCore/qcoreevent.h>
-
-class DirectShowTimedSample
-{
-public:
-    DirectShowTimedSample(IMediaSample *sample)
-        : m_next(0)
-        , m_sample(sample)
-        , m_cookie(0)
-        , m_lastSample(false)
-    {
-        m_sample->AddRef();
-    }
-
-    ~DirectShowTimedSample()
-    {
-        m_sample->Release();
-    }
-
-    IMediaSample *sample() const { return m_sample; }
-
-    DirectShowTimedSample *nextSample() const { return m_next; }
-    void setNextSample(DirectShowTimedSample *sample) { Q_ASSERT(!m_next); m_next = sample; }
-
-    DirectShowTimedSample *remove() {
-        DirectShowTimedSample *next = m_next; delete this; return next; }
-
-    bool schedule(IReferenceClock *clock, REFERENCE_TIME startTime, HANDLE handle);
-    void unschedule(IReferenceClock *clock);
-
-    bool isReady(IReferenceClock *clock) const;
-
-    bool isLast() const { return m_lastSample; }
-    void setLast() { m_lastSample = true; }
-
-private:
-    DirectShowTimedSample *m_next;
-    IMediaSample *m_sample;
-    DWORD_PTR m_cookie;
-    bool m_lastSample;
-};
-
-bool DirectShowTimedSample::schedule(
-        IReferenceClock *clock, REFERENCE_TIME startTime, HANDLE handle)
-{
-    REFERENCE_TIME sampleStartTime;
-    REFERENCE_TIME sampleEndTime;
-    if (m_sample->GetTime(&sampleStartTime, &sampleEndTime) == S_OK) {
-        if (clock->AdviseTime(
-                startTime, sampleStartTime, reinterpret_cast<HEVENT>(handle), &m_cookie) == S_OK) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void DirectShowTimedSample::unschedule(IReferenceClock *clock)
-{
-    clock->Unadvise(m_cookie);
-}
-
-bool DirectShowTimedSample::isReady(IReferenceClock *clock) const
-{
-    REFERENCE_TIME sampleStartTime;
-    REFERENCE_TIME sampleEndTime;
-    REFERENCE_TIME currentTime;
-    if (m_sample->GetTime(&sampleStartTime, &sampleEndTime) == S_OK) {
-        if (clock->GetTime(&currentTime) == S_OK)
-            return currentTime >= sampleStartTime;
-    }
-    return true;
-}
-
-DirectShowSampleScheduler::DirectShowSampleScheduler(IUnknown *pin, QObject *parent)
-    : QObject(parent)
-    , m_pin(pin)
-    , m_clock(0)
-    , m_allocator(0)
-    , m_head(0)
-    , m_tail(0)
-    , m_maximumSamples(1)
-    , m_state(Stopped)
-    , m_startTime(0)
-    , m_timeoutEvent(::CreateEvent(0, 0, 0, 0))
-    , m_flushEvent(::CreateEvent(0, 0, 0, 0))
-{
-    m_semaphore.release(m_maximumSamples);
-}
-
-DirectShowSampleScheduler::~DirectShowSampleScheduler()
-{
-    ::CloseHandle(m_timeoutEvent);
-    ::CloseHandle(m_flushEvent);
-
-    Q_ASSERT(!m_clock);
-    Q_ASSERT(!m_allocator);
-}
-
-HRESULT DirectShowSampleScheduler::QueryInterface(REFIID riid, void **ppvObject)
-{
-    return m_pin->QueryInterface(riid, ppvObject);
-}
-
-ULONG DirectShowSampleScheduler::AddRef()
-{
-    return m_pin->AddRef();
-}
-
-ULONG DirectShowSampleScheduler::Release()
-{
-    return m_pin->Release();
-}
-
-// IMemInputPin
-HRESULT DirectShowSampleScheduler::GetAllocator(IMemAllocator **ppAllocator)
-{
-    if (!ppAllocator) {
-        return E_POINTER;
-    } else {
-        QMutexLocker locker(&m_mutex);
-
-        if (!m_allocator) {
-            return VFW_E_NO_ALLOCATOR;
-        } else {
-            *ppAllocator = m_allocator;
-
-            return S_OK;
-        }
-    }
-}
-
-HRESULT DirectShowSampleScheduler::NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly)
-{
-    Q_UNUSED(bReadOnly);
-
-    HRESULT hr;
-    ALLOCATOR_PROPERTIES properties;
-
-    if (!pAllocator) {
-        if (m_allocator)
-            m_allocator->Release();
-
-        m_allocator = 0;
-
-        return S_OK;
-    } else if ((hr = pAllocator->GetProperties(&properties)) != S_OK) {
-        return hr;
-    } else {
-        if (properties.cBuffers == 1) {
-            ALLOCATOR_PROPERTIES actual;
-
-            properties.cBuffers = 2;
-            if ((hr = pAllocator->SetProperties(&properties, &actual)) != S_OK)
-                return hr;
-        }
-
-        QMutexLocker locker(&m_mutex);
-
-        if (m_allocator)
-            m_allocator->Release();
-
-        m_allocator = pAllocator;
-        m_allocator->AddRef();
-
-        return S_OK;
-    }
-}
-
-HRESULT DirectShowSampleScheduler::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps)
-{
-    if (!pProps)
-        return E_POINTER;
-
-    pProps->cBuffers = 2;
-
-    return S_OK;
-}
-
-HRESULT DirectShowSampleScheduler::Receive(IMediaSample *pSample)
-{
-    if (!pSample)
-        return E_POINTER;
-
-    m_semaphore.acquire(1);
-
-    QMutexLocker locker(&m_mutex);
-
-    if (m_state & Flushing) {
-        m_semaphore.release(1);
-
-        return S_FALSE;
-    } else if (m_state == Stopped) {
-        m_semaphore.release();
-
-        return VFW_E_WRONG_STATE;
-    } else {
-        DirectShowTimedSample *timedSample = new DirectShowTimedSample(pSample);
-
-        if (m_tail)
-            m_tail->setNextSample(timedSample);
-        else
-            m_head = timedSample;
-
-        m_tail = timedSample;
-
-        if (m_state == Running) {
-            if (!timedSample->schedule(m_clock, m_startTime, m_timeoutEvent)) {
-                // Timing information is unavailable, so schedule frames immediately.
-                QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
-            } else {
-                locker.unlock();
-                HANDLE handles[] = { m_flushEvent, m_timeoutEvent };
-                DWORD result = ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
-                locker.relock();
-
-                if (result == WAIT_OBJECT_0 + 1)
-                    QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
-            }
-        } else if (m_tail == m_head) {
-            // If this is the first frame make it available.
-            QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
-
-            if (m_state == Paused) {
-                ::ResetEvent(m_timeoutEvent);
-
-                locker.unlock();
-                HANDLE handles[] = { m_flushEvent, m_timeoutEvent };
-                ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
-                locker.relock();
-            }
-        }
-
-        return S_OK;
-    }
-}
-
-HRESULT DirectShowSampleScheduler::ReceiveMultiple(
-        IMediaSample **pSamples, long nSamples, long *nSamplesProcessed)
-{
-    if (!pSamples || !nSamplesProcessed)
-        return E_POINTER;
-
-    for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; ++(*nSamplesProcessed)) {
-        HRESULT hr = Receive(pSamples[*nSamplesProcessed]);
-
-        if (hr != S_OK)
-            return hr;
-    }
-    return S_OK;
-}
-
-HRESULT DirectShowSampleScheduler::ReceiveCanBlock()
-{
-    return S_OK;
-}
-
-void DirectShowSampleScheduler::run(REFERENCE_TIME startTime)
-{
-    QMutexLocker locker(&m_mutex);
-
-    m_state = (m_state & Flushing) | Running;
-    m_startTime = startTime;
-
-    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->nextSample()) {
-        sample->schedule(m_clock, m_startTime, m_timeoutEvent);
-    }
-
-    if (!(m_state & Flushing))
-        ::ResetEvent(m_flushEvent);
-
-    if (!m_head)
-        ::SetEvent(m_timeoutEvent);
-
-}
-
-void DirectShowSampleScheduler::pause()
-{
-    QMutexLocker locker(&m_mutex);
-
-    m_state = (m_state & Flushing) | Paused;
-
-    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->nextSample())
-        sample->unschedule(m_clock);
-
-    if (!(m_state & Flushing))
-        ::ResetEvent(m_flushEvent);
-}
-
-void DirectShowSampleScheduler::stop()
-{
-    QMutexLocker locker(&m_mutex);
-
-    m_state = m_state & Flushing;
-
-    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->remove()) {
-        sample->unschedule(m_clock);
-
-        m_semaphore.release(1);
-    }
-
-    m_head = 0;
-    m_tail = 0;
-
-    ::SetEvent(m_flushEvent);
-}
-
-void DirectShowSampleScheduler::setFlushing(bool flushing)
-{
-    QMutexLocker locker(&m_mutex);
-
-    const bool isFlushing = m_state & Flushing;
-
-    if (isFlushing != flushing) {
-        if (flushing) {
-            m_state |= Flushing;
-
-            for (DirectShowTimedSample *sample = m_head; sample; sample = sample->remove()) {
-                sample->unschedule(m_clock);
-
-                m_semaphore.release(1);
-            }
-            m_head = 0;
-            m_tail = 0;
-
-            ::SetEvent(m_flushEvent);
-        } else {
-            m_state &= ~Flushing;
-
-            if (m_state != Stopped)
-                ::ResetEvent(m_flushEvent);
-        }
-    }
-}
-
-void DirectShowSampleScheduler::setClock(IReferenceClock *clock)
-{
-    QMutexLocker locker(&m_mutex);
-
-    if (m_clock)
-        m_clock->Release();
-
-    m_clock = clock;
-
-    if (m_clock)
-        m_clock->AddRef();
-}
-
-IMediaSample *DirectShowSampleScheduler::takeSample(bool *eos)
-{
-    QMutexLocker locker(&m_mutex);
-
-    if (m_head && m_head->isReady(m_clock)) {
-        IMediaSample *sample = m_head->sample();
-        sample->AddRef();
-
-        *eos =  m_head->isLast();
-
-        m_head = m_head->remove();
-
-        if (!m_head)
-            m_tail = 0;
-
-        m_semaphore.release(1);
-
-        return sample;
-    } else {
-        return 0;
-    }
-}
-
-bool DirectShowSampleScheduler::scheduleEndOfStream()
-{
-    QMutexLocker locker(&m_mutex);
-
-    if (m_tail) {
-        m_tail->setLast();
-
-        return true;
-    } else {
-        return false;
-    }
-}
-
-bool DirectShowSampleScheduler::event(QEvent *event)
-{
-    if (event->type() == QEvent::UpdateRequest) {
-        emit sampleReady();
-
-        return true;
-    } else {
-        return QObject::event(event);
-    }
-}
diff --git a/src/plugins/directshow/player/directshowsamplescheduler.h b/src/plugins/directshow/player/directshowsamplescheduler.h
deleted file mode 100644
index 1670d23ed..000000000
--- a/src/plugins/directshow/player/directshowsamplescheduler.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef DIRECTSHOWSAMPLESCHEDULER_H
-#define DIRECTSHOWSAMPLESCHEDULER_H
-
-#include <dshow.h>
-
-#include <QtCore/qmutex.h>
-#include <QtCore/qobject.h>
-#include <QtCore/qsemaphore.h>
-
-class DirectShowTimedSample;
-
-class DirectShowSampleScheduler : public QObject, public IMemInputPin
-{
-    Q_OBJECT
-public:
-
-    enum State
-    {
-        Stopped  = 0x00,
-        Running  = 0x01,
-        Paused   = 0x02,
-        RunMask  = 0x03,
-        Flushing = 0x04
-    };
-
-    DirectShowSampleScheduler(IUnknown *pin, QObject *parent = 0);
-    ~DirectShowSampleScheduler();
-
-    // IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
-    ULONG STDMETHODCALLTYPE AddRef();
-    ULONG STDMETHODCALLTYPE Release();
-
-    // IMemInputPin
-    HRESULT STDMETHODCALLTYPE GetAllocator(IMemAllocator **ppAllocator);
-    HRESULT STDMETHODCALLTYPE NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly);
-    HRESULT STDMETHODCALLTYPE GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps);
-
-    HRESULT STDMETHODCALLTYPE Receive(IMediaSample *pSample);
-    HRESULT STDMETHODCALLTYPE ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed);
-    HRESULT STDMETHODCALLTYPE ReceiveCanBlock();
-
-    void run(REFERENCE_TIME startTime);
-    void pause();
-    void stop();
-    void setFlushing(bool flushing);
-
-    IReferenceClock *clock() const { return m_clock; }
-    void setClock(IReferenceClock *clock);
-
-    bool schedule(IMediaSample *sample);
-    bool scheduleEndOfStream();
-
-    IMediaSample *takeSample(bool *eos);
-
-    bool event(QEvent *event);
-
-Q_SIGNALS:
-    void sampleReady();
-
-private:
-    IUnknown *m_pin;
-    IReferenceClock *m_clock;
-    IMemAllocator *m_allocator;
-    DirectShowTimedSample *m_head;
-    DirectShowTimedSample *m_tail;
-    int m_maximumSamples;
-    int m_state;
-    REFERENCE_TIME m_startTime;
-    HANDLE m_timeoutEvent;
-    HANDLE m_flushEvent;
-    QSemaphore m_semaphore;
-    QMutex m_mutex;
-};
-
-#endif
diff --git a/src/plugins/directshow/player/player.pri b/src/plugins/directshow/player/player.pri
index 0bc9c6d0a..8b4bb70b7 100644
--- a/src/plugins/directshow/player/player.pri
+++ b/src/plugins/directshow/player/player.pri
@@ -8,35 +8,22 @@ qtHaveModule(widgets): QT += widgets
 DEFINES += QMEDIA_DIRECTSHOW_PLAYER
 
 HEADERS += \
-        $$PWD/directshoweventloop.h \
-        $$PWD/directshowglobal.h \
         $$PWD/directshowioreader.h \
         $$PWD/directshowiosource.h \
-        $$PWD/directshowmediatype.h \
-        $$PWD/directshowmediatypelist.h \
-        $$PWD/directshowpinenum.h \
         $$PWD/directshowplayercontrol.h \
         $$PWD/directshowplayerservice.h \
-        $$PWD/directshowsamplescheduler.h \
         $$PWD/directshowvideorenderercontrol.h \
-        $$PWD/mediasamplevideobuffer.h \
         $$PWD/videosurfacefilter.h \
         $$PWD/directshowaudioendpointcontrol.h \
         $$PWD/directshowmetadatacontrol.h \
         $$PWD/vmr9videowindowcontrol.h
 
 SOURCES += \
-        $$PWD/directshoweventloop.cpp \
         $$PWD/directshowioreader.cpp \
         $$PWD/directshowiosource.cpp \
-        $$PWD/directshowmediatype.cpp \
-        $$PWD/directshowmediatypelist.cpp \
-        $$PWD/directshowpinenum.cpp \
         $$PWD/directshowplayercontrol.cpp \
         $$PWD/directshowplayerservice.cpp \
-        $$PWD/directshowsamplescheduler.cpp \
         $$PWD/directshowvideorenderercontrol.cpp \
-        $$PWD/mediasamplevideobuffer.cpp \
         $$PWD/videosurfacefilter.cpp \
         $$PWD/directshowaudioendpointcontrol.cpp \
         $$PWD/directshowmetadatacontrol.cpp \
diff --git a/src/plugins/directshow/player/videosurfacefilter.cpp b/src/plugins/directshow/player/videosurfacefilter.cpp
index b7b0d3aa8..4cb97be39 100644
--- a/src/plugins/directshow/player/videosurfacefilter.cpp
+++ b/src/plugins/directshow/player/videosurfacefilter.cpp
@@ -41,226 +41,220 @@
 
 #include "directshoweventloop.h"
 #include "directshowglobal.h"
-#include "directshowpinenum.h"
-#include "mediasamplevideobuffer.h"
+#include "directshowvideobuffer.h"
 
-#include <QtCore/qcoreapplication.h>
-#include <QtCore/qcoreevent.h>
 #include <QtCore/qthread.h>
+#include <QtCore/qloggingcategory.h>
 #include <qabstractvideosurface.h>
 
 #include <initguid.h>
 
+Q_LOGGING_CATEGORY(qLcRenderFilter, "qt.multimedia.plugins.directshow.renderfilter")
+
 // { e23cad72-153d-406c-bf3f-4c4b523d96f2 }
 DEFINE_GUID(CLSID_VideoSurfaceFilter,
 0xe23cad72, 0x153d, 0x406c, 0xbf, 0x3f, 0x4c, 0x4b, 0x52, 0x3d, 0x96, 0xf2);
 
-VideoSurfaceFilter::VideoSurfaceFilter(
-        QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent)
-    : QObject(parent)
-    , m_ref(1)
-    , m_state(State_Stopped)
-    , m_surface(surface)
-    , m_loop(loop)
-    , m_graph(0)
-    , m_peerPin(0)
-    , m_bytesPerLine(0)
-    , m_startResult(S_OK)
-    , m_pinId(QString::fromLatin1("reference"))
-    , m_sampleScheduler(static_cast<IPin *>(this))
+class VideoSurfaceInputPin : public DirectShowInputPin
 {
-    connect(surface, SIGNAL(supportedFormatsChanged()), this, SLOT(supportedFormatsChanged()));
-    connect(&m_sampleScheduler, SIGNAL(sampleReady()), this, SLOT(sampleReady()));
-}
+    DIRECTSHOW_OBJECT
 
-VideoSurfaceFilter::~VideoSurfaceFilter()
-{
-    Q_ASSERT(m_ref == 0);
-}
+public:
+    VideoSurfaceInputPin(VideoSurfaceFilter *filter);
 
-HRESULT VideoSurfaceFilter::QueryInterface(REFIID riid, void **ppvObject)
-{
-    // 2dd74950-a890-11d1-abe8-00a0c905f375
-    static const GUID iid_IAmFilterMiscFlags = {
-        0x2dd74950, 0xa890, 0x11d1, {0xab, 0xe8, 0x00, 0xa0, 0xc9, 0x05, 0xf3, 0x75} };
+    // DirectShowPin
+    bool isMediaTypeSupported(const DirectShowMediaType *type);
+    bool setMediaType(const DirectShowMediaType *type);
 
-    if (!ppvObject) {
-        return E_POINTER;
-    } else if (riid == IID_IUnknown
-            || riid == IID_IPersist
-            || riid == IID_IMediaFilter
-            || riid == IID_IBaseFilter) {
-        *ppvObject = static_cast<IBaseFilter *>(this);
-    } else if (riid == iid_IAmFilterMiscFlags) {
-        *ppvObject = static_cast<IAMFilterMiscFlags *>(this);
-    } else if (riid == IID_IPin) {
-        *ppvObject = static_cast<IPin *>(this);
-    } else if (riid == IID_IMemInputPin) {
-        *ppvObject = static_cast<IMemInputPin *>(&m_sampleScheduler);
-    } else {
-        *ppvObject = 0;
+    HRESULT completeConnection(IPin *pin);
+    HRESULT connectionEnded();
 
-        return E_NOINTERFACE;
-    }
+    // IPin
+    STDMETHODIMP ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
+    STDMETHODIMP Disconnect();
+    STDMETHODIMP EndOfStream();
+    STDMETHODIMP BeginFlush();
+    STDMETHODIMP EndFlush();
 
-    AddRef();
+    // IMemInputPin
+    STDMETHODIMP GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps);
+    STDMETHODIMP Receive(IMediaSample *pMediaSample);
 
-    return S_OK;
+private:
+    VideoSurfaceFilter *m_videoSurfaceFilter;
+};
+
+VideoSurfaceInputPin::VideoSurfaceInputPin(VideoSurfaceFilter *filter)
+    : DirectShowInputPin(filter, QStringLiteral("Input"))
+    , m_videoSurfaceFilter(filter)
+{
 }
 
-ULONG VideoSurfaceFilter::AddRef()
+bool VideoSurfaceInputPin::isMediaTypeSupported(const DirectShowMediaType *type)
 {
-    return InterlockedIncrement(&m_ref);
+    return m_videoSurfaceFilter->isMediaTypeSupported(type);
 }
 
-ULONG VideoSurfaceFilter::Release()
+bool VideoSurfaceInputPin::setMediaType(const DirectShowMediaType *type)
 {
-    ULONG ref = InterlockedDecrement(&m_ref);
-    if (ref == 0)
-        delete this;
+    if (!DirectShowInputPin::setMediaType(type))
+        return false;
 
-    return ref;
+    return m_videoSurfaceFilter->setMediaType(type);
 }
 
-HRESULT VideoSurfaceFilter::GetClassID(CLSID *pClassID)
+HRESULT VideoSurfaceInputPin::completeConnection(IPin *pin)
 {
-    *pClassID = CLSID_VideoSurfaceFilter;
+    HRESULT hr = DirectShowInputPin::completeConnection(pin);
+    if (FAILED(hr))
+        return hr;
 
-    return S_OK;
+    return m_videoSurfaceFilter->completeConnection(pin);
 }
 
-HRESULT VideoSurfaceFilter::Run(REFERENCE_TIME tStart)
+HRESULT VideoSurfaceInputPin::connectionEnded()
 {
-    m_state = State_Running;
-
-    m_sampleScheduler.run(tStart);
+    HRESULT hr = DirectShowInputPin::connectionEnded();
+    if (FAILED(hr))
+        return hr;
 
-    return S_OK;
+    return m_videoSurfaceFilter->connectionEnded();
 }
 
-HRESULT VideoSurfaceFilter::Pause()
+HRESULT VideoSurfaceInputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 {
-    m_state = State_Paused;
-
-    m_sampleScheduler.pause();
+    QMutexLocker lock(&m_videoSurfaceFilter->m_mutex);
+    return DirectShowInputPin::ReceiveConnection(pConnector, pmt);
+}
 
-    return S_OK;
+HRESULT VideoSurfaceInputPin::Disconnect()
+{
+    QMutexLocker lock(&m_videoSurfaceFilter->m_mutex);
+    return DirectShowInputPin::Disconnect();
 }
 
-HRESULT VideoSurfaceFilter::Stop()
+HRESULT VideoSurfaceInputPin::EndOfStream()
 {
-    m_state = State_Stopped;
+    QMutexLocker lock(&m_videoSurfaceFilter->m_mutex);
+    QMutexLocker renderLock(&m_videoSurfaceFilter->m_renderMutex);
 
-    m_sampleScheduler.stop();
+    HRESULT hr = DirectShowInputPin::EndOfStream();
+    if (hr != S_OK)
+        return hr;
 
-    if (thread() == QThread::currentThread()) {
-        flush();
-    } else {
-        QMutexLocker locker(&m_mutex);
-        m_loop->postEvent(this, new QEvent(QEvent::Type(FlushSurface)));
-        m_wait.wait(&m_mutex);
+    return m_videoSurfaceFilter->EndOfStream();
+}
+
+HRESULT VideoSurfaceInputPin::BeginFlush()
+{
+    QMutexLocker lock(&m_videoSurfaceFilter->m_mutex);
+    {
+        QMutexLocker renderLock(&m_videoSurfaceFilter->m_renderMutex);
+        DirectShowInputPin::BeginFlush();
+        m_videoSurfaceFilter->BeginFlush();
     }
+    m_videoSurfaceFilter->resetEOS();
 
     return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
+HRESULT VideoSurfaceInputPin::EndFlush()
 {
-    Q_UNUSED(dwMilliSecsTimeout)
-    if (!pState)
-        return E_POINTER;
-
-    *pState = m_state;
+    QMutexLocker lock(&m_videoSurfaceFilter->m_mutex);
+    QMutexLocker renderLock(&m_videoSurfaceFilter->m_renderMutex);
 
-    return S_OK;
+    HRESULT hr = m_videoSurfaceFilter->EndFlush();
+    if (SUCCEEDED(hr))
+        hr = DirectShowInputPin::EndFlush();
+    return hr;
 }
 
-HRESULT VideoSurfaceFilter::SetSyncSource(IReferenceClock *pClock)
+HRESULT VideoSurfaceInputPin::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps)
 {
+    if (!pProps)
+        return E_POINTER;
 
-    m_sampleScheduler.setClock(pClock);
+    // We need at least two allocated buffers, one for holding the frame currently being
+    // rendered and another one to decode the following frame at the same time.
+    pProps->cBuffers = 2;
 
     return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::GetSyncSource(IReferenceClock **ppClock)
+HRESULT VideoSurfaceInputPin::Receive(IMediaSample *pMediaSample)
 {
-    if (!ppClock) {
-        return E_POINTER;
-    } else {
-        *ppClock = m_sampleScheduler.clock();
-
-        if (*ppClock) {
-            (*ppClock)->AddRef();
-
-            return S_OK;
-        } else {
-            return S_FALSE;
+    HRESULT hr = m_videoSurfaceFilter->Receive(pMediaSample);
+    if (FAILED(hr)) {
+        QMutexLocker locker(&m_videoSurfaceFilter->m_mutex);
+        if (m_videoSurfaceFilter->state() != State_Stopped && !m_flushing && !m_inErrorState) {
+            m_videoSurfaceFilter->NotifyEvent(EC_ERRORABORT, hr, 0);
+            {
+                QMutexLocker renderLocker(&m_videoSurfaceFilter->m_renderMutex);
+                if (m_videoSurfaceFilter->m_running && !m_videoSurfaceFilter->m_EOSDelivered)
+                    m_videoSurfaceFilter->notifyEOS();
+            }
+            m_inErrorState = true;
         }
     }
+
+    return hr;
 }
 
-HRESULT VideoSurfaceFilter::EnumPins(IEnumPins **ppEnum)
-{
-    if (ppEnum) {
-        *ppEnum = new DirectShowPinEnum(QList<IPin *>() << this);
 
-        return S_OK;
-    } else {
-        return E_POINTER;
-    }
+VideoSurfaceFilter::VideoSurfaceFilter(QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent)
+    : QObject(parent)
+    , m_loop(loop)
+    , m_pin(NULL)
+    , m_surface(surface)
+    , m_bytesPerLine(0)
+    , m_surfaceStarted(false)
+    , m_renderMutex(QMutex::Recursive)
+    , m_running(false)
+    , m_pendingSample(NULL)
+    , m_pendingSampleEndTime(0)
+    , m_renderEvent(CreateEvent(NULL, FALSE, FALSE, NULL))
+    , m_flushEvent(CreateEvent(NULL, TRUE, FALSE, NULL))
+    , m_adviseCookie(0)
+    , m_EOS(false)
+    , m_EOSDelivered(false)
+    , m_EOSTimer(0)
+{
+    supportedFormatsChanged();
+    connect(surface, &QAbstractVideoSurface::supportedFormatsChanged,
+            this, &VideoSurfaceFilter::supportedFormatsChanged);
 }
 
-HRESULT VideoSurfaceFilter::FindPin(LPCWSTR pId, IPin **ppPin)
+VideoSurfaceFilter::~VideoSurfaceFilter()
 {
-    if (!ppPin || !pId) {
-        return E_POINTER;
-    } else if (QString::fromWCharArray(pId) == m_pinId) {
-        AddRef();
+    clearPendingSample();
 
-        *ppPin = this;
+    if (m_pin)
+        m_pin->Release();
 
-        return S_OK;
-    } else {
-        return VFW_E_NOT_FOUND;
-    }
+    CloseHandle(m_flushEvent);
+    CloseHandle(m_renderEvent);
 }
 
-HRESULT VideoSurfaceFilter::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
+HRESULT VideoSurfaceFilter::getInterface(const IID &riid, void **ppvObject)
 {
-    m_graph = pGraph;
-    m_name = QString::fromWCharArray(pName);
-
-    return S_OK;
+    if (riid == IID_IAMFilterMiscFlags)
+        return GetInterface(static_cast<IAMFilterMiscFlags*>(this), ppvObject);
+    else
+        return DirectShowBaseFilter::getInterface(riid, ppvObject);
 }
 
-HRESULT VideoSurfaceFilter::QueryFilterInfo(FILTER_INFO *pInfo)
+QList<DirectShowPin *> VideoSurfaceFilter::pins()
 {
-    if (pInfo) {
-        QString name = m_name;
-
-        if (name.length() >= MAX_FILTER_NAME)
-            name.truncate(MAX_FILTER_NAME - 1);
-
-        int length = name.toWCharArray(pInfo->achName);
-        pInfo->achName[length] = '\0';
-
-        if (m_graph)
-            m_graph->AddRef();
-
-        pInfo->pGraph = m_graph;
+    if (!m_pin)
+        m_pin = new VideoSurfaceInputPin(this);
 
-        return S_OK;
-    } else {
-        return E_POINTER;
-    }
+    return QList<DirectShowPin *>() << m_pin;
 }
 
-HRESULT VideoSurfaceFilter::QueryVendorInfo(LPWSTR *pVendorInfo)
+HRESULT VideoSurfaceFilter::GetClassID(CLSID *pClassID)
 {
-    Q_UNUSED(pVendorInfo);
-
-    return E_NOTIMPL;
+    *pClassID = CLSID_VideoSurfaceFilter;
+    return S_OK;
 }
 
 ULONG VideoSurfaceFilter::GetMiscFlags()
@@ -268,388 +262,527 @@ ULONG VideoSurfaceFilter::GetMiscFlags()
     return AM_FILTER_MISC_FLAGS_IS_RENDERER;
 }
 
-
-HRESULT VideoSurfaceFilter::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
-{
-    Q_UNUSED(pReceivePin)
-    Q_UNUSED(pmt)
-    // This is an input pin, you shouldn't be calling Connect on it.
-    return E_POINTER;
-}
-
-HRESULT VideoSurfaceFilter::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
+void VideoSurfaceFilter::supportedFormatsChanged()
 {
-    if (!pConnector) {
-        return E_POINTER;
-    } else if (!pmt) {
-        return E_POINTER;
-    } else {
-        HRESULT hr;
-        QMutexLocker locker(&m_mutex);
+    QWriteLocker writeLocker(&m_typesLock);
 
-        if (m_peerPin) {
-            hr = VFW_E_ALREADY_CONNECTED;
-        } else if (pmt->majortype != MEDIATYPE_Video) {
-            hr = VFW_E_TYPE_NOT_ACCEPTED;
-        } else {
-            m_surfaceFormat = DirectShowMediaType::formatFromType(*pmt);
-            m_bytesPerLine = DirectShowMediaType::bytesPerLine(m_surfaceFormat);
+    qCDebug(qLcRenderFilter, "supportedFormatChanged");
 
-            if (thread() == QThread::currentThread()) {
-                hr = start();
-            } else {
-                m_loop->postEvent(this, new QEvent(QEvent::Type(StartSurface)));
+    m_supportedTypes.clear();
 
-                m_wait.wait(&m_mutex);
+    const QList<QVideoFrame::PixelFormat> formats = m_surface->supportedPixelFormats();
+    m_supportedTypes.reserve(formats.count());
 
-                hr = m_startResult;
-            }
+    for (QVideoFrame::PixelFormat format : formats) {
+        GUID subtype = DirectShowMediaType::convertPixelFormat(format);
+        if (!IsEqualGUID(subtype, MEDIASUBTYPE_None)) {
+            qCDebug(qLcRenderFilter) << "  " << format;
+            m_supportedTypes.append(subtype);
         }
-        if (hr == S_OK) {
-           m_peerPin = pConnector;
-           m_peerPin->AddRef();
+    }
+}
 
-           DirectShowMediaType::copy(&m_mediaType, *pmt);
-        }
-        return hr;
+bool VideoSurfaceFilter::isMediaTypeSupported(const DirectShowMediaType *type)
+{
+    if (type->majortype != MEDIATYPE_Video || type->bFixedSizeSamples == FALSE)
+        return false;
+
+    QReadLocker readLocker(&m_typesLock);
+
+    for (const GUID &supportedType : m_supportedTypes) {
+        if (IsEqualGUID(supportedType, type->subtype))
+            return true;
     }
+
+    return false;
 }
 
-HRESULT VideoSurfaceFilter::start()
+bool VideoSurfaceFilter::setMediaType(const DirectShowMediaType *type)
 {
-    if (!m_surface->isFormatSupported(m_surfaceFormat)) {
-        return VFW_E_TYPE_NOT_ACCEPTED;
+    if (!type) {
+        qCDebug(qLcRenderFilter, "clear media type");
+        m_surfaceFormat = QVideoSurfaceFormat();
+        m_bytesPerLine = 0;
+        return true;
+    } else {
+        m_surfaceFormat = DirectShowMediaType::formatFromType(*type);
+        m_bytesPerLine = DirectShowMediaType::bytesPerLine(m_surfaceFormat);
+        qCDebug(qLcRenderFilter) << "setMediaType -->" << m_surfaceFormat;
+        return m_surfaceFormat.isValid();
     }
-    if (!m_surface->start(m_surfaceFormat)) {
+}
+
+HRESULT VideoSurfaceFilter::completeConnection(IPin *pin)
+{
+    Q_UNUSED(pin);
+
+    qCDebug(qLcRenderFilter, "completeConnection");
+
+    if (!startSurface())
         return VFW_E_TYPE_NOT_ACCEPTED;
-    } else {
+    else
         return S_OK;
-    }
 }
 
-HRESULT VideoSurfaceFilter::Disconnect()
+HRESULT VideoSurfaceFilter::connectionEnded()
+{
+    qCDebug(qLcRenderFilter, "connectionEnded");
+
+    stopSurface();
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::Run(REFERENCE_TIME tStart)
 {
     QMutexLocker locker(&m_mutex);
 
-    if (!m_peerPin)
-        return S_FALSE;
+    if (m_state == State_Running)
+        return S_OK;
 
-    if (thread() == QThread::currentThread()) {
-        stop();
-    } else {
-        m_loop->postEvent(this, new QEvent(QEvent::Type(StopSurface)));
+    qCDebug(qLcRenderFilter, "Run (start=%lli)", tStart);
+
+    HRESULT hr = DirectShowBaseFilter::Run(tStart);
+    if (FAILED(hr))
+        return hr;
+
+    ResetEvent(m_flushEvent);
 
-        m_wait.wait(&m_mutex);
+    IMemAllocator *allocator;
+    if (SUCCEEDED(m_pin->GetAllocator(&allocator))) {
+        allocator->Commit();
+        allocator->Release();
     }
 
-    m_mediaType.clear();
+    QMutexLocker renderLocker(&m_renderMutex);
 
-    m_sampleScheduler.NotifyAllocator(0, FALSE);
+    m_running = true;
 
-    m_peerPin->Release();
-    m_peerPin = 0;
+    if (!m_pendingSample)
+        checkEOS();
+    else if (!scheduleSample(m_pendingSample))
+        SetEvent(m_renderEvent); // render immediately
 
     return S_OK;
 }
 
-void VideoSurfaceFilter::stop()
+HRESULT VideoSurfaceFilter::Pause()
 {
-    m_surface->stop();
-}
+    QMutexLocker locker(&m_mutex);
 
-HRESULT VideoSurfaceFilter::ConnectedTo(IPin **ppPin)
-{
-    if (!ppPin) {
-        return E_POINTER;
-    } else {
-        QMutexLocker locker(&m_mutex);
+    if (m_state == State_Paused)
+        return S_OK;
 
-        if (!m_peerPin) {
-            return VFW_E_NOT_CONNECTED;
-        } else {
-            m_peerPin->AddRef();
+    qCDebug(qLcRenderFilter, "Pause");
 
-            *ppPin = m_peerPin;
+    HRESULT hr = DirectShowBaseFilter::Pause();
+    if (FAILED(hr))
+        return hr;
 
-            return S_OK;
-        }
+    m_renderMutex.lock();
+    m_EOSDelivered = false;
+    m_running = false;
+    m_renderMutex.unlock();
+
+    resetEOSTimer();
+    ResetEvent(m_flushEvent);
+    unscheduleSample();
+
+    IMemAllocator *allocator;
+    if (SUCCEEDED(m_pin->GetAllocator(&allocator))) {
+        allocator->Commit();
+        allocator->Release();
     }
+
+    return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
+HRESULT VideoSurfaceFilter::Stop()
 {
-    if (!pmt) {
-        return E_POINTER;
-    } else {
-        QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&m_mutex);
 
-        if (!m_peerPin) {
-            return VFW_E_NOT_CONNECTED;
-        } else {
-            DirectShowMediaType::copy(pmt, m_mediaType);
+    if (m_state == State_Stopped)
+        return S_OK;
 
-            return S_OK;
-        }
-    }
-}
+    qCDebug(qLcRenderFilter, "Stop");
 
-HRESULT VideoSurfaceFilter::QueryPinInfo(PIN_INFO *pInfo)
-{
-    if (!pInfo) {
-        return E_POINTER;
-    } else {
-        AddRef();
+    DirectShowBaseFilter::Stop();
 
-        pInfo->pFilter = this;
-        pInfo->dir = PINDIR_INPUT;
+    clearPendingSample();
 
-        const int bytes = qMin(MAX_FILTER_NAME, (m_pinId.length() + 1) * 2);
+    m_renderMutex.lock();
+    m_EOSDelivered = false;
+    m_running = false;
+    m_renderMutex.unlock();
 
-        ::memcpy(pInfo->achName, m_pinId.utf16(), bytes);
+    SetEvent(m_flushEvent);
+    resetEOS();
+    unscheduleSample();
+    flushSurface();
 
-        return S_OK;
+    IMemAllocator *allocator;
+    if (SUCCEEDED(m_pin->GetAllocator(&allocator))) {
+        allocator->Decommit();
+        allocator->Release();
     }
+
+    return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::QueryId(LPWSTR *Id)
+HRESULT VideoSurfaceFilter::EndOfStream()
 {
-    if (!Id) {
-        return E_POINTER;
-    } else {
-        const int bytes = (m_pinId.length() + 1) * 2;
+    QMutexLocker renderLocker(&m_renderMutex);
 
-        *Id = static_cast<LPWSTR>(::CoTaskMemAlloc(bytes));
+    qCDebug(qLcRenderFilter, "EndOfStream");
 
-        ::memcpy(*Id, m_pinId.utf16(), bytes);
+    m_EOS = true;
 
-        return S_OK;
-    }
-}
+    if (!m_pendingSample && m_running)
+        checkEOS();
 
-HRESULT VideoSurfaceFilter::QueryAccept(const AM_MEDIA_TYPE *pmt)
-{
-    return !m_surface->isFormatSupported(DirectShowMediaType::formatFromType(*pmt))
-            ? S_OK
-            : S_FALSE;
+    return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::EnumMediaTypes(IEnumMediaTypes **ppEnum)
+HRESULT VideoSurfaceFilter::BeginFlush()
 {
-    if (!ppEnum) {
-        return E_POINTER;
-    } else {
-        QMutexLocker locker(&m_mutex);
+    qCDebug(qLcRenderFilter, "BeginFlush");
 
-        *ppEnum = createMediaTypeEnum();
+    SetEvent(m_flushEvent);
+    unscheduleSample();
+    clearPendingSample();
 
-        return S_OK;
-    }
+    return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::QueryInternalConnections(IPin **apPin, ULONG *nPin)
+HRESULT VideoSurfaceFilter::EndFlush()
 {
-    Q_UNUSED(apPin);
-    Q_UNUSED(nPin);
+    qCDebug(qLcRenderFilter, "EndFlush");
 
-    return E_NOTIMPL;
+    ResetEvent(m_flushEvent);
+    return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::EndOfStream()
+HRESULT VideoSurfaceFilter::Receive(IMediaSample *pMediaSample)
 {
-    QMutexLocker locker(&m_mutex);
+    {
+        QMutexLocker locker(&m_mutex);
 
-    if (!m_sampleScheduler.scheduleEndOfStream()) {
-        if (IMediaEventSink *sink = com_cast<IMediaEventSink>(m_graph, IID_IMediaEventSink)) {
-            sink->Notify(
-                    EC_COMPLETE,
-                    S_OK,
-                    reinterpret_cast<LONG_PTR>(static_cast<IBaseFilter *>(this)));
-            sink->Release();
+        qCDebug(qLcRenderFilter, "Receive (sample=%p)", pMediaSample);
+
+        HRESULT hr = m_pin->DirectShowInputPin::Receive(pMediaSample);
+        if (hr != S_OK) {
+            qCDebug(qLcRenderFilter, "  can't receive sample (error %X)", uint(hr));
+            return E_FAIL;
         }
-    }
 
-    return S_OK;
-}
+        // 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))
+                    || !restartSurface())) {
+                qCWarning(qLcRenderFilter, "  dynamic format change failed, aborting rendering");
+                NotifyEvent(EC_ERRORABORT, VFW_E_TYPE_NOT_ACCEPTED, 0);
+                return VFW_E_INVALIDMEDIATYPE;
+        }
 
-HRESULT VideoSurfaceFilter::BeginFlush()
-{
-    QMutexLocker locker(&m_mutex);
+        {
+            QMutexLocker locker(&m_renderMutex);
 
-    m_sampleScheduler.setFlushing(true);
+            if (m_pendingSample || m_EOS)
+                return E_UNEXPECTED;
 
-    if (thread() == QThread::currentThread()) {
-        flush();
-    } else {
-        m_loop->postEvent(this, new QEvent(QEvent::Type(FlushSurface)));
+            if (m_running && !scheduleSample(pMediaSample)) {
+                qCWarning(qLcRenderFilter, "  sample can't be scheduled, discarding it");
+                return S_OK;
+            }
+
+            m_pendingSample = pMediaSample;
+            m_pendingSample->AddRef();
+            m_pendingSampleEndTime = m_pin->currentSampleProperties()->tStop;
+        }
 
-        m_wait.wait(&m_mutex);
+        if (m_state == State_Paused) // Render immediately
+            renderPendingSample();
     }
 
-    return S_OK;
-}
+    qCDebug(qLcRenderFilter, "  waiting for render time");
 
-HRESULT VideoSurfaceFilter::EndFlush()
-{
-    QMutexLocker locker(&m_mutex);
+    // Wait for render time. The clock will wake us up whenever the time comes.
+    // It can also be interrupted by a flush, pause or stop.
+    HANDLE waitObjects[] = { m_flushEvent, m_renderEvent };
+    DWORD result = WAIT_TIMEOUT;
+    while (result == WAIT_TIMEOUT)
+        result = WaitForMultipleObjects(2, waitObjects, FALSE, INFINITE);
 
-    m_sampleScheduler.setFlushing(false);
+    if (result == WAIT_OBJECT_0) {
+        // render interrupted (flush, pause, stop)
+        qCDebug(qLcRenderFilter, " rendering of sample %p interrupted", pMediaSample);
+        return S_OK;
+    }
 
-    return S_OK;
-}
+    m_adviseCookie = 0;
 
-void VideoSurfaceFilter::flush()
-{
-    m_surface->present(QVideoFrame());
+    QMutexLocker locker(&m_mutex);
 
-    m_wait.wakeAll();
-}
+    // State might have changed just before the lock
+    if (m_state == State_Stopped) {
+        qCDebug(qLcRenderFilter, "  state changed to Stopped, discarding sample (%p)", pMediaSample);
+        return S_OK;
+    }
 
-HRESULT VideoSurfaceFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
-{
-    Q_UNUSED(tStart);
-    Q_UNUSED(tStop);
-    Q_UNUSED(dRate);
+    QMutexLocker renderLock(&m_renderMutex);
+
+    // Flush or pause might have happened just before the lock
+    if (m_pendingSample && m_running) {
+        renderLock.unlock();
+        renderPendingSample();
+        renderLock.relock();
+    } else {
+        qCDebug(qLcRenderFilter, "  discarding sample (%p)", pMediaSample);
+    }
+
+    clearPendingSample();
+    checkEOS();
+    ResetEvent(m_renderEvent);
 
     return S_OK;
 }
 
-HRESULT VideoSurfaceFilter::QueryDirection(PIN_DIRECTION *pPinDir)
+bool VideoSurfaceFilter::scheduleSample(IMediaSample *sample)
 {
-    if (!pPinDir) {
-        return E_POINTER;
-    } else {
-        *pPinDir = PINDIR_INPUT;
+    if (!sample)
+        return false;
 
-        return S_OK;
+    qCDebug(qLcRenderFilter, "scheduleSample (sample=%p)", sample);
+
+    REFERENCE_TIME sampleStart, sampleEnd;
+    if (FAILED(sample->GetTime(&sampleStart, &sampleEnd)) || !m_clock) {
+        qCDebug(qLcRenderFilter, "  render now");
+        SetEvent(m_renderEvent); // Render immediately
+        return true;
     }
-}
 
-int VideoSurfaceFilter::currentMediaTypeToken()
-{
-    QMutexLocker locker(&m_mutex);
+    if (sampleEnd < sampleStart) { // incorrect times
+        qCWarning(qLcRenderFilter, "  invalid sample times (start=%lli, end=%lli)", sampleStart, sampleEnd);
+        return false;
+    }
+
+    HRESULT hr = m_clock->AdviseTime(m_startTime, sampleStart, (HEVENT)m_renderEvent, &m_adviseCookie);
+    if (FAILED(hr)) {
+        qCWarning(qLcRenderFilter, "  clock failed to advise time (error=%X)", uint(hr));
+        return false;
+    }
 
-    return DirectShowMediaTypeList::currentMediaTypeToken();
+    return true;
 }
 
-HRESULT VideoSurfaceFilter::nextMediaType(
-        int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount)
+void VideoSurfaceFilter::unscheduleSample()
 {
-    QMutexLocker locker(&m_mutex);
-
-    return DirectShowMediaTypeList::nextMediaType(token, index, count, types, fetchedCount);
+    if (m_adviseCookie) {
+        qCDebug(qLcRenderFilter, "unscheduleSample");
+        m_clock->Unadvise(m_adviseCookie);
+        m_adviseCookie = 0;
+    }
 
+    ResetEvent(m_renderEvent);
 }
 
-HRESULT VideoSurfaceFilter::skipMediaType(int token, int *index, ULONG count)
+void VideoSurfaceFilter::clearPendingSample()
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&m_renderMutex);
+    if (m_pendingSample) {
+        qCDebug(qLcRenderFilter, "clearPendingSample");
+        m_pendingSample->Release();
+        m_pendingSample = NULL;
+    }
+}
 
-    return DirectShowMediaTypeList::skipMediaType(token, index, count);
+void QT_WIN_CALLBACK EOSTimerCallback(UINT, UINT, DWORD_PTR dwUser, DWORD_PTR, DWORD_PTR)
+{
+    VideoSurfaceFilter *that = reinterpret_cast<VideoSurfaceFilter *>(dwUser);
+    that->onEOSTimerTimeout();
 }
 
-HRESULT VideoSurfaceFilter::cloneMediaType(int token, int index, IEnumMediaTypes **enumeration)
+void VideoSurfaceFilter::onEOSTimerTimeout()
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&m_renderMutex);
 
-    return DirectShowMediaTypeList::cloneMediaType(token, index, enumeration);
+    if (m_EOSTimer) {
+        m_EOSTimer = 0;
+        checkEOS();
+    }
 }
 
-void VideoSurfaceFilter::customEvent(QEvent *event)
+void VideoSurfaceFilter::checkEOS()
 {
-    const int type = event->type();
-    if (type == StartSurface) {
-        QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&m_renderMutex);
 
-        m_startResult = start();
+    if (!m_EOS || m_EOSDelivered || m_EOSTimer)
+        return;
 
-        m_wait.wakeAll();
-    } else if (type == StopSurface) {
-        QMutexLocker locker(&m_mutex);
+    if (!m_clock) {
+        notifyEOS();
+        return;
+    }
 
-        stop();
+    REFERENCE_TIME eosTime = m_startTime + m_pendingSampleEndTime;
+    REFERENCE_TIME currentTime;
+    m_clock->GetTime(&currentTime);
+    LONG delay = LONG((eosTime - currentTime) / 10000);
 
-        m_wait.wakeAll();
-    } else if (type == FlushSurface) {
-        QMutexLocker locker(&m_mutex);
+    if (delay < 1) {
+        notifyEOS();
+    } else {
+        qCDebug(qLcRenderFilter, "will trigger EOS in %li", delay);
 
-        flush();
+        m_EOSTimer = timeSetEvent(delay,
+                                  1,
+                                  EOSTimerCallback,
+                                  reinterpret_cast<DWORD_PTR>(this),
+                                  TIME_ONESHOT | TIME_CALLBACK_FUNCTION | TIME_KILL_SYNCHRONOUS);
 
-        m_wait.wakeAll();
-    } else {
-       QObject::customEvent(event);
+        if (!m_EOSTimer) {
+            qDebug("Error with timer");
+            notifyEOS();
+        }
     }
 }
 
-void VideoSurfaceFilter::supportedFormatsChanged()
+void VideoSurfaceFilter::notifyEOS()
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&m_renderMutex);
 
-    // MEDIASUBTYPE_None;
-    static const GUID none = {
-        0xe436eb8e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };
+    if (!m_running)
+        return;
 
-    const QList<QVideoFrame::PixelFormat> formats = m_surface->supportedPixelFormats();
+    qCDebug(qLcRenderFilter, "notifyEOS, delivering EC_COMPLETE event");
 
-    QVector<AM_MEDIA_TYPE> mediaTypes;
-    mediaTypes.reserve(formats.count());
+    m_EOSTimer = 0;
+    m_EOSDelivered = true;
+    NotifyEvent(EC_COMPLETE, S_OK, (LONG_PTR)(IBaseFilter *)this);
+}
 
-    AM_MEDIA_TYPE type;
-    type.majortype = MEDIATYPE_Video;
-    type.bFixedSizeSamples = TRUE;
-    type.bTemporalCompression = FALSE;
-    type.lSampleSize = 0;
-    type.formattype = GUID_NULL;
-    type.pUnk = 0;
-    type.cbFormat = 0;
-    type.pbFormat = 0;
+void VideoSurfaceFilter::resetEOS()
+{
+    resetEOSTimer();
 
-    for (QVideoFrame::PixelFormat format : formats) {
-        type.subtype = DirectShowMediaType::convertPixelFormat(format);
+    QMutexLocker locker(&m_renderMutex);
 
-        if (type.subtype != none)
-            mediaTypes.append(type);
-    }
+    if (m_EOS)
+        qCDebug(qLcRenderFilter, "resetEOS (delivered=%s)", m_EOSDelivered ? "true" : "false");
 
-    setMediaTypes(mediaTypes);
+    m_EOS = false;
+    m_EOSDelivered = false;
+    m_pendingSampleEndTime = 0;
 }
 
-void VideoSurfaceFilter::sampleReady()
+void VideoSurfaceFilter::resetEOSTimer()
 {
-    bool eos = false;
+    if (m_EOSTimer) {
+        timeKillEvent(m_EOSTimer);
+        m_EOSTimer = 0;
+    }
+}
 
-    IMediaSample *sample = m_sampleScheduler.takeSample(&eos);
+bool VideoSurfaceFilter::startSurface()
+{
+    if (QThread::currentThread() != thread()) {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(StartSurface)));
+        m_waitSurface.wait(&m_mutex);
+        return m_surfaceStarted;
+    } else {
+        m_surfaceStarted = m_surface->start(m_surfaceFormat);
+        qCDebug(qLcRenderFilter, "startSurface %s", m_surfaceStarted ? "succeeded" : "failed");
+        return m_surfaceStarted;
+    }
+}
 
-    if (sample) {
-        QVideoFrame frame(new MediaSampleVideoBuffer(sample, m_bytesPerLine),
-                          m_surfaceFormat.frameSize(),
-                          m_surfaceFormat.pixelFormat());
+void VideoSurfaceFilter::stopSurface()
+{
+    if (!m_surfaceStarted)
+        return;
 
-        if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
-            LONGLONG position = 0;
-            seeking->GetCurrentPosition(&position);
-            seeking->Release();
+    if (QThread::currentThread() != thread()) {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(StopSurface)));
+        m_waitSurface.wait(&m_mutex);
+    } else {
+        qCDebug(qLcRenderFilter, "stopSurface");
+        m_surface->stop();
+        m_surfaceStarted = false;
+    }
+}
 
-            frame.setStartTime(position * 0.1);
+bool VideoSurfaceFilter::restartSurface()
+{
+    if (QThread::currentThread() != thread()) {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(RestartSurface)));
+        m_waitSurface.wait(&m_mutex);
+        return m_surfaceStarted;
+    } else {
+        m_surface->stop();
+        m_surfaceStarted = m_surface->start(m_surfaceFormat);
+        qCDebug(qLcRenderFilter, "restartSurface %s", m_surfaceStarted ? "succeeded" : "failed");
+        return m_surfaceStarted;
+    }
+}
 
-            REFERENCE_TIME startTime = -1;
-            REFERENCE_TIME endTime = -1;
-            if (sample->GetTime(&startTime, &endTime) == S_OK)
-                frame.setEndTime(frame.startTime() + (endTime - startTime) * 0.1);
-        }
+void VideoSurfaceFilter::flushSurface()
+{
+    if (QThread::currentThread() != thread()) {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(FlushSurface)));
+        m_waitSurface.wait(&m_mutex);
+    } else {
+        qCDebug(qLcRenderFilter, "flushSurface");
+        m_surface->present(QVideoFrame());
+    }
+}
 
-        m_surface->present(frame);
+void VideoSurfaceFilter::renderPendingSample()
+{
+    if (QThread::currentThread() != thread()) {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(RenderSample)));
+        m_waitSurface.wait(&m_mutex);
+    } else {
+        QMutexLocker locker(&m_renderMutex);
+        if (!m_pendingSample)
+            return;
 
-        sample->Release();
+        qCDebug(qLcRenderFilter, "presentSample (sample=%p)", m_pendingSample);
 
-        if (eos) {
-            if (IMediaEventSink *sink = com_cast<IMediaEventSink>(m_graph, IID_IMediaEventSink)) {
-                sink->Notify(
-                        EC_COMPLETE,
-                        S_OK,
-                        reinterpret_cast<LONG_PTR>(static_cast<IBaseFilter *>(this)));
-                sink->Release();
-            }
-        }
+        m_surface->present(QVideoFrame(new DirectShowVideoBuffer(m_pendingSample, m_bytesPerLine),
+                                       m_surfaceFormat.frameSize(),
+                                       m_surfaceFormat.pixelFormat()));
     }
 }
 
+bool VideoSurfaceFilter::event(QEvent *e)
+{
+    if (e->type() == QEvent::Type(StartSurface)) {
+        QMutexLocker locker(&m_mutex);
+        startSurface();
+        m_waitSurface.wakeAll();
+        return true;
+    } else if (e->type() == QEvent::Type(StopSurface)) {
+        QMutexLocker locker(&m_mutex);
+        stopSurface();
+        m_waitSurface.wakeAll();
+        return true;
+    } else if (e->type() == QEvent::Type(RestartSurface)) {
+        QMutexLocker locker(&m_mutex);
+        restartSurface();
+        m_waitSurface.wakeAll();
+        return true;
+    } else if (e->type() == QEvent::Type(FlushSurface)) {
+        QMutexLocker locker(&m_mutex);
+        flushSurface();
+        m_waitSurface.wakeAll();
+        return true;
+    } else if (e->type() == QEvent::Type(RenderSample)) {
+        QMutexLocker locker(&m_mutex);
+        renderPendingSample();
+        m_waitSurface.wakeAll();
+        return true;
+    }
+
+    return QObject::event(e);
+}
diff --git a/src/plugins/directshow/player/videosurfacefilter.h b/src/plugins/directshow/player/videosurfacefilter.h
index 001e2804b..581e33c70 100644
--- a/src/plugins/directshow/player/videosurfacefilter.h
+++ b/src/plugins/directshow/player/videosurfacefilter.h
@@ -40,135 +40,121 @@
 #ifndef VIDEOSURFACEFILTER_H
 #define VIDEOSURFACEFILTER_H
 
-#include "directshowglobal.h"
-#include "directshowmediatypelist.h"
-#include "directshowsamplescheduler.h"
-#include "directshowmediatype.h"
+#include "directshowbasefilter.h"
 
-#include <QtCore/qbasictimer.h>
 #include <QtCore/qcoreevent.h>
 #include <QtCore/qmutex.h>
-#include <QtCore/qsemaphore.h>
-#include <QtCore/qstring.h>
-#include <QtCore/qwaitcondition.h>
-
-#include <dshow.h>
+#include <qreadwritelock.h>
+#include <qsemaphore.h>
+#include <qwaitcondition.h>
 
 QT_BEGIN_NAMESPACE
 class QAbstractVideoSurface;
 QT_END_NAMESPACE
 
 class DirectShowEventLoop;
+class VideoSurfaceInputPin;
 
-class VideoSurfaceFilter
-    : public QObject
-    , public DirectShowMediaTypeList
-    , public IBaseFilter
-    , public IAMFilterMiscFlags
-    , public IPin
+class VideoSurfaceFilter : public QObject
+                         , public DirectShowBaseFilter
+                         , public IAMFilterMiscFlags
 {
     Q_OBJECT
+    DIRECTSHOW_OBJECT
 public:
-    VideoSurfaceFilter(
-            QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent = 0);
+    VideoSurfaceFilter(QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent = 0);
     ~VideoSurfaceFilter();
 
-    // IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
-    ULONG STDMETHODCALLTYPE AddRef();
-    ULONG STDMETHODCALLTYPE Release();
+    // DirectShowObject
+    HRESULT getInterface(REFIID riid, void **ppvObject);
+
+    // DirectShowBaseFilter
+    QList<DirectShowPin *> pins();
 
     // IPersist
-    HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
+    STDMETHODIMP GetClassID(CLSID *pClassID);
 
     // IMediaFilter
-    HRESULT STDMETHODCALLTYPE Run(REFERENCE_TIME tStart);
-    HRESULT STDMETHODCALLTYPE Pause();
-    HRESULT STDMETHODCALLTYPE Stop();
-
-    HRESULT STDMETHODCALLTYPE GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState);
-
-    HRESULT STDMETHODCALLTYPE SetSyncSource(IReferenceClock *pClock);
-    HRESULT STDMETHODCALLTYPE GetSyncSource(IReferenceClock **ppClock);
-
-    // IBaseFilter
-    HRESULT STDMETHODCALLTYPE EnumPins(IEnumPins **ppEnum);
-    HRESULT STDMETHODCALLTYPE FindPin(LPCWSTR Id, IPin **ppPin);
-
-    HRESULT STDMETHODCALLTYPE JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName);
-
-    HRESULT STDMETHODCALLTYPE QueryFilterInfo(FILTER_INFO *pInfo);
-    HRESULT STDMETHODCALLTYPE QueryVendorInfo(LPWSTR *pVendorInfo);
+    STDMETHODIMP Run(REFERENCE_TIME tStart);
+    STDMETHODIMP Pause();
+    STDMETHODIMP Stop();
 
     // IAMFilterMiscFlags
-    ULONG STDMETHODCALLTYPE GetMiscFlags();
+    STDMETHODIMP_(ULONG) GetMiscFlags();
 
-    // IPin
-    HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
-    HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
-    HRESULT STDMETHODCALLTYPE Disconnect();
-    HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **ppPin);
+    // DirectShowPin (delegate)
+    bool isMediaTypeSupported(const DirectShowMediaType *type);
+    bool setMediaType(const DirectShowMediaType *type);
+    HRESULT completeConnection(IPin *pin);
+    HRESULT connectionEnded();
 
-    HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
+    // IPin (delegate)
+    HRESULT EndOfStream();
+    HRESULT BeginFlush();
+    HRESULT EndFlush();
 
-    HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
-    HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
+    // IMemInputPin (delegate)
+    HRESULT Receive(IMediaSample *pMediaSample);
 
-    HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
+private Q_SLOTS:
+    void supportedFormatsChanged();
+    void checkEOS();
 
-    HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
+private:
+    enum Events {
+        StartSurface = QEvent::User,
+        StopSurface = QEvent::User + 1,
+        RestartSurface = QEvent::User + 2,
+        FlushSurface = QEvent::User + 3,
+        RenderSample = QEvent::User + 4
+    };
+
+    bool event(QEvent *);
 
-    HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
+    bool startSurface();
+    void stopSurface();
+    bool restartSurface();
+    void flushSurface();
 
-    HRESULT STDMETHODCALLTYPE EndOfStream();
+    bool scheduleSample(IMediaSample *sample);
+    void unscheduleSample();
+    void renderPendingSample();
+    void clearPendingSample();
 
-    HRESULT STDMETHODCALLTYPE BeginFlush();
-    HRESULT STDMETHODCALLTYPE EndFlush();
+    void notifyEOS();
+    void resetEOS();
+    void resetEOSTimer();
+    void onEOSTimerTimeout();
 
-    HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
+    friend void QT_WIN_CALLBACK EOSTimerCallback(UINT, UINT, DWORD_PTR dwUser, DWORD_PTR, DWORD_PTR);
 
-    HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
+    QMutex m_mutex;
 
-    int currentMediaTypeToken();
-    HRESULT nextMediaType(
-            int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount);
-    HRESULT skipMediaType(int token, int *index, ULONG count);
-    HRESULT cloneMediaType(int token, int index, IEnumMediaTypes **enumeration);
+    DirectShowEventLoop *m_loop;
+    VideoSurfaceInputPin *m_pin;
 
-protected:
-    void customEvent(QEvent *event);
+    QWaitCondition m_waitSurface;
+    QAbstractVideoSurface *m_surface;
+    QVideoSurfaceFormat m_surfaceFormat;
+    int m_bytesPerLine;
+    bool m_surfaceStarted;
 
-private Q_SLOTS:
-    void supportedFormatsChanged();
-    void sampleReady();
+    QList<GUID> m_supportedTypes;
+    QReadWriteLock m_typesLock;
 
-private:
-    HRESULT start();
-    void stop();
-    void flush();
+    QMutex m_renderMutex;
+    bool m_running;
+    IMediaSample *m_pendingSample;
+    REFERENCE_TIME m_pendingSampleEndTime;
+    HANDLE m_renderEvent;
+    HANDLE m_flushEvent;
+    DWORD_PTR m_adviseCookie;
 
-    enum
-    {
-        StartSurface = QEvent::User,
-        StopSurface,
-        FlushSurface
-    };
+    bool m_EOS;
+    bool m_EOSDelivered;
+    UINT m_EOSTimer;
 
-    LONG m_ref;
-    FILTER_STATE m_state;
-    QAbstractVideoSurface *m_surface;
-    DirectShowEventLoop *m_loop;
-    IFilterGraph *m_graph;
-    IPin *m_peerPin;
-    int m_bytesPerLine;
-    HRESULT m_startResult;
-    QString m_name;
-    QString m_pinId;
-    DirectShowMediaType m_mediaType;
-    QVideoSurfaceFormat m_surfaceFormat;
-    QMutex m_mutex;
-    QWaitCondition m_wait;
-    DirectShowSampleScheduler m_sampleScheduler;
+    friend class VideoSurfaceInputPin;
 };
 
 #endif