WMF: remove dead code.

Change-Id: Ib3b595263e64336cc5d0482edd890e7b4e534927
Reviewed-by: Christian Stromme <christian.stromme@digia.com>

1 files changed, 0 insertions, 333 deletions

diff --git a/src/plugins/wmf/player/mfplayersession.cpp b/src/plugins/wmf/player/mfplayersession.cpp
index c324116ee..04b46ec0d 100644
--- a/src/plugins/wmf/player/mfplayersession.cpp
+++ b/src/plugins/wmf/player/mfplayersession.cpp
@@ -68,339 +68,6 @@
 #include <wmcodecdsp.h>
 
 //#define DEBUG_MEDIAFOUNDATION
-//#define TEST_STREAMING
-
-namespace
-{
-    //MFStream is added for supporting QIODevice type of media source.
-    //It is used to delegate invocations from media foundation(through IMFByteStream) to QIODevice.
-    class MFStream : public QObject, public IMFByteStream
-    {
-        Q_OBJECT
-    public:
-        MFStream(QIODevice *stream, bool ownStream)
-            : m_cRef(1)
-            , m_stream(stream)
-            , m_ownStream(ownStream)
-            , m_currentReadResult(0)
-        {
-            //Move to the thread of the stream object
-            //to make sure invocations on stream
-            //are happened in the same thread of stream object
-            this->moveToThread(stream->thread());
-            connect(stream, SIGNAL(readyRead()), this, SLOT(handleReadyRead()));
-        }
-
-        ~MFStream()
-        {
-            if (m_currentReadResult)
-                m_currentReadResult->Release();
-            if (m_ownStream)
-                m_stream->deleteLater();
-        }
-
-        //from IUnknown
-        STDMETHODIMP QueryInterface(REFIID riid, LPVOID *ppvObject)
-        {
-            if (!ppvObject)
-                return E_POINTER;
-            if (riid == IID_IMFByteStream) {
-                *ppvObject = static_cast<IMFByteStream*>(this);
-            } else if (riid == IID_IUnknown) {
-                *ppvObject = static_cast<IUnknown*>(this);
-            } else {
-                *ppvObject =  NULL;
-                return E_NOINTERFACE;
-            }
-            AddRef();
-            return S_OK;
-        }
-
-        STDMETHODIMP_(ULONG) AddRef(void)
-        {
-            return InterlockedIncrement(&m_cRef);
-        }
-
-        STDMETHODIMP_(ULONG) Release(void)
-        {
-            LONG cRef = InterlockedDecrement(&m_cRef);
-            if (cRef == 0) {
-                this->deleteLater();
-            }
-            return cRef;
-        }
-
-
-        //from IMFByteStream
-        STDMETHODIMP GetCapabilities(DWORD *pdwCapabilities)
-        {
-            if (!pdwCapabilities)
-                return E_INVALIDARG;
-            *pdwCapabilities = MFBYTESTREAM_IS_READABLE;
-            if (!m_stream->isSequential())
-                *pdwCapabilities |= MFBYTESTREAM_IS_SEEKABLE;
-            return S_OK;
-        }
-
-        STDMETHODIMP GetLength(QWORD *pqwLength)
-        {
-            if (!pqwLength)
-                return E_INVALIDARG;
-            QMutexLocker locker(&m_mutex);
-            *pqwLength = QWORD(m_stream->size());
-            return S_OK;
-        }
-
-        STDMETHODIMP SetLength(QWORD)
-        {
-            return E_NOTIMPL;
-        }
-
-        STDMETHODIMP GetCurrentPosition(QWORD *pqwPosition)
-        {
-            if (!pqwPosition)
-                return E_INVALIDARG;
-            QMutexLocker locker(&m_mutex);
-            *pqwPosition = m_stream->pos();
-            return S_OK;
-        }
-
-        STDMETHODIMP SetCurrentPosition(QWORD qwPosition)
-        {
-            QMutexLocker locker(&m_mutex);
-            //SetCurrentPosition may happend during the BeginRead/EndRead pair,
-            //refusing to execute SetCurrentPosition during that time seems to be
-            //the simplest workable solution
-            if (m_currentReadResult)
-                return S_FALSE;
-
-            bool seekOK = m_stream->seek(qint64(qwPosition));
-            if (seekOK)
-                return S_OK;
-            else
-                return S_FALSE;
-        }
-
-        STDMETHODIMP IsEndOfStream(BOOL *pfEndOfStream)
-        {
-            if (!pfEndOfStream)
-                return E_INVALIDARG;
-            QMutexLocker locker(&m_mutex);
-            *pfEndOfStream = m_stream->atEnd() ? TRUE : FALSE;
-            return S_OK;
-        }
-
-        STDMETHODIMP Read(BYTE *pb, ULONG cb, ULONG *pcbRead)
-        {
-            QMutexLocker locker(&m_mutex);
-            qint64 read = m_stream->read((char*)(pb), qint64(cb));
-            if (pcbRead)
-                *pcbRead = ULONG(read);
-            return S_OK;
-        }
-
-        STDMETHODIMP BeginRead(BYTE *pb, ULONG cb, IMFAsyncCallback *pCallback,
-                               IUnknown *punkState)
-        {
-            if (!pCallback || !pb)
-                return E_INVALIDARG;
-
-            Q_ASSERT(m_currentReadResult == NULL);
-
-            AsyncReadState *state = new (std::nothrow) AsyncReadState(pb, cb);
-            if (state == NULL)
-                return E_OUTOFMEMORY;
-
-            HRESULT hr = MFCreateAsyncResult(state, pCallback, punkState, &m_currentReadResult);
-            state->Release();
-            if (FAILED(hr))
-                return hr;
-
-            QCoreApplication::postEvent(this, new QEvent(QEvent::User));
-            return hr;
-        }
-
-        STDMETHODIMP EndRead(IMFAsyncResult* pResult, ULONG *pcbRead)
-        {
-            if (!pcbRead)
-                return E_INVALIDARG;
-            IUnknown *pUnk;
-            pResult->GetObject(&pUnk);
-            AsyncReadState *state = static_cast<AsyncReadState*>(pUnk);
-            *pcbRead = state->bytesRead();
-            pUnk->Release();
-
-            m_currentReadResult->Release();
-            m_currentReadResult = NULL;
-
-            return S_OK;
-        }
-
-        STDMETHODIMP Write(const BYTE *, ULONG, ULONG *)
-        {
-            return E_NOTIMPL;
-        }
-
-        STDMETHODIMP BeginWrite(const BYTE *, ULONG ,
-                                IMFAsyncCallback *,
-                                IUnknown *)
-        {
-            return E_NOTIMPL;
-        }
-
-        STDMETHODIMP EndWrite(IMFAsyncResult *,
-                              ULONG *)
-        {
-            return E_NOTIMPL;
-        }
-
-        STDMETHODIMP Seek(
-            MFBYTESTREAM_SEEK_ORIGIN SeekOrigin,
-            LONGLONG llSeekOffset,
-            DWORD,
-            QWORD *pqwCurrentPosition)
-        {
-            QMutexLocker locker(&m_mutex);
-            if (m_currentReadResult)
-                return S_FALSE;
-
-            qint64 pos = qint64(llSeekOffset);
-            switch (SeekOrigin) {
-            case msoCurrent:
-                pos += m_stream->pos();
-                break;
-            }
-            bool seekOK = m_stream->seek(pos);
-            if (*pqwCurrentPosition)
-                *pqwCurrentPosition = pos;
-            if (seekOK)
-                return S_OK;
-            else
-                return S_FALSE;
-        }
-
-        STDMETHODIMP Flush()
-        {
-            return E_NOTIMPL;
-        }
-
-        STDMETHODIMP Close()
-        {
-            QMutexLocker locker(&m_mutex);
-            if (m_ownStream)
-                m_stream->close();
-            return S_OK;
-        }
-
-    private:
-        //AsyncReadState is a helper class used in BeginRead for asynchronous operation
-        //to record some BeginRead parameters, so these parameters could be
-        //used later when actually executing the read operation in another thread.
-        class AsyncReadState : public IUnknown
-        {
-        public:
-            AsyncReadState(BYTE *pb, ULONG cb)
-                : m_cRef(1)
-                , m_pb(pb)
-                , m_cb(cb)
-                , m_cbRead(0)
-            {
-            }
-
-            //from IUnknown
-            STDMETHODIMP QueryInterface(REFIID riid, LPVOID *ppvObject)
-            {
-                if (!ppvObject)
-                    return E_POINTER;
-
-                if (riid == IID_IUnknown) {
-                    *ppvObject = static_cast<IUnknown*>(this);
-                } else {
-                    *ppvObject =  NULL;
-                    return E_NOINTERFACE;
-                }
-                AddRef();
-                return S_OK;
-            }
-
-            STDMETHODIMP_(ULONG) AddRef(void)
-            {
-                return InterlockedIncrement(&m_cRef);
-            }
-
-            STDMETHODIMP_(ULONG) Release(void)
-            {
-                LONG cRef = InterlockedDecrement(&m_cRef);
-                if (cRef == 0)
-                    delete this;
-                // For thread safety, return a temporary variable.
-                return cRef;
-            }
-
-            BYTE* pb() const { return m_pb; }
-            ULONG cb() const { return m_cb; }
-            ULONG bytesRead() const { return m_cbRead; }
-
-            void setBytesRead(ULONG cbRead) { m_cbRead = cbRead; }
-
-        private:
-            long m_cRef;
-            BYTE *m_pb;
-            ULONG m_cb;
-            ULONG m_cbRead;
-        };
-
-        long m_cRef;
-        QIODevice *m_stream;
-        bool m_ownStream;
-        DWORD m_workQueueId;
-        QMutex m_mutex;
-
-        void doRead()
-        {
-            bool readDone = true;
-            IUnknown *pUnk = NULL;
-            HRESULT    hr = m_currentReadResult->GetObject(&pUnk);
-            if (SUCCEEDED(hr)) {
-                //do actual read
-                AsyncReadState *state =  static_cast<AsyncReadState*>(pUnk);
-                ULONG cbRead;
-                Read(state->pb(), state->cb() - state->bytesRead(), &cbRead);
-                pUnk->Release();
-
-                state->setBytesRead(cbRead + state->bytesRead());
-                if (state->cb() > state->bytesRead() && !m_stream->atEnd()) {
-                    readDone = false;
-                }
-            }
-
-            if (readDone) {
-                //now inform the original caller
-                m_currentReadResult->SetStatus(hr);
-                MFInvokeCallback(m_currentReadResult);
-            }
-        }
-
-
-    private Q_SLOTS:
-        void handleReadyRead()
-        {
-            doRead();
-        }
-
-    protected:
-        void customEvent(QEvent *event)
-        {
-            if (event->type() != QEvent::User) {
-                QObject::customEvent(event);
-                return;
-            }
-            doRead();
-        }
-        IMFAsyncResult *m_currentReadResult;
-    };
-}
-
 
 MFPlayerSession::MFPlayerSession(MFPlayerService *playerService)
     : m_playerService(playerService)