Remove MediaPlayerPrivate::supportsMuting()
[WebKit-https.git] / Source / WebCore / platform / graphics / win / MediaPlayerPrivateMediaFoundation.h
1 /*
2  * Copyright (C) 2014 Alex Christensen <achristensen@webkit.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #pragma once
28
29 #include "COMPtr.h"
30 #include "MediaPlayerPrivate.h"
31
32 #include <D3D9.h>
33 #include <Dxva2api.h>
34
35 #include <Mfapi.h>
36 #include <Mferror.h>
37 #include <Mfidl.h>
38 #include <evcode.h>
39 #include <evr.h>
40
41 #include <wtf/Deque.h>
42 #include <wtf/Lock.h>
43 #include <wtf/ThreadingPrimitives.h>
44 #include <wtf/WeakPtr.h>
45 #include <wtf/win/Win32Handle.h>
46
47 namespace WebCore {
48
49 class MediaPlayerPrivateMediaFoundation final : public MediaPlayerPrivateInterface, public CanMakeWeakPtr<MediaPlayerPrivateMediaFoundation> {
50 public:
51     explicit MediaPlayerPrivateMediaFoundation(MediaPlayer*);
52     ~MediaPlayerPrivateMediaFoundation();
53     static void registerMediaEngine(MediaEngineRegistrar);
54
55     static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types);
56     static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
57     static bool isAvailable();
58
59     void load(const String& url) final;
60     void cancelLoad() final;
61
62     void play() final;
63     void pause() final;
64
65     bool supportsFullscreen() const final;
66
67     FloatSize naturalSize() const final;
68
69     bool hasVideo() const final;
70     bool hasAudio() const final;
71
72     void setVisible(bool) final;
73
74     bool seeking() const final;
75     void seek(float) final;
76
77     void setRate(float) final;
78
79     float duration() const final;
80
81     float currentTime() const final;
82
83     bool paused() const final;
84
85     void setVolume(float) final;
86
87     void setMuted(bool) final;
88
89     MediaPlayer::NetworkState networkState() const final;
90     MediaPlayer::ReadyState readyState() const final;
91
92     float maxTimeSeekable() const final;
93
94     std::unique_ptr<PlatformTimeRanges> buffered() const final;
95
96     bool didLoadingProgress() const final;
97
98     void setSize(const IntSize&) final;
99
100     void paint(GraphicsContext&, const FloatRect&) final;
101
102 private:
103     WeakPtr<MediaPlayerPrivateMediaFoundation> m_weakThis;
104     MediaPlayer* m_player;
105     IntSize m_size;
106     bool m_visible;
107     bool m_loadingProgress;
108     bool m_paused;
109     bool m_hasAudio;
110     bool m_hasVideo;
111     bool m_preparingToPlay;
112     float m_volume;
113     MediaPlayer::NetworkState m_networkState;
114     MediaPlayer::ReadyState m_readyState;
115
116     class MediaPlayerListener;
117     HashSet<MediaPlayerListener*> m_listeners;
118     Lock m_mutexListeners;
119
120     FloatSize m_cachedNaturalSize;
121     mutable Lock m_cachedNaturalSizeLock;
122
123     COMPtr<IMFMediaSession> m_mediaSession;
124     COMPtr<IMFSourceResolver> m_sourceResolver;
125     COMPtr<IMFMediaSource> m_mediaSource;
126     COMPtr<IMFTopology> m_topology;
127     COMPtr<IMFPresentationDescriptor> m_sourcePD;
128     COMPtr<IMFVideoDisplayControl> m_videoDisplay;
129
130     bool createSession();
131     bool startSession();
132     bool endSession();
133     bool startCreateMediaSource(const String& url);
134     bool endCreatedMediaSource(IMFAsyncResult*);
135     bool endGetEvent(IMFAsyncResult*);
136     bool createTopologyFromSource();
137     bool addBranchToPartialTopology(int stream);
138     bool createOutputNode(COMPtr<IMFStreamDescriptor> sourceSD, COMPtr<IMFTopologyNode>&);
139     bool createSourceStreamNode(COMPtr<IMFStreamDescriptor> sourceSD, COMPtr<IMFTopologyNode>&);
140
141     void updateReadyState();
142
143     COMPtr<IMFVideoDisplayControl> videoDisplay();
144
145     void onCreatedMediaSource();
146     void onTopologySet();
147     void onBufferingStarted();
148     void onBufferingStopped();
149     void onSessionStarted();
150     void onSessionEnded();
151
152     HWND hostWindow();
153     void invalidateFrameView();
154
155     void addListener(MediaPlayerListener*);
156     void removeListener(MediaPlayerListener*);
157     void setNaturalSize(const FloatSize&);
158     void notifyDeleted();
159
160     bool setAllChannelVolumes(float);
161
162     class MediaPlayerListener {
163     public:
164         MediaPlayerListener() = default;
165         virtual ~MediaPlayerListener() = default;
166
167         virtual void onMediaPlayerDeleted() { }
168     };
169
170     class AsyncCallback : public IMFAsyncCallback, public MediaPlayerListener {
171     public:
172         AsyncCallback(MediaPlayerPrivateMediaFoundation*, bool event);
173         ~AsyncCallback();
174
175         HRESULT STDMETHODCALLTYPE QueryInterface(_In_ REFIID riid, __RPC__deref_out void __RPC_FAR *__RPC_FAR *ppvObject) override;
176         ULONG STDMETHODCALLTYPE AddRef() override;
177         ULONG STDMETHODCALLTYPE Release() override;
178
179         HRESULT STDMETHODCALLTYPE GetParameters(__RPC__out DWORD *pdwFlags, __RPC__out DWORD *pdwQueue) override;
180         HRESULT STDMETHODCALLTYPE Invoke(__RPC__in_opt IMFAsyncResult *pAsyncResult) override;
181
182         void onMediaPlayerDeleted() override;
183
184     private:
185         ULONG m_refCount;
186         MediaPlayerPrivateMediaFoundation* m_mediaPlayer;
187         bool m_event;
188         Lock m_mutex;
189     };
190
191     typedef Deque<COMPtr<IMFSample>> VideoSampleList;
192
193     class VideoSamplePool {
194     public:
195         VideoSamplePool() = default;
196         virtual ~VideoSamplePool() = default;
197
198         HRESULT initialize(VideoSampleList& samples);
199         void clear();
200
201         HRESULT getSample(COMPtr<IMFSample>&);
202         HRESULT returnSample(IMFSample*);
203         bool areSamplesPending();
204
205     private:
206         Lock m_lock;
207         VideoSampleList m_videoSampleQueue;
208         bool m_initialized { false };
209         unsigned m_pending { 0 };
210     };
211
212     class Direct3DPresenter;
213
214     class VideoScheduler {
215     public:
216         VideoScheduler() = default;
217         virtual ~VideoScheduler() = default;
218
219         void setPresenter(Direct3DPresenter* presenter) { m_presenter = presenter; }
220
221         void setFrameRate(const MFRatio& fps);
222         void setClockRate(float rate) { m_playbackRate = rate; }
223
224         const LONGLONG& lastSampleTime() const { return m_lastSampleTime; }
225         const LONGLONG& frameDuration() const { return m_frameDuration; }
226
227         HRESULT startScheduler(IMFClock*);
228         HRESULT stopScheduler();
229
230         HRESULT scheduleSample(IMFSample*, bool presentNow);
231         HRESULT processSamplesInQueue(LONG& nextSleep);
232         HRESULT processSample(IMFSample*, LONG& nextSleep);
233         HRESULT flush();
234
235     private:
236         static DWORD WINAPI schedulerThreadProc(LPVOID lpParameter);
237         DWORD schedulerThreadProcPrivate();
238
239         Deque<COMPtr<IMFSample>> m_scheduledSamples;
240         Lock m_lock;
241
242         COMPtr<IMFClock> m_clock;
243         Direct3DPresenter* m_presenter { nullptr };
244
245         DWORD m_threadID { 0 };
246         WTF::Win32Handle m_schedulerThread;
247         WTF::Win32Handle m_threadReadyEvent;
248         WTF::Win32Handle m_flushEvent;
249
250         float m_playbackRate { 1.0f };
251         MFTIME m_frameDuration { 0 };
252         MFTIME m_lastSampleTime { 0 };
253
254         std::atomic<bool> m_exitThread { false };
255
256         void stopThread() { m_exitThread = true; }
257     };
258
259     class Direct3DPresenter {
260     public:
261         Direct3DPresenter();
262         ~Direct3DPresenter();
263
264         enum DeviceState {
265             DeviceOK,
266             DeviceReset,
267             DeviceRemoved,
268         };
269
270         // Returns the IDirect3DDeviceManager9 interface.
271         HRESULT getService(REFGUID guidService, REFIID riid, void** ppv);
272
273         HRESULT checkFormat(D3DFORMAT);
274
275         HRESULT setVideoWindow(HWND);
276         HWND getVideoWindow() const { return m_hwnd; }
277         HRESULT setDestinationRect(const RECT& destRect);
278         RECT getDestinationRect() const { return m_destRect; };
279
280         HRESULT createVideoSamples(IMFMediaType* format, VideoSampleList& videoSampleQueue);
281         void releaseResources();
282
283         HRESULT checkDeviceState(DeviceState&);
284         HRESULT presentSample(IMFSample*, LONGLONG target);
285
286         UINT refreshRate() const { return m_displayMode.RefreshRate; }
287
288         void paintCurrentFrame(GraphicsContext&, const FloatRect&);
289
290     private:
291         HRESULT initializeD3D();
292         HRESULT getSwapChainPresentParameters(IMFMediaType*, D3DPRESENT_PARAMETERS* presentParams);
293         HRESULT createD3DDevice();
294         HRESULT createD3DSample(IDirect3DSwapChain9*, COMPtr<IMFSample>& videoSample);
295
296         UINT m_deviceResetToken { 0 };
297         HWND m_hwnd { nullptr };
298         RECT m_destRect;
299         D3DDISPLAYMODE m_displayMode;
300
301         Lock m_lock;
302         
303         COMPtr<IDirect3D9Ex> m_direct3D9;
304         COMPtr<IDirect3DDevice9Ex> m_device;
305         COMPtr<IDirect3DDeviceManager9> m_deviceManager;
306         COMPtr<IDirect3DSurface9> m_surfaceRepaint;
307
308         COMPtr<IDirect3DSurface9> m_memSurface;
309         int m_width { 0 };
310         int m_height { 0 };
311     };
312
313     class CustomVideoPresenter
314         : public IMFVideoPresenter
315         , public IMFVideoDeviceID
316         , public IMFTopologyServiceLookupClient
317         , public IMFGetService
318         , public IMFActivate
319         , public IMFVideoDisplayControl
320         , public IMFAsyncCallback
321         , public MediaPlayerListener {
322     public:
323         CustomVideoPresenter(MediaPlayerPrivateMediaFoundation*);
324         ~CustomVideoPresenter();
325
326         HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, __RPC__deref_out void __RPC_FAR *__RPC_FAR *ppvObject) override;
327         ULONG STDMETHODCALLTYPE AddRef() override;
328         ULONG STDMETHODCALLTYPE Release() override;
329
330         // IMFClockStateSink
331         HRESULT STDMETHODCALLTYPE OnClockStart(MFTIME hnsSystemTime, LONGLONG llClockStartOffset) override;
332         HRESULT STDMETHODCALLTYPE OnClockStop(MFTIME hnsSystemTime) override;
333         HRESULT STDMETHODCALLTYPE OnClockPause(MFTIME hnsSystemTime) override;
334         HRESULT STDMETHODCALLTYPE OnClockRestart(MFTIME hnsSystemTime) override;
335         HRESULT STDMETHODCALLTYPE OnClockSetRate(MFTIME hnsSystemTime, float flRate) override;
336
337         // IMFVideoPresenter
338         HRESULT STDMETHODCALLTYPE ProcessMessage(MFVP_MESSAGE_TYPE eMessage, ULONG_PTR ulParam) override;
339         HRESULT STDMETHODCALLTYPE GetCurrentMediaType(_Outptr_  IMFVideoMediaType **ppMediaType) override;
340
341         // IMFVideoDeviceID
342         HRESULT STDMETHODCALLTYPE GetDeviceID(IID* pDeviceID) override;
343
344         // IMFTopologyServiceLookupClient
345         HRESULT STDMETHODCALLTYPE InitServicePointers(_In_  IMFTopologyServiceLookup *pLookup) override;
346         HRESULT STDMETHODCALLTYPE ReleaseServicePointers(void) override;
347
348         // IMFGetService
349         HRESULT STDMETHODCALLTYPE GetService(REFGUID guidService, REFIID riid, LPVOID *ppvObject) override;
350
351         // IMFActivate
352         HRESULT STDMETHODCALLTYPE ActivateObject(REFIID riid, void **ppv) override;
353         HRESULT STDMETHODCALLTYPE DetachObject() override;
354         HRESULT STDMETHODCALLTYPE ShutdownObject() override;
355
356         // IMFAttributes
357         HRESULT STDMETHODCALLTYPE GetItem(__RPC__in REFGUID guidKey, __RPC__inout_opt PROPVARIANT *pValue) override { return E_NOTIMPL; }
358         HRESULT STDMETHODCALLTYPE GetItemType(__RPC__in REFGUID guidKey, __RPC__out MF_ATTRIBUTE_TYPE *pType) override { return E_NOTIMPL; }
359         HRESULT STDMETHODCALLTYPE CompareItem(__RPC__in REFGUID guidKey, __RPC__in REFPROPVARIANT Value, __RPC__out BOOL *pbResult) override { return E_NOTIMPL; }
360         HRESULT STDMETHODCALLTYPE Compare(__RPC__in_opt IMFAttributes *pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, __RPC__out BOOL *pbResult) override { return E_NOTIMPL; }
361         HRESULT STDMETHODCALLTYPE GetUINT32(__RPC__in REFGUID guidKey, __RPC__out UINT32 *punValue) override { return E_NOTIMPL; }
362         HRESULT STDMETHODCALLTYPE GetUINT64(__RPC__in REFGUID guidKey, __RPC__out UINT64 *punValue) override { return E_NOTIMPL; }
363         HRESULT STDMETHODCALLTYPE GetDouble(__RPC__in REFGUID guidKey, __RPC__out double *pfValue) override { return E_NOTIMPL; }
364         HRESULT STDMETHODCALLTYPE GetGUID(__RPC__in REFGUID guidKey, __RPC__out GUID *pguidValue) override { return E_NOTIMPL; }
365         HRESULT STDMETHODCALLTYPE GetStringLength(__RPC__in REFGUID guidKey, __RPC__out UINT32 *pcchLength) override { return E_NOTIMPL; }
366         HRESULT STDMETHODCALLTYPE GetString(__RPC__in REFGUID guidKey, __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, UINT32 cchBufSize, __RPC__inout_opt UINT32 *pcchLength) override { return E_NOTIMPL; }
367         HRESULT STDMETHODCALLTYPE GetAllocatedString(__RPC__in REFGUID guidKey, __RPC__deref_out_ecount_full_opt((*pcchLength + 1)) LPWSTR *ppwszValue, __RPC__out UINT32 *pcchLength) override { return E_NOTIMPL; }
368         HRESULT STDMETHODCALLTYPE GetBlobSize(__RPC__in REFGUID guidKey, __RPC__out UINT32 *pcbBlobSize) override { return E_NOTIMPL; }
369         HRESULT STDMETHODCALLTYPE GetBlob(__RPC__in REFGUID guidKey, __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, UINT32 cbBufSize, __RPC__inout_opt UINT32 *pcbBlobSize) override { return E_NOTIMPL; }
370         HRESULT STDMETHODCALLTYPE GetAllocatedBlob(__RPC__in REFGUID guidKey, __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, __RPC__out UINT32 *pcbSize) override { return E_NOTIMPL; }
371         HRESULT STDMETHODCALLTYPE GetUnknown(__RPC__in REFGUID guidKey, __RPC__in REFIID riid, __RPC__deref_out_opt LPVOID *ppv) override { return E_NOTIMPL; }
372         HRESULT STDMETHODCALLTYPE SetItem(__RPC__in REFGUID guidKey, __RPC__in REFPROPVARIANT Value) override { return E_NOTIMPL; }
373         HRESULT STDMETHODCALLTYPE DeleteItem(__RPC__in REFGUID guidKey) override { return E_NOTIMPL; }
374         HRESULT STDMETHODCALLTYPE DeleteAllItems(void) override { return E_NOTIMPL; }
375         HRESULT STDMETHODCALLTYPE SetUINT32(__RPC__in REFGUID guidKey, UINT32 unValue) override { return E_NOTIMPL; }
376         HRESULT STDMETHODCALLTYPE SetUINT64(__RPC__in REFGUID guidKey, UINT64 unValue) override { return E_NOTIMPL; }
377         HRESULT STDMETHODCALLTYPE SetDouble(__RPC__in REFGUID guidKey, double fValue) override { return E_NOTIMPL; }
378         HRESULT STDMETHODCALLTYPE SetGUID(__RPC__in REFGUID guidKey, __RPC__in REFGUID guidValue) override { return E_NOTIMPL; }
379         HRESULT STDMETHODCALLTYPE SetString(__RPC__in REFGUID guidKey, __RPC__in_string LPCWSTR wszValue) override { return E_NOTIMPL; }
380         HRESULT STDMETHODCALLTYPE SetBlob(__RPC__in REFGUID guidKey, __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, UINT32 cbBufSize) override { return E_NOTIMPL; }
381         HRESULT STDMETHODCALLTYPE SetUnknown(__RPC__in REFGUID guidKey, __RPC__in_opt IUnknown *pUnknown) override { return E_NOTIMPL; }
382         HRESULT STDMETHODCALLTYPE LockStore(void) override { return E_NOTIMPL; }
383         HRESULT STDMETHODCALLTYPE UnlockStore(void) override { return E_NOTIMPL; }
384         HRESULT STDMETHODCALLTYPE GetCount(__RPC__out UINT32 *pcItems) override { return E_NOTIMPL; }
385         HRESULT STDMETHODCALLTYPE GetItemByIndex(UINT32 unIndex, __RPC__out GUID *pguidKey, __RPC__inout_opt PROPVARIANT *pValue) override { return E_NOTIMPL; }
386         HRESULT STDMETHODCALLTYPE CopyAllItems(__RPC__in_opt IMFAttributes *pDest) override { return E_NOTIMPL; }
387
388         // IMFVideoDisplayControl
389         HRESULT STDMETHODCALLTYPE GetNativeVideoSize(SIZE* pszVideo, SIZE* pszARVideo) override { return E_NOTIMPL; }
390         HRESULT STDMETHODCALLTYPE GetIdealVideoSize(SIZE* pszMin, SIZE* pszMax) override { return E_NOTIMPL; }
391         HRESULT STDMETHODCALLTYPE SetVideoPosition(const MFVideoNormalizedRect* pnrcSource, const LPRECT prcDest) override;
392         HRESULT STDMETHODCALLTYPE GetVideoPosition(MFVideoNormalizedRect* pnrcSource, LPRECT prcDest) override;
393         HRESULT STDMETHODCALLTYPE SetAspectRatioMode(DWORD dwAspectRatioMode) override { return E_NOTIMPL; }
394         HRESULT STDMETHODCALLTYPE GetAspectRatioMode(DWORD* pdwAspectRatioMode) override { return E_NOTIMPL; }
395         HRESULT STDMETHODCALLTYPE SetVideoWindow(HWND hwndVideo) override;
396         HRESULT STDMETHODCALLTYPE GetVideoWindow(HWND* phwndVideo) override;
397         HRESULT STDMETHODCALLTYPE RepaintVideo() override;
398         HRESULT STDMETHODCALLTYPE GetCurrentImage(BITMAPINFOHEADER* pBih, BYTE** pDib, DWORD* pcbDib, LONGLONG* pTimeStamp) override { return E_NOTIMPL; }
399         HRESULT STDMETHODCALLTYPE SetBorderColor(COLORREF Clr) override { return E_NOTIMPL; }
400         HRESULT STDMETHODCALLTYPE GetBorderColor(COLORREF* pClr) override { return E_NOTIMPL; }
401         HRESULT STDMETHODCALLTYPE SetRenderingPrefs(DWORD dwRenderFlags) override { return E_NOTIMPL; }
402         HRESULT STDMETHODCALLTYPE GetRenderingPrefs(DWORD* pdwRenderFlags) override { return E_NOTIMPL; }
403         HRESULT STDMETHODCALLTYPE SetFullscreen(BOOL bFullscreen) override { return E_NOTIMPL; }
404         HRESULT STDMETHODCALLTYPE GetFullscreen(BOOL* pbFullscreen) override { return E_NOTIMPL; }
405
406         // IMFAsyncCallback methods
407         HRESULT STDMETHODCALLTYPE GetParameters(DWORD*, DWORD*) override { return E_NOTIMPL; }
408         HRESULT STDMETHODCALLTYPE Invoke(IMFAsyncResult* pAsyncResult) override;
409
410         // MediaPlayerListener
411         void onMediaPlayerDeleted() override;
412
413         void paintCurrentFrame(GraphicsContext&, const FloatRect&);
414
415         float currentTime();
416
417         float maxTimeLoaded() const { return m_maxTimeLoaded; }
418
419     private:
420         ULONG m_refCount { 0 };
421         Lock m_lock;
422         MediaPlayerPrivateMediaFoundation* m_mediaPlayer;
423
424         enum RenderState {
425             RenderStateStarted = 1,
426             RenderStateStopped,
427             RenderStatePaused,
428             RenderStateShutdown,
429         };
430
431         RenderState m_renderState { RenderStateShutdown };
432         COMPtr<IMFClock> m_clock;
433         COMPtr<IMediaEventSink> m_mediaEventSink;
434         COMPtr<IMFTransform> m_mixer;
435         COMPtr<IMFMediaType> m_mediaType;
436         std::unique_ptr<Direct3DPresenter> m_presenterEngine;
437         MFVideoNormalizedRect m_sourceRect;
438         bool m_sampleNotify { false };
439         bool m_prerolled { false };
440         bool m_repaint { false };
441         bool m_endStreaming { false };
442         VideoScheduler m_scheduler;
443         VideoSamplePool m_samplePool;
444         unsigned m_tokenCounter { 0 };
445         float m_rate { 1.0f };
446         float m_maxTimeLoaded { 0.0f };
447
448         bool isActive() const;
449
450         bool isScrubbing() const { return m_rate == 0.0f; }
451
452         HRESULT configureMixer(IMFTransform* mixer);
453         HRESULT flush();
454         HRESULT setMediaType(IMFMediaType*);
455         HRESULT checkShutdown() const;
456         HRESULT renegotiateMediaType();
457         HRESULT processInputNotify();
458         HRESULT beginStreaming();
459         HRESULT endStreaming();
460         HRESULT checkEndOfStream();
461         HRESULT isMediaTypeSupported(IMFMediaType*);
462         HRESULT createOptimalVideoType(IMFMediaType* proposedType, IMFMediaType** optimalType);
463         HRESULT calculateOutputRectangle(IMFMediaType* proposedType, RECT& outputRect);
464
465         void processOutputLoop();
466         HRESULT processOutput();
467         HRESULT deliverSample(IMFSample*, bool repaint);
468         HRESULT trackSample(IMFSample*);
469         void releaseResources();
470
471         HRESULT onSampleFree(IMFAsyncResult*);
472
473         void notifyEvent(long EventCode, LONG_PTR Param1, LONG_PTR Param2);
474     };
475
476     COMPtr<CustomVideoPresenter> m_presenter;
477 };
478
479 }