Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef EVRCUSTOMPRESENTER_H
#define EVRCUSTOMPRESENTER_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QObject>
#include <qmutex.h>
#include <qqueue.h>
#include <qevent.h>
#include <qrect.h>
#include <qvideoframeformat.h>
#include <qvideosink.h>
#include <qpointer.h>
#include <QtCore/private/qcomptr_p.h>
#include "evrhelpers_p.h"
#include <d3d9.h>
#include <dxva2api.h>
#include <evr9.h>
#include <evr.h>
#include <mfidl.h>
#include <mfapi.h>
#include <mferror.h>
QT_BEGIN_NAMESPACE
class EVRCustomPresenter;
class D3DPresentEngine;
template<class T>
class AsyncCallback : public IMFAsyncCallback
{
Q_DISABLE_COPY(AsyncCallback)
public:
typedef HRESULT (T::*InvokeFn)(IMFAsyncResult *asyncResult);
AsyncCallback(T *parent, InvokeFn fn) : m_parent(parent), m_invokeFn(fn)
{
}
// IUnknown
STDMETHODIMP QueryInterface(REFIID iid, void** ppv) override
{
if (!ppv)
return E_POINTER;
if (iid == __uuidof(IUnknown)) {
*ppv = static_cast<IUnknown*>(static_cast<IMFAsyncCallback*>(this));
} else if (iid == __uuidof(IMFAsyncCallback)) {
*ppv = static_cast<IMFAsyncCallback*>(this);
} else {
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
STDMETHODIMP_(ULONG) AddRef() override {
// Delegate to parent class.
return m_parent->AddRef();
}
STDMETHODIMP_(ULONG) Release() override {
// Delegate to parent class.
return m_parent->Release();
}
// IMFAsyncCallback methods
STDMETHODIMP GetParameters(DWORD*, DWORD*) override
{
// Implementation of this method is optional.
return E_NOTIMPL;
}
STDMETHODIMP Invoke(IMFAsyncResult* asyncResult) override
{
return (m_parent->*m_invokeFn)(asyncResult);
}
T *m_parent;
InvokeFn m_invokeFn;
};
class Scheduler
{
Q_DISABLE_COPY(Scheduler)
public:
enum ScheduleEvent
{
Terminate = WM_USER,
Schedule = WM_USER + 1,
Flush = WM_USER + 2
};
Scheduler(EVRCustomPresenter *presenter);
~Scheduler();
void setFrameRate(const MFRatio &fps);
void setClockRate(float rate) { m_playbackRate = rate; }
HRESULT startScheduler(ComPtr<IMFClock> clock);
HRESULT stopScheduler();
HRESULT scheduleSample(const ComPtr<IMFSample> &sample, bool presentNow);
HRESULT processSamplesInQueue(LONG *nextSleep);
HRESULT flush();
bool areSamplesScheduled();
// ThreadProc for the scheduler thread.
static DWORD WINAPI schedulerThreadProc(LPVOID parameter);
private:
DWORD schedulerThreadProcPrivate();
bool isSampleReadyToPresent(IMFSample *sample, LONG *pNextSleep) const;
EVRCustomPresenter *m_presenter;
QQueue<ComPtr<IMFSample>> m_scheduledSamples; // Samples waiting to be presented.
ComPtr<IMFClock> m_clock; // Presentation clock. Can be NULL.
DWORD m_threadID;
ThreadHandle m_schedulerThread;
EventHandle m_threadReadyEvent;
EventHandle m_flushEvent;
float m_playbackRate;
MFTIME m_perFrame_1_4th; // 1/4th of the frame duration.
QMutex m_mutex;
};
class SamplePool
{
Q_DISABLE_COPY(SamplePool)
public:
SamplePool();
~SamplePool();
HRESULT initialize(QList<ComPtr<IMFSample>> &&samples);
HRESULT clear();
ComPtr<IMFSample> takeSample();
void returnSample(const ComPtr<IMFSample> &sample);
private:
QMutex m_mutex;
QList<ComPtr<IMFSample>> m_videoSampleQueue;
bool m_initialized;
};
class EVRCustomPresenter
: public QObject
, public IMFVideoDeviceID
, public IMFVideoPresenter // Inherits IMFClockStateSink
, public IMFRateSupport
, public IMFGetService
, public IMFTopologyServiceLookupClient
{
Q_DISABLE_COPY(EVRCustomPresenter)
public:
// Defines the state of the presenter.
enum RenderState
{
RenderStarted = 1,
RenderStopped,
RenderPaused,
RenderShutdown // Initial state.
};
// Defines the presenter's state with respect to frame-stepping.
enum FrameStepState
{
FrameStepNone, // Not frame stepping.
FrameStepWaitingStart, // Frame stepping, but the clock is not started.
FrameStepPending, // Clock is started. Waiting for samples.
FrameStepScheduled, // Submitted a sample for rendering.
FrameStepComplete // Sample was rendered.
};
enum PresenterEvents
{
StartSurface = QEvent::User,
StopSurface = QEvent::User + 1,
PresentSample = QEvent::User + 2
};
EVRCustomPresenter(QVideoSink *sink = 0);
~EVRCustomPresenter() override;
bool isValid() const;
// IUnknown methods
STDMETHODIMP QueryInterface(REFIID riid, void ** ppv) override;
STDMETHODIMP_(ULONG) AddRef() override;
STDMETHODIMP_(ULONG) Release() override;
// IMFGetService methods
STDMETHODIMP GetService(REFGUID guidService, REFIID riid, LPVOID *ppvObject) override;
// IMFVideoPresenter methods
STDMETHODIMP ProcessMessage(MFVP_MESSAGE_TYPE message, ULONG_PTR param) override;
STDMETHODIMP GetCurrentMediaType(IMFVideoMediaType** mediaType) override;
// IMFClockStateSink methods
STDMETHODIMP OnClockStart(MFTIME systemTime, LONGLONG clockStartOffset) override;
STDMETHODIMP OnClockStop(MFTIME systemTime) override;
STDMETHODIMP OnClockPause(MFTIME systemTime) override;
STDMETHODIMP OnClockRestart(MFTIME systemTime) override;
STDMETHODIMP OnClockSetRate(MFTIME systemTime, float rate) override;
// IMFRateSupport methods
STDMETHODIMP GetSlowestRate(MFRATE_DIRECTION direction, BOOL thin, float *rate) override;
STDMETHODIMP GetFastestRate(MFRATE_DIRECTION direction, BOOL thin, float *rate) override;
STDMETHODIMP IsRateSupported(BOOL thin, float rate, float *nearestSupportedRate) override;
// IMFVideoDeviceID methods
STDMETHODIMP GetDeviceID(IID* deviceID) override;
// IMFTopologyServiceLookupClient methods
STDMETHODIMP InitServicePointers(IMFTopologyServiceLookup *lookup) override;
STDMETHODIMP ReleaseServicePointers() override;
void supportedFormatsChanged();
void setSink(QVideoSink *sink);
void setCropRect(QRect cropRect);
void startSurface();
void stopSurface();
void presentSample(const ComPtr<IMFSample> &sample);
bool event(QEvent *) override;
public Q_SLOTS:
void positionChanged(qint64 position);
private:
HRESULT checkShutdown() const
{
if (m_renderState == RenderShutdown)
return MF_E_SHUTDOWN;
else
return S_OK;
}
// The "active" state is started or paused.
inline bool isActive() const
{
return ((m_renderState == RenderStarted) || (m_renderState == RenderPaused));
}
// Scrubbing occurs when the frame rate is 0.
inline bool isScrubbing() const { return m_playbackRate == 0.0f; }
// Send an event to the EVR through its IMediaEventSink interface.
void notifyEvent(long eventCode, LONG_PTR param1, LONG_PTR param2)
{
if (m_mediaEventSink)
m_mediaEventSink->Notify(eventCode, param1, param2);
}
float getMaxRate(bool thin);
// Mixer operations
HRESULT configureMixer(IMFTransform *mixer);
// Formats
HRESULT createOptimalVideoType(IMFMediaType* proposed, IMFMediaType **optimal);
HRESULT setMediaType(IMFMediaType *mediaType);
HRESULT isMediaTypeSupported(IMFMediaType *mediaType);
// Message handlers
HRESULT flush();
HRESULT renegotiateMediaType();
HRESULT processInputNotify();
HRESULT beginStreaming();
HRESULT endStreaming();
HRESULT checkEndOfStream();
// Managing samples
void processOutputLoop();
HRESULT processOutput();
HRESULT deliverSample(const ComPtr<IMFSample> &sample);
HRESULT trackSample(const ComPtr<IMFSample> &sample);
void releaseResources();
// Frame-stepping
HRESULT prepareFrameStep(DWORD steps);
HRESULT startFrameStep();
HRESULT deliverFrameStepSample(const ComPtr<IMFSample> &sample);
HRESULT completeFrameStep(const ComPtr<IMFSample> &sample);
HRESULT cancelFrameStep();
// Callback when a video sample is released.
HRESULT onSampleFree(IMFAsyncResult *result);
AsyncCallback<EVRCustomPresenter> m_sampleFreeCB;
// Holds information related to frame-stepping.
struct FrameStep
{
FrameStepState state = FrameStepNone;
QList<ComPtr<IMFSample>> samples;
DWORD steps = 0;
DWORD_PTR sampleNoRef = 0;
};
long m_refCount;
RenderState m_renderState;
FrameStep m_frameStep;
QRecursiveMutex m_mutex;
// Samples and scheduling
Scheduler m_scheduler; // Manages scheduling of samples.
SamplePool m_samplePool; // Pool of allocated samples.
DWORD m_tokenCounter; // Counter. Incremented whenever we create new samples.
// Rendering state
bool m_sampleNotify; // Did the mixer signal it has an input sample?
bool m_prerolled; // Have we presented at least one sample?
bool m_endStreaming; // Did we reach the end of the stream (EOS)?
MFVideoNormalizedRect m_sourceRect;
float m_playbackRate;
D3DPresentEngine *m_presentEngine; // Rendering engine. (Never null if the constructor succeeds.)
ComPtr<IMFClock> m_clock; // The EVR's clock.
ComPtr<IMFTransform> m_mixer; // The EVR's mixer.
ComPtr<IMediaEventSink> m_mediaEventSink; // The EVR's event-sink interface.
ComPtr<IMFMediaType> m_mediaType; // Output media type
QPointer<QVideoSink> m_videoSink;
bool m_canRenderToSurface;
qint64 m_positionOffset; // Seek position in microseconds.
QRect m_cropRect; // Video crop rectangle
};
bool qt_evr_setCustomPresenter(IUnknown *evr, EVRCustomPresenter *presenter);
QT_END_NAMESPACE
#endif // EVRCUSTOMPRESENTER_H