1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/mediactrl.cpp
3 // Purpose: Built-in Media Backends for Windows
4 // Author: Ryan Norton <wxprojects@comcast.net>
8 // Copyright: (c) Ryan Norton
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 //===========================================================================
14 //===========================================================================
16 //---------------------------------------------------------------------------
17 // Pre-compiled header stuff
18 //---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "mediactrl.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
31 //---------------------------------------------------------------------------
33 //---------------------------------------------------------------------------
34 #include "wx/mediactrl.h"
36 //---------------------------------------------------------------------------
38 //---------------------------------------------------------------------------
41 //---------------------------------------------------------------------------
42 // Externals (somewhere in src/msw/app.cpp)
43 //---------------------------------------------------------------------------
44 extern "C" WXDLLIMPEXP_BASE HINSTANCE
wxGetInstance(void);
46 extern WXDLLIMPEXP_CORE wxChar
*wxCanvasClassName
;
48 extern WXDLLIMPEXP_CORE
const wxChar
*wxCanvasClassName
;
51 //===========================================================================
52 // BACKEND DECLARATIONS
53 //===========================================================================
55 //---------------------------------------------------------------------------
59 //---------------------------------------------------------------------------
61 //---------------------------------------------------------------------------
62 // Compilation guard for DirectShow
63 //---------------------------------------------------------------------------
66 //---------------------------------------------------------------------------
68 //---------------------------------------------------------------------------
69 #include "wx/msw/ole/oleutils.h" //wxBasicString, IID etc.
70 #include "wx/msw/ole/uuid.h" //IID etc..
72 //---------------------------------------------------------------------------
73 // IIDS - used by CoCreateInstance and IUnknown::QueryInterface
74 //---------------------------------------------------------------------------
75 const IID LIBID_QuartzTypeLib
= {0x56A868B0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
76 const IID IID_IAMCollection
= {0x56A868B9,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
77 const IID IID_IMediaControl
= {0x56A868B1,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
78 const IID IID_IMediaEvent
= {0x56A868B6,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
79 const IID IID_IMediaEventEx
= {0x56A868C0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
80 const IID IID_IMediaPosition
= {0x56A868B2,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
81 const IID IID_IBasicAudio
= {0x56A868B3,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
82 const IID IID_IVideoWindow
= {0x56A868B4,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
83 const IID IID_IBasicVideo
= {0x56A868B5,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
84 const IID IID_IBasicVideo2
= {0x329BB360,0xF6EA,0x11D1,{0x90,0x38,0x00,0xA0,0xC9,0x69,0x72,0x98}};
85 const IID IID_IDeferredCommand
= {0x56A868B8,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
86 const IID IID_IQueueCommand
= {0x56A868B7,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
87 const IID IID_IFilterInfo
= {0x56A868BA,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
88 const IID IID_IRegFilterInfo
= {0x56A868BB,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
89 const IID IID_IMediaTypeInfo
= {0x56A868BC,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
90 const IID IID_IPinInfo
= {0x56A868BD,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
91 const IID IID_IAMStats
= {0xBC9BCF80,0xDCD2,0x11D2,{0xAB,0xF6,0x00,0xA0,0xC9,0x05,0xF3,0x75}};
93 //TODO: These 4 lines needed?
97 #endif // CLSID_DEFINED
100 const CLSID CLSID_FilgraphManager
= {0xE436EBB3,0x524F,0x11CE,{0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
102 //---------------------------------------------------------------------------
103 // COM INTERFACES (dumped from midl from quartz.idl from MSVC COM Browser)
104 //---------------------------------------------------------------------------
105 MIDL_INTERFACE("56A868B9-0AD4-11CE-B03A-0020AF0BA770")
106 IAMCollection
: public IDispatch
109 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Count(
110 /* [retval][out] */ long __RPC_FAR
*plCount
) = 0;
112 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Item(
113 /* [in] */ long lItem
,
114 /* [out] */ IUnknown __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
116 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get__NewEnum(
117 /* [retval][out] */ IUnknown __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
121 MIDL_INTERFACE("56A868B1-0AD4-11CE-B03A-0020AF0BA770")
122 IMediaControl
: public IDispatch
125 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Run( void) = 0;
127 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Pause( void) = 0;
129 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Stop( void) = 0;
131 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetState(
132 /* [in] */ long msTimeout
,
133 /* [out] */ long __RPC_FAR
*pfs
) = 0;
135 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
RenderFile(
136 /* [in] */ BSTR strFilename
) = 0;
138 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
AddSourceFilter(
139 /* [in] */ BSTR strFilename
,
140 /* [out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
142 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_FilterCollection(
143 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
145 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_RegFilterCollection(
146 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
148 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
StopWhenReady( void) = 0;
152 MIDL_INTERFACE("56A868B6-0AD4-11CE-B03A-0020AF0BA770")
153 IMediaEvent
: public IDispatch
156 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetEventHandle(
157 /* [out] */ LONG_PTR __RPC_FAR
*hEvent
) = 0;
159 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetEvent(
160 /* [out] */ long __RPC_FAR
*lEventCode
,
161 /* [out] */ LONG_PTR __RPC_FAR
*lParam1
,
162 /* [out] */ LONG_PTR __RPC_FAR
*lParam2
,
163 /* [in] */ long msTimeout
) = 0;
165 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
WaitForCompletion(
166 /* [in] */ long msTimeout
,
167 /* [out] */ long __RPC_FAR
*pEvCode
) = 0;
169 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
CancelDefaultHandling(
170 /* [in] */ long lEvCode
) = 0;
172 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
RestoreDefaultHandling(
173 /* [in] */ long lEvCode
) = 0;
175 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
FreeEventParams(
176 /* [in] */ long lEvCode
,
177 /* [in] */ LONG_PTR lParam1
,
178 /* [in] */ LONG_PTR lParam2
) = 0;
182 MIDL_INTERFACE("56A868C0-0AD4-11CE-B03A-0020AF0BA770")
183 IMediaEventEx
: public IMediaEvent
186 virtual HRESULT __stdcall
SetNotifyWindow(
187 /* [in] */ LONG_PTR hwnd
,
188 /* [in] */ long lMsg
,
189 /* [in] */ LONG_PTR lInstanceData
) = 0;
191 virtual HRESULT __stdcall
SetNotifyFlags(
192 /* [in] */ long lNoNotifyFlags
) = 0;
194 virtual HRESULT __stdcall
GetNotifyFlags(
195 /* [out] */ long __RPC_FAR
*lplNoNotifyFlags
) = 0;
199 MIDL_INTERFACE("56A868B2-0AD4-11CE-B03A-0020AF0BA770")
200 IMediaPosition
: public IDispatch
203 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Duration(
204 /* [retval][out] */ double __RPC_FAR
*plength
) = 0;
206 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_CurrentPosition(
207 /* [in] */ double pllTime
) = 0;
209 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_CurrentPosition(
210 /* [retval][out] */ double __RPC_FAR
*pllTime
) = 0;
212 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_StopTime(
213 /* [retval][out] */ double __RPC_FAR
*pllTime
) = 0;
215 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_StopTime(
216 /* [in] */ double pllTime
) = 0;
218 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_PrerollTime(
219 /* [retval][out] */ double __RPC_FAR
*pllTime
) = 0;
221 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_PrerollTime(
222 /* [in] */ double pllTime
) = 0;
224 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Rate(
225 /* [in] */ double pdRate
) = 0;
227 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Rate(
228 /* [retval][out] */ double __RPC_FAR
*pdRate
) = 0;
230 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
CanSeekForward(
231 /* [retval][out] */ long __RPC_FAR
*pCanSeekForward
) = 0;
233 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
CanSeekBackward(
234 /* [retval][out] */ long __RPC_FAR
*pCanSeekBackward
) = 0;
238 MIDL_INTERFACE("56A868B3-0AD4-11CE-B03A-0020AF0BA770")
239 IBasicAudio
: public IDispatch
242 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Volume(
243 /* [in] */ long plVolume
) = 0;
245 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Volume(
246 /* [retval][out] */ long __RPC_FAR
*plVolume
) = 0;
248 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Balance(
249 /* [in] */ long plBalance
) = 0;
251 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Balance(
252 /* [retval][out] */ long __RPC_FAR
*plBalance
) = 0;
256 MIDL_INTERFACE("56A868B4-0AD4-11CE-B03A-0020AF0BA770")
257 IVideoWindow
: public IDispatch
260 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Caption(
261 /* [in] */ BSTR strCaption
) = 0;
263 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Caption(
264 /* [retval][out] */ BSTR __RPC_FAR
*strCaption
) = 0;
266 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_WindowStyle(
267 /* [in] */ long WindowStyle
) = 0;
269 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_WindowStyle(
270 /* [retval][out] */ long __RPC_FAR
*WindowStyle
) = 0;
272 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_WindowStyleEx(
273 /* [in] */ long WindowStyleEx
) = 0;
275 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_WindowStyleEx(
276 /* [retval][out] */ long __RPC_FAR
*WindowStyleEx
) = 0;
278 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_AutoShow(
279 /* [in] */ long AutoShow
) = 0;
281 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_AutoShow(
282 /* [retval][out] */ long __RPC_FAR
*AutoShow
) = 0;
284 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_WindowState(
285 /* [in] */ long WindowState
) = 0;
287 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_WindowState(
288 /* [retval][out] */ long __RPC_FAR
*WindowState
) = 0;
290 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_BackgroundPalette(
291 /* [in] */ long pBackgroundPalette
) = 0;
293 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_BackgroundPalette(
294 /* [retval][out] */ long __RPC_FAR
*pBackgroundPalette
) = 0;
296 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Visible(
297 /* [in] */ long pVisible
) = 0;
299 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Visible(
300 /* [retval][out] */ long __RPC_FAR
*pVisible
) = 0;
302 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Left(
303 /* [in] */ long pLeft
) = 0;
305 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Left(
306 /* [retval][out] */ long __RPC_FAR
*pLeft
) = 0;
308 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Width(
309 /* [in] */ long pWidth
) = 0;
311 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Width(
312 /* [retval][out] */ long __RPC_FAR
*pWidth
) = 0;
314 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Top(
315 /* [in] */ long pTop
) = 0;
317 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Top(
318 /* [retval][out] */ long __RPC_FAR
*pTop
) = 0;
320 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Height(
321 /* [in] */ long pHeight
) = 0;
323 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Height(
324 /* [retval][out] */ long __RPC_FAR
*pHeight
) = 0;
326 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Owner(
327 /* [in] */ LONG_PTR Owner
) = 0;
329 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Owner(
330 /* [retval][out] */ LONG_PTR __RPC_FAR
*Owner
) = 0;
332 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_MessageDrain(
333 /* [in] */ LONG_PTR Drain
) = 0;
335 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_MessageDrain(
336 /* [retval][out] */ LONG_PTR __RPC_FAR
*Drain
) = 0;
338 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_BorderColor(
339 /* [retval][out] */ long __RPC_FAR
*Color
) = 0;
341 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_BorderColor(
342 /* [in] */ long Color
) = 0;
344 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_FullScreenMode(
345 /* [retval][out] */ long __RPC_FAR
*FullScreenMode
) = 0;
347 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_FullScreenMode(
348 /* [in] */ long FullScreenMode
) = 0;
350 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetWindowForeground(
351 /* [in] */ long Focus
) = 0;
353 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
NotifyOwnerMessage(
354 /* [in] */ LONG_PTR hwnd
,
355 /* [in] */ long uMsg
,
356 /* [in] */ LONG_PTR wParam
,
357 /* [in] */ LONG_PTR lParam
) = 0;
359 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetWindowPosition(
360 /* [in] */ long Left
,
362 /* [in] */ long Width
,
363 /* [in] */ long Height
) = 0;
365 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetWindowPosition(
366 /* [out] */ long __RPC_FAR
*pLeft
,
367 /* [out] */ long __RPC_FAR
*pTop
,
368 /* [out] */ long __RPC_FAR
*pWidth
,
369 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
371 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetMinIdealImageSize(
372 /* [out] */ long __RPC_FAR
*pWidth
,
373 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
375 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetMaxIdealImageSize(
376 /* [out] */ long __RPC_FAR
*pWidth
,
377 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
379 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetRestorePosition(
380 /* [out] */ long __RPC_FAR
*pLeft
,
381 /* [out] */ long __RPC_FAR
*pTop
,
382 /* [out] */ long __RPC_FAR
*pWidth
,
383 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
385 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
HideCursor(
386 /* [in] */ long HideCursor
) = 0;
388 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
IsCursorHidden(
389 /* [out] */ long __RPC_FAR
*CursorHidden
) = 0;
393 MIDL_INTERFACE("56A868B5-0AD4-11CE-B03A-0020AF0BA770")
394 IBasicVideo
: public IDispatch
397 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_AvgTimePerFrame(
398 /* [retval][out] */ double __RPC_FAR
*pAvgTimePerFrame
) = 0;
400 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_BitRate(
401 /* [retval][out] */ long __RPC_FAR
*pBitRate
) = 0;
403 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_BitErrorRate(
404 /* [retval][out] */ long __RPC_FAR
*pBitErrorRate
) = 0;
406 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_VideoWidth(
407 /* [retval][out] */ long __RPC_FAR
*pVideoWidth
) = 0;
409 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_VideoHeight(
410 /* [retval][out] */ long __RPC_FAR
*pVideoHeight
) = 0;
412 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_SourceLeft(
413 /* [in] */ long pSourceLeft
) = 0;
415 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_SourceLeft(
416 /* [retval][out] */ long __RPC_FAR
*pSourceLeft
) = 0;
418 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_SourceWidth(
419 /* [in] */ long pSourceWidth
) = 0;
421 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_SourceWidth(
422 /* [retval][out] */ long __RPC_FAR
*pSourceWidth
) = 0;
424 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_SourceTop(
425 /* [in] */ long pSourceTop
) = 0;
427 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_SourceTop(
428 /* [retval][out] */ long __RPC_FAR
*pSourceTop
) = 0;
430 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_SourceHeight(
431 /* [in] */ long pSourceHeight
) = 0;
433 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_SourceHeight(
434 /* [retval][out] */ long __RPC_FAR
*pSourceHeight
) = 0;
436 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_DestinationLeft(
437 /* [in] */ long pDestinationLeft
) = 0;
439 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_DestinationLeft(
440 /* [retval][out] */ long __RPC_FAR
*pDestinationLeft
) = 0;
442 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_DestinationWidth(
443 /* [in] */ long pDestinationWidth
) = 0;
445 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_DestinationWidth(
446 /* [retval][out] */ long __RPC_FAR
*pDestinationWidth
) = 0;
448 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_DestinationTop(
449 /* [in] */ long pDestinationTop
) = 0;
451 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_DestinationTop(
452 /* [retval][out] */ long __RPC_FAR
*pDestinationTop
) = 0;
454 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_DestinationHeight(
455 /* [in] */ long pDestinationHeight
) = 0;
457 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_DestinationHeight(
458 /* [retval][out] */ long __RPC_FAR
*pDestinationHeight
) = 0;
460 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetSourcePosition(
461 /* [in] */ long Left
,
463 /* [in] */ long Width
,
464 /* [in] */ long Height
) = 0;
466 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetSourcePosition(
467 /* [out] */ long __RPC_FAR
*pLeft
,
468 /* [out] */ long __RPC_FAR
*pTop
,
469 /* [out] */ long __RPC_FAR
*pWidth
,
470 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
472 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetDefaultSourcePosition( void) = 0;
474 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetDestinationPosition(
475 /* [in] */ long Left
,
477 /* [in] */ long Width
,
478 /* [in] */ long Height
) = 0;
480 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetDestinationPosition(
481 /* [out] */ long __RPC_FAR
*pLeft
,
482 /* [out] */ long __RPC_FAR
*pTop
,
483 /* [out] */ long __RPC_FAR
*pWidth
,
484 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
486 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
SetDefaultDestinationPosition( void) = 0;
488 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetVideoSize(
489 /* [out] */ long __RPC_FAR
*pWidth
,
490 /* [out] */ long __RPC_FAR
*pHeight
) = 0;
492 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetVideoPaletteEntries(
493 /* [in] */ long StartIndex
,
494 /* [in] */ long Entries
,
495 /* [out] */ long __RPC_FAR
*pRetrieved
,
496 /* [out] */ long __RPC_FAR
*pPalette
) = 0;
498 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetCurrentImage(
499 /* [out][in] */ long __RPC_FAR
*pBufferSize
,
500 /* [out] */ long __RPC_FAR
*pDIBImage
) = 0;
502 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
IsUsingDefaultSource( void) = 0;
504 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
IsUsingDefaultDestination( void) = 0;
508 MIDL_INTERFACE("329BB360-F6EA-11D1-9038-00A0C9697298")
509 IBasicVideo2
: public IBasicVideo
512 virtual HRESULT __stdcall
GetPreferredAspectRatio(
513 /* [out] */ long __RPC_FAR
*plAspectX
,
514 /* [out] */ long __RPC_FAR
*plAspectY
) = 0;
518 MIDL_INTERFACE("56A868B8-0AD4-11CE-B03A-0020AF0BA770")
519 IDeferredCommand
: public IUnknown
522 virtual HRESULT __stdcall
Cancel( void) = 0;
524 virtual HRESULT __stdcall
Confidence(
525 /* [out] */ long __RPC_FAR
*pConfidence
) = 0;
527 virtual HRESULT __stdcall
Postpone(
528 /* [in] */ double newtime
) = 0;
530 virtual HRESULT __stdcall
GetHResult(
531 /* [out] */ HRESULT __RPC_FAR
*phrResult
) = 0;
535 MIDL_INTERFACE("56A868B7-0AD4-11CE-B03A-0020AF0BA770")
536 IQueueCommand
: public IUnknown
539 virtual HRESULT __stdcall
InvokeAtStreamTime(
540 /* [out] */ IDeferredCommand __RPC_FAR
*__RPC_FAR
*pCmd
,
541 /* [in] */ double time
,
542 /* [in] */ GUID __RPC_FAR
*iid
,
543 /* [in] */ long dispidMethod
,
544 /* [in] */ short wFlags
,
545 /* [in] */ long cArgs
,
546 /* [in] */ VARIANT __RPC_FAR
*pDispParams
,
547 /* [out][in] */ VARIANT __RPC_FAR
*pvarResult
,
548 /* [out] */ short __RPC_FAR
*puArgErr
) = 0;
550 virtual HRESULT __stdcall
InvokeAtPresentationTime(
551 /* [out] */ IDeferredCommand __RPC_FAR
*__RPC_FAR
*pCmd
,
552 /* [in] */ double time
,
553 /* [in] */ GUID __RPC_FAR
*iid
,
554 /* [in] */ long dispidMethod
,
555 /* [in] */ short wFlags
,
556 /* [in] */ long cArgs
,
557 /* [in] */ VARIANT __RPC_FAR
*pDispParams
,
558 /* [out][in] */ VARIANT __RPC_FAR
*pvarResult
,
559 /* [out] */ short __RPC_FAR
*puArgErr
) = 0;
563 MIDL_INTERFACE("56A868BA-0AD4-11CE-B03A-0020AF0BA770")
564 IFilterInfo
: public IDispatch
567 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
FindPin(
568 /* [in] */ BSTR strPinID
,
569 /* [out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
571 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Name(
572 /* [retval][out] */ BSTR __RPC_FAR
*strName
) = 0;
574 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_VendorInfo(
575 /* [retval][out] */ BSTR __RPC_FAR
*strVendorInfo
) = 0;
577 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Filter(
578 /* [retval][out] */ IUnknown __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
580 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Pins(
581 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
583 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_IsFileSource(
584 /* [retval][out] */ long __RPC_FAR
*pbIsSource
) = 0;
586 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Filename(
587 /* [retval][out] */ BSTR __RPC_FAR
*pstrFilename
) = 0;
589 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE
put_Filename(
590 /* [in] */ BSTR pstrFilename
) = 0;
594 MIDL_INTERFACE("56A868BB-0AD4-11CE-B03A-0020AF0BA770")
595 IRegFilterInfo
: public IDispatch
598 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Name(
599 /* [retval][out] */ BSTR __RPC_FAR
*strName
) = 0;
601 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Filter(
602 /* [out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
606 MIDL_INTERFACE("56A868BC-0AD4-11CE-B03A-0020AF0BA770")
607 IMediaTypeInfo
: public IDispatch
610 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Type(
611 /* [retval][out] */ BSTR __RPC_FAR
*strType
) = 0;
613 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Subtype(
614 /* [retval][out] */ BSTR __RPC_FAR
*strType
) = 0;
618 MIDL_INTERFACE("56A868BD-0AD4-11CE-B03A-0020AF0BA770")
619 IPinInfo
: public IDispatch
622 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Pin(
623 /* [retval][out] */ IUnknown __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
625 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_ConnectedTo(
626 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
628 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_ConnectionMediaType(
629 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
631 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_FilterInfo(
632 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
634 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Name(
635 /* [retval][out] */ BSTR __RPC_FAR
*ppUnk
) = 0;
637 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Direction(
638 /* [retval][out] */ long __RPC_FAR
*ppDirection
) = 0;
640 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_PinID(
641 /* [retval][out] */ BSTR __RPC_FAR
*strPinID
) = 0;
643 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_MediaTypes(
644 /* [retval][out] */ IDispatch __RPC_FAR
*__RPC_FAR
*ppUnk
) = 0;
646 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Connect(
647 /* [in] */ IUnknown __RPC_FAR
*pPin
) = 0;
649 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
ConnectDirect(
650 /* [in] */ IUnknown __RPC_FAR
*pPin
) = 0;
652 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
ConnectWithType(
653 /* [in] */ IUnknown __RPC_FAR
*pPin
,
654 /* [in] */ IDispatch __RPC_FAR
*pMediaType
) = 0;
656 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Disconnect( void) = 0;
658 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Render( void) = 0;
662 MIDL_INTERFACE("BC9BCF80-DCD2-11D2-ABF6-00A0C905F375")
663 IAMStats
: public IDispatch
666 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
Reset( void) = 0;
668 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE
get_Count(
669 /* [retval][out] */ long __RPC_FAR
*plCount
) = 0;
671 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetValueByIndex(
672 /* [in] */ long lIndex
,
673 /* [out] */ BSTR __RPC_FAR
*szName
,
674 /* [out] */ long __RPC_FAR
*lCount
,
675 /* [out] */ double __RPC_FAR
*dLast
,
676 /* [out] */ double __RPC_FAR
*dAverage
,
677 /* [out] */ double __RPC_FAR
*dStdDev
,
678 /* [out] */ double __RPC_FAR
*dMin
,
679 /* [out] */ double __RPC_FAR
*dMax
) = 0;
681 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetValueByName(
682 /* [in] */ BSTR szName
,
683 /* [out] */ long __RPC_FAR
*lIndex
,
684 /* [out] */ long __RPC_FAR
*lCount
,
685 /* [out] */ double __RPC_FAR
*dLast
,
686 /* [out] */ double __RPC_FAR
*dAverage
,
687 /* [out] */ double __RPC_FAR
*dStdDev
,
688 /* [out] */ double __RPC_FAR
*dMin
,
689 /* [out] */ double __RPC_FAR
*dMax
) = 0;
691 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
GetIndex(
692 /* [in] */ BSTR szName
,
693 /* [in] */ long lCreate
,
694 /* [out] */ long __RPC_FAR
*plIndex
) = 0;
696 virtual /* [id] */ HRESULT STDMETHODCALLTYPE
AddValue(
697 /* [in] */ long lIndex
,
698 /* [in] */ double dValue
) = 0;
702 //------------------------------------------------------------------
703 // wxAMMediaBackend (Active Movie)
704 //------------------------------------------------------------------
705 class WXDLLIMPEXP_MEDIA wxAMMediaBackend
: public wxMediaBackend
710 virtual ~wxAMMediaBackend();
712 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
717 const wxValidator
& validator
,
718 const wxString
& name
);
721 virtual bool Pause();
724 virtual bool Load(const wxString
& fileName
);
725 virtual bool Load(const wxURI
& location
);
727 virtual wxMediaState
GetState();
729 virtual bool SetPosition(wxLongLong where
);
730 virtual wxLongLong
GetPosition();
731 virtual wxLongLong
GetDuration();
733 virtual void Move(int x
, int y
, int w
, int h
);
734 wxSize
GetVideoSize() const;
736 virtual double GetPlaybackRate();
737 virtual bool SetPlaybackRate(double);
743 static LRESULT CALLBACK
NotifyWndProc(HWND hWnd
, UINT nMsg
,
744 WPARAM wParam
, LPARAM lParam
);
746 LRESULT CALLBACK
OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
747 WPARAM wParam
, LPARAM lParam
);
753 IMediaControl
* m_pMC
;
754 IMediaEventEx
* m_pME
;
755 IMediaPosition
* m_pMS
;
761 DECLARE_DYNAMIC_CLASS(wxAMMediaBackend
);
764 #endif //wxUSE_DIRECTSHOW
766 //---------------------------------------------------------------------------
770 //---------------------------------------------------------------------------
772 //---------------------------------------------------------------------------
774 //---------------------------------------------------------------------------
775 #include <mmsystem.h>
777 class WXDLLIMPEXP_MEDIA wxMCIMediaBackend
: public wxMediaBackend
782 ~wxMCIMediaBackend();
784 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
789 const wxValidator
& validator
,
790 const wxString
& name
);
793 virtual bool Pause();
796 virtual bool Load(const wxString
& fileName
);
797 virtual bool Load(const wxURI
& location
);
799 virtual wxMediaState
GetState();
801 virtual bool SetPosition(wxLongLong where
);
802 virtual wxLongLong
GetPosition();
803 virtual wxLongLong
GetDuration();
805 virtual void Move(int x
, int y
, int w
, int h
);
806 wxSize
GetVideoSize() const;
808 virtual double GetPlaybackRate();
809 virtual bool SetPlaybackRate(double dRate
);
811 static LRESULT CALLBACK
NotifyWndProc(HWND hWnd
, UINT nMsg
,
812 WPARAM wParam
, LPARAM lParam
);
814 LRESULT CALLBACK
OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
815 WPARAM wParam
, LPARAM lParam
);
817 MCIDEVICEID m_hDev
; //Our MCI Device ID/Handler
818 wxControl
* m_ctrl
; //Parent control
819 HWND m_hNotifyWnd
; //Window to use for MCI events
820 bool m_bVideo
; //Whether or not we have video
822 DECLARE_DYNAMIC_CLASS(wxMCIMediaBackend
)
825 //---------------------------------------------------------------------------
829 //---------------------------------------------------------------------------
831 //---------------------------------------------------------------------------
832 // QT Compilation Guard
833 //---------------------------------------------------------------------------
836 //---------------------------------------------------------------------------
838 //---------------------------------------------------------------------------
839 #include <qtml.h> //Windoze QT include
840 #include <QuickTimeComponents.h> //Standard QT stuff
842 class WXDLLIMPEXP_MEDIA wxQTMediaBackend
: public wxMediaBackend
849 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
854 const wxValidator
& validator
,
855 const wxString
& name
);
858 virtual bool Pause();
861 virtual bool Load(const wxString
& fileName
);
862 virtual bool Load(const wxURI
& location
);
864 virtual wxMediaState
GetState();
866 virtual bool SetPosition(wxLongLong where
);
867 virtual wxLongLong
GetPosition();
868 virtual wxLongLong
GetDuration();
870 virtual void Move(int x
, int y
, int w
, int h
);
871 wxSize
GetVideoSize() const;
873 virtual double GetPlaybackRate();
874 virtual bool SetPlaybackRate(double dRate
);
879 wxSize m_bestSize
; //Original movie size
880 struct MovieRecord
* m_movie
; //QT Movie handle/instance
881 wxControl
* m_ctrl
; //Parent control
882 bool m_bVideo
; //Whether or not we have video
883 class _wxQTTimer
* m_timer
; //Timer for streaming the movie
885 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend
);
888 //---------------------------------------------------------------------------
889 // End QT Compilation Guard
890 //---------------------------------------------------------------------------
891 #endif //wxUSE_QUICKTIME
893 //===========================================================================
895 //===========================================================================
897 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
901 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
903 //---------------------------------------------------------------------------
904 // Only use if user wants it -
905 //---------------------------------------------------------------------------
908 IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend
, wxMediaBackend
);
910 // Numerical value for when the graph reaches the stop position
911 #define WM_GRAPHNOTIFY WM_USER+13
913 //---------------------------------------------------------------------------
914 // Usual debugging macros
915 //---------------------------------------------------------------------------
917 #define wxAMVERIFY(x) \
919 HRESULT hrdsv = (x); \
920 if ( FAILED(hrdsv) ) \
922 /*TCHAR szError[MAX_ERROR_TEXT_LEN];*/ \
923 /*if( AMGetErrorText(hrdsv, szError, MAX_ERROR_TEXT_LEN) == 0)*/ \
925 /*wxFAIL_MSG( wxString::Format(wxT("DirectShow error \"%s\" ")*/\
926 /*wxT("occured at line %i in ")*/ \
927 /*wxT("mediactrl.cpp"),*/ \
928 /*szError, __LINE__) );*/ \
931 wxFAIL_MSG( wxString::Format(wxT("Unknown error (%i) ") \
933 wxT(" line %i in mediactrl.cpp."), \
934 (int)hrdsv, __LINE__) ); \
937 #define wxVERIFY(x) wxASSERT((x))
939 #define wxAMVERIFY(x) (x)
940 #define wxVERIFY(x) (x)
943 //---------------------------------------------------------------------------
944 // Standard macros for ease of use
945 //---------------------------------------------------------------------------
946 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
948 //---------------------------------------------------------------------------
949 // wxAMMediaBackend Constructor
951 // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet
952 //---------------------------------------------------------------------------
953 wxAMMediaBackend::wxAMMediaBackend() : m_hNotifyWnd(NULL
)
957 //---------------------------------------------------------------------------
958 // wxAMMediaBackend Destructor
960 // Cleans up everything
961 //---------------------------------------------------------------------------
962 wxAMMediaBackend::~wxAMMediaBackend()
968 //---------------------------------------------------------------------------
969 // wxAMMediaBackend::CreateControl
971 // ActiveMovie does not really have any native control to speak of,
972 // so we just create a normal control.
974 // We also check to see if ActiveMovie is installed
975 //---------------------------------------------------------------------------
976 bool wxAMMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
981 const wxValidator
& validator
,
982 const wxString
& name
)
984 //create our filter graph - the beuty of COM is that it loads
985 //quartz.dll for us :)
986 HRESULT hr
= CoCreateInstance(CLSID_FilgraphManager
, NULL
, CLSCTX_INPROC_SERVER
,
987 IID_IMediaControl
, (void**)&m_pMC
);
989 //directshow not installed?
993 //release the filter graph - we don't need it yet
999 // By default wxWindow(s) is created with a border -
1000 // so we need to get rid of those, and create with
1001 // wxCLIP_CHILDREN, so that if the driver/backend
1002 // is a child window, it refereshes properly
1004 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
1005 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
| wxCLIP_CHILDREN
,
1014 //---------------------------------------------------------------------------
1015 // wxAMMediaBackend::Load (file version)
1017 // Creates an Active Movie filter graph from a file or url
1018 //---------------------------------------------------------------------------
1019 bool wxAMMediaBackend::Load(const wxString
& fileName
)
1021 //if previously loaded cleanup
1025 //We already checked for success in CreateControl
1026 CoCreateInstance(CLSID_FilgraphManager
, NULL
, CLSCTX_INPROC_SERVER
,
1027 IID_IMediaControl
, (void**)&m_pMC
);
1029 //load the graph & render
1030 if( FAILED(m_pMC
->RenderFile(wxBasicString(fileName
).Get())) )
1033 //get the interfaces, all of them
1034 wxAMVERIFY( m_pMC
->QueryInterface(IID_IMediaEventEx
, (void**)&m_pME
) );
1035 wxAMVERIFY( m_pMC
->QueryInterface(IID_IMediaPosition
, (void**)&m_pMS
) );
1036 wxAMVERIFY( m_pMC
->QueryInterface(IID_IVideoWindow
, (void**)&m_pVW
) );
1037 wxAMVERIFY( m_pMC
->QueryInterface(IID_IBasicAudio
, (void**)&m_pBA
) );
1038 wxAMVERIFY( m_pMC
->QueryInterface(IID_IBasicVideo
, (void**)&m_pBV
) );
1040 //We could tell if the media has audio or not by
1044 //pBA->get_Volume(&lVolume) == E_NOTIMPL
1049 //Obtain the _actual_ size of the movie & remember it
1054 m_bestSize
.x
= m_bestSize
.y
= 0;
1056 m_bVideo
= SUCCEEDED( m_pVW
->GetWindowPosition( &nX
,
1058 (long*)&m_bestSize
.x
,
1059 (long*)&m_bestSize
.y
) );
1062 //If we have video in the media - set it up so that
1063 //its a child window of the control, its visible,
1064 //and that the control is the owner of the video window
1068 wxAMVERIFY( m_pVW
->put_Owner((LONG_PTR
)m_ctrl
->GetHandle()) );
1069 wxAMVERIFY( m_pVW
->put_WindowStyle(WS_CHILD
| WS_CLIPSIBLINGS
) );
1070 wxAMVERIFY( m_pVW
->put_Visible(-1) ); //OATRUE == -1
1074 // Create a hidden window and register to handle
1075 // directshow events for this graph
1076 // Note that wxCanvasClassName is already registered
1077 // and used by all wxWindows and normal wxControls
1079 m_hNotifyWnd
= ::CreateWindow
1093 wxLogSysError( wxT("Could not create hidden needed for ")
1094 wxT("registering for DirectShow events!") );
1099 ::SetWindowLongPtr(m_hNotifyWnd
, GWLP_WNDPROC
,
1100 (LONG_PTR
)wxAMMediaBackend::NotifyWndProc
);
1102 ::SetWindowLong(m_hNotifyWnd
, GWL_USERDATA
,
1105 wxAMVERIFY( m_pME
->SetNotifyWindow((LONG_PTR
)m_hNotifyWnd
,
1106 WM_GRAPHNOTIFY
, 0) );
1109 // Force the parent window of this control to recalculate
1110 // the size of this if sizers are being used
1111 // and render the results immediately
1113 m_ctrl
->InvalidateBestSize();
1114 m_ctrl
->GetParent()->Layout();
1115 m_ctrl
->GetParent()->Refresh();
1116 m_ctrl
->GetParent()->Update();
1121 //---------------------------------------------------------------------------
1122 // wxAMMediaBackend::Load (URL Version)
1124 // Loads media from a URL. Interestingly enough DirectShow
1125 // appears (?) to escape the URL for us, at least on normal
1127 //---------------------------------------------------------------------------
1128 bool wxAMMediaBackend::Load(const wxURI
& location
)
1130 return Load(location
.BuildUnescapedURI());
1133 //---------------------------------------------------------------------------
1134 // wxAMMediaBackend::Play
1136 // Plays the stream. If it is non-seekable, it will restart it.
1137 //---------------------------------------------------------------------------
1138 bool wxAMMediaBackend::Play()
1140 return SUCCEEDED( m_pMC
->Run() );
1143 //---------------------------------------------------------------------------
1144 // wxAMMediaBackend::Pause
1146 // Pauses the stream.
1147 //---------------------------------------------------------------------------
1148 bool wxAMMediaBackend::Pause()
1150 return SUCCEEDED( m_pMC
->Pause() );
1153 //---------------------------------------------------------------------------
1154 // wxAMMediaBackend::Stop
1156 // Stops the stream.
1157 //---------------------------------------------------------------------------
1158 bool wxAMMediaBackend::Stop()
1160 bool bOK
= SUCCEEDED( m_pMC
->Stop() );
1162 //We don't care if it can't get to the beginning in directshow -
1163 //it could be a non-seeking filter (wince midi) in which case playing
1164 //starts all over again
1169 //---------------------------------------------------------------------------
1170 // wxAMMediaBackend::SetPosition
1172 // 1) Translates the current position's time to directshow time,
1173 // which is in a scale of 1 second (in a double)
1174 // 2) Sets the play position of the IMediaSeeking interface -
1175 // passing NULL as the stop position means to keep the old
1177 //---------------------------------------------------------------------------
1178 bool wxAMMediaBackend::SetPosition(wxLongLong where
)
1180 return SUCCEEDED( m_pMS
->put_CurrentPosition(
1181 ((LONGLONG
)where
.GetValue()) / 1000
1186 //---------------------------------------------------------------------------
1187 // wxAMMediaBackend::GetPosition
1189 // 1) Obtains the current play and stop positions from IMediaSeeking
1190 // 2) Returns the play position translated to our time base
1191 //---------------------------------------------------------------------------
1192 wxLongLong
wxAMMediaBackend::GetPosition()
1195 wxAMVERIFY( m_pMS
->get_CurrentPosition(&outCur
) );
1197 //h,m,s,milli - outdur is in 1 second (double)
1198 return (outCur
*1000);
1201 //---------------------------------------------------------------------------
1202 // wxAMMediaBackend::GetDuration
1204 // 1) Obtains the duration of the media from the IMediaSeeking interface
1205 // 2) Converts that value to our time base, and returns it
1206 //---------------------------------------------------------------------------
1207 wxLongLong
wxAMMediaBackend::GetDuration()
1210 wxAMVERIFY( m_pMS
->get_Duration(&outDuration
) );
1212 //h,m,s,milli - outdur is in 1 second (double)
1213 return (outDuration
*1000);
1216 //---------------------------------------------------------------------------
1217 // wxAMMediaBackend::GetState
1219 // Obtains the state from the IMediaControl interface.
1220 // Note that it's enumeration values for stopping/playing
1221 // etc. are the same as ours, so we just do a straight cast.
1222 // TODO: MS recommends against INFINITE here for
1223 // IMediaControl::GetState- do it in stages
1224 //---------------------------------------------------------------------------
1225 wxMediaState
wxAMMediaBackend::GetState()
1228 long theState
; //OAFilterState
1229 hr
= m_pMC
->GetState(INFINITE
, &theState
);
1231 wxASSERT( SUCCEEDED(hr
) );
1233 //MSW state is the same as ours
1234 //State_Stopped = 0,
1235 //State_Paused = State_Stopped + 1,
1236 //State_Running = State_Paused + 1
1238 return (wxMediaState
) theState
;
1241 //---------------------------------------------------------------------------
1242 // wxAMMediaBackend::GetPlaybackRate
1244 // Pretty simple way of obtaining the playback rate from
1245 // the IMediaSeeking interface
1246 //---------------------------------------------------------------------------
1247 double wxAMMediaBackend::GetPlaybackRate()
1250 wxAMVERIFY( m_pMS
->get_Rate(&dRate
) );
1254 //---------------------------------------------------------------------------
1255 // wxAMMediaBackend::SetPlaybackRate
1257 // Sets the playback rate of the media - DirectShow is pretty good
1258 // about this, actually
1259 //---------------------------------------------------------------------------
1260 bool wxAMMediaBackend::SetPlaybackRate(double dRate
)
1262 return SUCCEEDED( m_pMS
->put_Rate(dRate
) );
1265 //---------------------------------------------------------------------------
1266 // wxAMMediaBackend::NotifyWndProc
1268 // Here we check to see if DirectShow tells us we've reached the stop
1269 // position in our stream - if it has, it may not actually stop
1270 // the stream - which we need to do...
1271 //---------------------------------------------------------------------------
1272 LRESULT CALLBACK
wxAMMediaBackend::NotifyWndProc(HWND hWnd
, UINT nMsg
,
1276 wxAMMediaBackend
* backend
= (wxAMMediaBackend
*)
1277 ::GetWindowLong(hWnd
, GWL_USERDATA
);
1279 return backend
->OnNotifyWndProc(hWnd
, nMsg
, wParam
, lParam
);
1282 LRESULT CALLBACK
wxAMMediaBackend::OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
1286 if (nMsg
== WM_GRAPHNOTIFY
)
1293 // DirectShow keeps a list of queued events, and we need
1294 // to go through them one by one, stopping at (Hopefully only one)
1295 // EC_COMPLETE message
1297 while(SUCCEEDED(m_pME
->GetEvent(&evCode
, (LONG_PTR
*) &evParam1
,
1298 (LONG_PTR
*) &evParam2
, 0)
1302 // Cleanup memory that GetEvent allocated
1303 wxAMVERIFY( m_pME
->FreeEventParams(evCode
, evParam1
, evParam2
) );
1305 // If this is the end of the clip, notify handler
1306 if(1 == evCode
) //EC_COMPLETE
1308 //send the event to our child
1309 wxMediaEvent
theEvent(wxEVT_MEDIA_STOP
, m_ctrl
->GetId());
1310 m_ctrl
->ProcessEvent(theEvent
);
1312 //if the user didn't veto it, stop the stream
1313 if (theEvent
.IsAllowed())
1315 //Interestingly enough, DirectShow does not actually stop
1316 //the filters - even when it reaches the end!
1319 //send the event to our child
1320 wxMediaEvent
theEvent(wxEVT_MEDIA_FINISHED
,
1322 m_ctrl
->ProcessEvent(theEvent
);
1327 return DefWindowProc(hWnd
, nMsg
, wParam
, lParam
);
1330 //---------------------------------------------------------------------------
1331 // wxAMMediaBackend::Cleanup
1333 // 1) Hide/disowns the video window (MS says bad things will happen if
1335 // 2) Releases all the directshow interfaces we use
1336 // TODO: Maybe there's a way to redirect the IMediaControl each time
1337 // we load, rather then creating and destroying the interfaces
1339 //---------------------------------------------------------------------------
1340 void wxAMMediaBackend::Cleanup()
1342 // Hide then disown the window
1345 m_pVW
->put_Visible(0); //OSFALSE == 0
1346 m_pVW
->put_Owner(NULL
);
1349 // Release and zero DirectShow interfaces
1350 SAFE_RELEASE(m_pME
);
1351 SAFE_RELEASE(m_pMS
);
1352 SAFE_RELEASE(m_pBA
);
1353 SAFE_RELEASE(m_pBV
);
1354 SAFE_RELEASE(m_pVW
);
1355 SAFE_RELEASE(m_pMC
);
1357 // Get rid of our hidden Window
1358 DestroyWindow(m_hNotifyWnd
);
1359 m_hNotifyWnd
= NULL
;
1363 //---------------------------------------------------------------------------
1364 // wxAMMediaBackend::GetVideoSize
1366 // Obtains the cached original video size
1367 //---------------------------------------------------------------------------
1368 wxSize
wxAMMediaBackend::GetVideoSize() const
1373 //---------------------------------------------------------------------------
1374 // wxAMMediaBackend::Move
1376 // Resizes the IVideoWindow to the size of the control window
1377 //---------------------------------------------------------------------------
1378 void wxAMMediaBackend::Move(int WXUNUSED(x
), int WXUNUSED(y
), int w
, int h
)
1380 if(m_hNotifyWnd
&& m_bVideo
)
1382 wxAMVERIFY( m_pVW
->SetWindowPosition(0, 0, w
, h
) );
1386 //---------------------------------------------------------------------------
1387 // End of wxAMMediaBackend
1388 //---------------------------------------------------------------------------
1389 #endif //wxUSE_DIRECTSHOW
1391 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1393 // wxMCIMediaBackend
1395 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1398 IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend
, wxMediaBackend
);
1400 //---------------------------------------------------------------------------
1401 // Usual debugging macros for MCI returns
1402 //---------------------------------------------------------------------------
1405 #define wxMCIVERIFY(arg) \
1408 if ( (nRet = (arg)) != 0) \
1411 mciGetErrorString(nRet, sz, 5000); \
1412 wxFAIL_MSG(wxString::Format(_T("MCI Error:%s"), sz)); \
1416 #define wxMCIVERIFY(arg) (arg);
1419 //---------------------------------------------------------------------------
1420 // Simulation for <digitalv.h>
1422 // Mingw and possibly other compilers don't have the digitalv.h header
1423 // that is needed to have some essential features of mci work with
1424 // windows - so we provide the declarations for the types we use here
1425 //---------------------------------------------------------------------------
1428 DWORD_PTR dwCallback
;
1429 #ifdef MCI_USE_OFFEXT
1435 } MCI_DGV_RECT_PARMS
;
1438 DWORD_PTR dwCallback
;
1448 } MCI_DGV_WINDOW_PARMS
;
1451 DWORD_PTR dwCallback
;
1456 } MCI_DGV_SET_PARMS
;
1458 //---------------------------------------------------------------------------
1459 // wxMCIMediaBackend Constructor
1461 // Here we don't need to do much except say we don't have any video :)
1462 //---------------------------------------------------------------------------
1463 wxMCIMediaBackend::wxMCIMediaBackend() : m_hNotifyWnd(NULL
), m_bVideo(false)
1467 //---------------------------------------------------------------------------
1468 // wxMCIMediaBackend Destructor
1470 // We close the mci device - note that there may not be an mci device here,
1471 // or it may fail - but we don't really care, since we're destructing
1472 //---------------------------------------------------------------------------
1473 wxMCIMediaBackend::~wxMCIMediaBackend()
1477 mciSendCommand(m_hDev
, MCI_CLOSE
, 0, 0);
1478 DestroyWindow(m_hNotifyWnd
);
1479 m_hNotifyWnd
= NULL
;
1483 //---------------------------------------------------------------------------
1484 // wxMCIMediaBackend::Create
1486 // Here we just tell wxMediaCtrl that mci does exist (which it does, on all
1487 // msw systems, at least in some form dating back to win16 days)
1488 //---------------------------------------------------------------------------
1489 bool wxMCIMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
1494 const wxValidator
& validator
,
1495 const wxString
& name
)
1499 // By default wxWindow(s) is created with a border -
1500 // so we need to get rid of those, and create with
1501 // wxCLIP_CHILDREN, so that if the driver/backend
1502 // is a child window, it refereshes properly
1504 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
1505 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
| wxCLIP_CHILDREN
,
1513 //---------------------------------------------------------------------------
1514 // wxMCIMediaBackend::Load (file version)
1516 // Here we have MCI load a file and device, set the time format to our
1517 // default (milliseconds), and set the video (if any) to play in the control
1518 //---------------------------------------------------------------------------
1519 bool wxMCIMediaBackend::Load(const wxString
& fileName
)
1522 //if the user already called load close the previous MCI device
1526 mciSendCommand(m_hDev
, MCI_CLOSE
, 0, 0);
1527 DestroyWindow(m_hNotifyWnd
);
1528 m_hNotifyWnd
= NULL
;
1532 //Opens a file and has MCI select a device. Normally you'd put
1533 //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you
1534 //omit this it tells MCI to select the device instead. This is
1535 //good because we have no reliable way of "enumerating" the devices
1538 MCI_OPEN_PARMS openParms
;
1539 openParms
.lpstrElementName
= (wxChar
*) fileName
.c_str();
1541 if ( mciSendCommand(0, MCI_OPEN
, MCI_OPEN_ELEMENT
,
1542 (DWORD
)(LPVOID
)&openParms
) != 0)
1545 m_hDev
= openParms
.wDeviceID
;
1548 //Now set the time format for the device to milliseconds
1550 MCI_SET_PARMS setParms
;
1551 setParms
.dwCallback
= 0;
1552 setParms
.dwTimeFormat
= MCI_FORMAT_MILLISECONDS
;
1554 if (mciSendCommand(m_hDev
, MCI_SET
, MCI_SET_TIME_FORMAT
,
1555 (DWORD
)(LPVOID
)&setParms
) != 0)
1559 //Now tell the MCI device to display the video in our wxMediaCtrl
1561 MCI_DGV_WINDOW_PARMS windowParms
;
1562 windowParms
.hWnd
= (HWND
)m_ctrl
->GetHandle();
1564 m_bVideo
= (mciSendCommand(m_hDev
, MCI_WINDOW
,
1565 0x00010000L
, //MCI_DGV_WINDOW_HWND
1566 (DWORD
)(LPVOID
)&windowParms
) == 0);
1569 // Create a hidden window and register to handle
1571 // Note that wxCanvasClassName is already registered
1572 // and used by all wxWindows and normal wxControls
1574 m_hNotifyWnd
= ::CreateWindow
1588 wxLogSysError( wxT("Could not create hidden needed for ")
1589 wxT("registering for DirectShow events!") );
1594 ::SetWindowLong(m_hNotifyWnd
, GWL_WNDPROC
,
1595 (LONG
)wxMCIMediaBackend::NotifyWndProc
);
1597 ::SetWindowLong(m_hNotifyWnd
, GWL_USERDATA
,
1600 m_ctrl
->Show(false);
1603 //Here, if the parent of the control has a sizer - we
1604 //tell it to recalculate the size of this control since
1605 //the user opened a seperate media file
1607 m_ctrl
->InvalidateBestSize();
1608 m_ctrl
->GetParent()->Layout();
1609 m_ctrl
->GetParent()->Refresh();
1610 m_ctrl
->GetParent()->Update();
1615 //---------------------------------------------------------------------------
1616 // wxMCIMediaBackend::Load (URL version)
1618 // MCI doesn't support URLs directly (?)
1620 // TODO: Use wxURL/wxFileSystem and mmioInstallProc
1621 //---------------------------------------------------------------------------
1622 bool wxMCIMediaBackend::Load(const wxURI
& WXUNUSED(location
))
1627 //---------------------------------------------------------------------------
1628 // wxMCIMediaBackend::Play
1630 // Plays/Resumes the MCI device... a couple notes:
1631 // 1) Certain drivers will crash and burn if we don't pass them an
1632 // MCI_PLAY_PARMS, despite the documentation that says otherwise...
1633 // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing
1634 // and will resume from a stopped state also, so there's no need to
1635 // call both, for example
1636 //---------------------------------------------------------------------------
1637 bool wxMCIMediaBackend::Play()
1639 MCI_PLAY_PARMS playParms
;
1640 playParms
.dwCallback
= (DWORD
)m_hNotifyWnd
;
1642 bool bOK
= ( mciSendCommand(m_hDev
, MCI_PLAY
, MCI_NOTIFY
,
1643 (DWORD
)(LPVOID
)&playParms
) == 0 );
1646 m_ctrl
->Show(m_bVideo
);
1651 //---------------------------------------------------------------------------
1652 // wxMCIMediaBackend::Pause
1654 // Pauses the MCI device - nothing special
1655 //---------------------------------------------------------------------------
1656 bool wxMCIMediaBackend::Pause()
1658 return (mciSendCommand(m_hDev
, MCI_PAUSE
, MCI_WAIT
, 0) == 0);
1661 //---------------------------------------------------------------------------
1662 // wxMCIMediaBackend::Stop
1664 // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline
1665 //---------------------------------------------------------------------------
1666 bool wxMCIMediaBackend::Stop()
1668 return (mciSendCommand(m_hDev
, MCI_STOP
, MCI_WAIT
, 0) == 0) &&
1669 (mciSendCommand(m_hDev
, MCI_SEEK
, MCI_SEEK_TO_START
, 0) == 0);
1672 //---------------------------------------------------------------------------
1673 // wxMCIMediaBackend::GetState
1675 // Here we get the state and convert it to a wxMediaState -
1676 // since we use direct comparisons with MCI_MODE_PLAY and
1677 // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call
1679 //---------------------------------------------------------------------------
1680 wxMediaState
wxMCIMediaBackend::GetState()
1682 MCI_STATUS_PARMS statusParms
;
1683 statusParms
.dwItem
= MCI_STATUS_MODE
;
1685 mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
1686 (DWORD
)(LPVOID
)&statusParms
);
1688 if(statusParms
.dwReturn
== MCI_MODE_PAUSE
)
1689 return wxMEDIASTATE_PAUSED
;
1690 else if(statusParms
.dwReturn
== MCI_MODE_PLAY
)
1691 return wxMEDIASTATE_PLAYING
;
1693 return wxMEDIASTATE_STOPPED
;
1696 //---------------------------------------------------------------------------
1697 // wxMCIMediaBackend::SetPosition
1699 // Here we set the position of the device in the stream.
1700 // Note that MCI actually stops the device after you seek it if the
1701 // device is playing/paused, so we need to play the file after
1702 // MCI seeks like normal APIs would
1703 //---------------------------------------------------------------------------
1704 bool wxMCIMediaBackend::SetPosition(wxLongLong where
)
1706 MCI_SEEK_PARMS seekParms
;
1707 seekParms
.dwCallback
= 0;
1708 #if wxUSE_LONGLONG_NATIVE && !wxUSE_LONGLONG_WX
1709 seekParms
.dwTo
= (DWORD
)where
.GetValue();
1710 #else /* wxUSE_LONGLONG_WX */
1711 /* no way to return it in one piece */
1712 wxASSERT( where
.GetHi()==0 );
1713 seekParms
.dwTo
= (DWORD
)where
.GetLo();
1714 #endif /* wxUSE_LONGLONG_* */
1716 //device was playing?
1717 bool bReplay
= GetState() == wxMEDIASTATE_PLAYING
;
1719 if( mciSendCommand(m_hDev
, MCI_SEEK
, MCI_TO
,
1720 (DWORD
)(LPVOID
)&seekParms
) != 0)
1723 //If the device was playing, resume it
1730 //---------------------------------------------------------------------------
1731 // wxMCIMediaBackend::GetPosition
1733 // Gets the position of the device in the stream using the current
1734 // time format... nothing special here...
1735 //---------------------------------------------------------------------------
1736 wxLongLong
wxMCIMediaBackend::GetPosition()
1738 MCI_STATUS_PARMS statusParms
;
1739 statusParms
.dwItem
= MCI_STATUS_POSITION
;
1741 if (mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
1742 (DWORD
)(LPSTR
)&statusParms
) != 0)
1745 return statusParms
.dwReturn
;
1748 //---------------------------------------------------------------------------
1749 // wxMCIMediaBackend::GetDuration
1751 // Gets the duration of the stream... nothing special
1752 //---------------------------------------------------------------------------
1753 wxLongLong
wxMCIMediaBackend::GetDuration()
1755 MCI_STATUS_PARMS statusParms
;
1756 statusParms
.dwItem
= MCI_STATUS_LENGTH
;
1758 if (mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
1759 (DWORD
)(LPSTR
)&statusParms
) != 0)
1762 return statusParms
.dwReturn
;
1765 //---------------------------------------------------------------------------
1766 // wxMCIMediaBackend::Move
1768 // Moves the window to a location
1769 //---------------------------------------------------------------------------
1770 void wxMCIMediaBackend::Move(int WXUNUSED(x
), int WXUNUSED(y
),
1773 if (m_hNotifyWnd
&& m_bVideo
)
1775 MCI_DGV_RECT_PARMS putParms
; //ifdefed MCI_DGV_PUT_PARMS
1776 putParms
.rc
.top
= 0;
1777 putParms
.rc
.bottom
= 0;
1778 putParms
.rc
.right
= w
;
1779 putParms
.rc
.bottom
= h
;
1781 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_PUT
,
1782 0x00040000L
, //MCI_DGV_PUT_DESTINATION
1783 (DWORD
)(LPSTR
)&putParms
) );
1787 //---------------------------------------------------------------------------
1788 // wxMCIMediaBackend::GetVideoSize
1790 // Gets the original size of the movie for sizers
1791 //---------------------------------------------------------------------------
1792 wxSize
wxMCIMediaBackend::GetVideoSize() const
1796 MCI_DGV_RECT_PARMS whereParms
; //ifdefed MCI_DGV_WHERE_PARMS
1798 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_WHERE
,
1799 0x00020000L
, //MCI_DGV_WHERE_SOURCE
1800 (DWORD
)(LPSTR
)&whereParms
) );
1802 return wxSize(whereParms
.rc
.right
, whereParms
.rc
.bottom
);
1807 //---------------------------------------------------------------------------
1808 // wxMCIMediaBackend::GetPlaybackRate
1811 //---------------------------------------------------------------------------
1812 double wxMCIMediaBackend::GetPlaybackRate()
1817 //---------------------------------------------------------------------------
1818 // wxMCIMediaBackend::SetPlaybackRate
1821 //---------------------------------------------------------------------------
1822 bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate
))
1825 MCI_WAVE_SET_SAMPLESPERSEC
1826 MCI_DGV_SET_PARMS setParms;
1827 setParms.dwSpeed = (DWORD) (dRate * 1000.0);
1829 return (mciSendCommand(m_hDev, MCI_SET,
1830 0x00020000L, //MCI_DGV_SET_SPEED
1831 (DWORD)(LPSTR)&setParms) == 0);
1836 //---------------------------------------------------------------------------
1837 // [static] wxMCIMediaBackend::MSWWindowProc
1839 // Here we process a message when MCI reaches the stopping point
1841 //---------------------------------------------------------------------------
1842 LRESULT CALLBACK
wxMCIMediaBackend::NotifyWndProc(HWND hWnd
, UINT nMsg
,
1846 wxMCIMediaBackend
* backend
= (wxMCIMediaBackend
*)
1847 ::GetWindowLong(hWnd
, GWL_USERDATA
);
1850 return backend
->OnNotifyWndProc(hWnd
, nMsg
, wParam
, lParam
);
1853 LRESULT CALLBACK
wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
1857 if(nMsg
== MM_MCINOTIFY
)
1859 wxASSERT(lParam
== (LPARAM
) m_hDev
);
1860 if(wParam
== MCI_NOTIFY_SUCCESSFUL
&& lParam
== (LPARAM
)m_hDev
)
1862 wxMediaEvent
theEvent(wxEVT_MEDIA_STOP
, m_ctrl
->GetId());
1863 m_ctrl
->ProcessEvent(theEvent
);
1865 if(theEvent
.IsAllowed())
1867 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_SEEK
,
1868 MCI_SEEK_TO_START
, 0) );
1870 //send the event to our child
1871 wxMediaEvent
theEvent(wxEVT_MEDIA_FINISHED
,
1873 m_ctrl
->ProcessEvent(theEvent
);
1877 return DefWindowProc(hWnd
, nMsg
, wParam
, lParam
);
1879 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1883 // TODO: Use a less cludgy way to pause/get state/set state
1884 // TODO: Dynamically load from qtml.dll
1885 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1889 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend
, wxMediaBackend
);
1891 //Time between timer calls
1892 #define MOVIE_DELAY 100
1894 #include "wx/timer.h"
1896 // --------------------------------------------------------------------------
1897 // wxQTTimer - Handle Asyncronous Playing
1898 // --------------------------------------------------------------------------
1899 class _wxQTTimer
: public wxTimer
1902 _wxQTTimer(Movie movie
, wxQTMediaBackend
* parent
) :
1903 m_movie(movie
), m_bPaused(false), m_parent(parent
)
1911 bool GetPaused() {return m_bPaused
;}
1912 void SetPaused(bool bPaused
) {m_bPaused
= bPaused
;}
1914 //-----------------------------------------------------------------------
1915 // _wxQTTimer::Notify
1917 // 1) Checks to see if the movie is done, and if not continues
1918 // streaming the movie
1919 // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
1921 //-----------------------------------------------------------------------
1926 if(!IsMovieDone(m_movie
))
1927 MoviesTask(m_movie
, MOVIE_DELAY
);
1930 wxMediaEvent
theEvent(wxEVT_MEDIA_STOP
,
1931 m_parent
->m_ctrl
->GetId());
1932 m_parent
->m_ctrl
->ProcessEvent(theEvent
);
1934 if(theEvent
.IsAllowed())
1938 wxASSERT(::GetMoviesError() == noErr
);
1940 //send the event to our child
1941 wxMediaEvent
theEvent(wxEVT_MEDIA_FINISHED
,
1942 m_parent
->m_ctrl
->GetId());
1943 m_parent
->m_ctrl
->ProcessEvent(theEvent
);
1950 Movie m_movie
; //Our movie instance
1951 bool m_bPaused
; //Whether we are paused or not
1952 wxQTMediaBackend
* m_parent
; //Backend pointer
1955 //---------------------------------------------------------------------------
1956 // wxQTMediaBackend Destructor
1958 // Sets m_timer to NULL signifying we havn't loaded anything yet
1959 //---------------------------------------------------------------------------
1960 wxQTMediaBackend::wxQTMediaBackend() : m_timer(NULL
)
1964 //---------------------------------------------------------------------------
1965 // wxQTMediaBackend Destructor
1967 // 1) Cleans up the QuickTime movie instance
1968 // 2) Decrements the QuickTime reference counter - if this reaches
1969 // 0, QuickTime shuts down
1970 // 3) Decrements the QuickTime Windows Media Layer reference counter -
1971 // if this reaches 0, QuickTime shuts down the Windows Media Layer
1972 //---------------------------------------------------------------------------
1973 wxQTMediaBackend::~wxQTMediaBackend()
1978 //Note that ExitMovies() is not neccessary, but
1979 //the docs are fuzzy on whether or not TerminateQTML is
1984 //---------------------------------------------------------------------------
1985 // wxQTMediaBackend::CreateControl
1987 // 1) Intializes QuickTime
1988 // 2) Creates the control window
1989 //---------------------------------------------------------------------------
1990 bool wxQTMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
1995 const wxValidator
& validator
,
1996 const wxString
& name
)
1999 if ((nError
= InitializeQTML(0)) != noErr
) //-2093 no dll
2001 wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError
));
2008 // By default wxWindow(s) is created with a border -
2009 // so we need to get rid of those
2011 // Since we don't have a child window like most other
2012 // backends, we don't need wxCLIP_CHILDREN
2014 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
2015 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
,
2023 //---------------------------------------------------------------------------
2024 // wxQTMediaBackend::Load (file version)
2026 // 1) Get an FSSpec from the Windows path name
2027 // 2) Open the movie
2028 // 3) Obtain the movie instance from the movie resource
2030 //---------------------------------------------------------------------------
2031 bool wxQTMediaBackend::Load(const wxString
& fileName
)
2040 if (NativePathNameToFSSpec ((char*) (const char*) fileName
.mb_str(),
2041 &sfFile
, 0) != noErr
)
2044 if (OpenMovieFile (&sfFile
, &movieResFile
, fsRdPerm
) != noErr
)
2047 short movieResID
= 0;
2050 err
= NewMovieFromFile (
2058 CloseMovieFile (movieResFile
);
2065 return ::GetMoviesError() == noErr
;
2068 //---------------------------------------------------------------------------
2069 // wxQTMediaBackend::Move
2072 //---------------------------------------------------------------------------
2073 bool wxQTMediaBackend::Load(const wxURI
& location
)
2078 wxString theURI
= location
.BuildURI();
2082 Handle theHandle
= NewHandleClear(theURI
.length() + 1);
2083 wxASSERT(theHandle
);
2085 BlockMove(theURI
.mb_str(), *theHandle
, theURI
.length() + 1);
2087 //create the movie from the handle that refers to the URI
2088 err
= NewMovieFromDataRef(&m_movie
, newMovieActive
,
2090 URLDataHandlerSubType
);
2092 DisposeHandle(theHandle
);
2097 //preroll movie for streaming
2101 timeNow
= GetMovieTime(m_movie
, NULL
);
2102 playRate
= GetMoviePreferredRate(m_movie
);
2103 PrePrerollMovie(m_movie
, timeNow
, playRate
, NULL
, NULL
);
2104 PrerollMovie(m_movie
, timeNow
, playRate
);
2105 SetMovieRate(m_movie
, playRate
);
2109 return ::GetMoviesError() == noErr
;
2112 //---------------------------------------------------------------------------
2113 // wxQTMediaBackend::Move
2116 //---------------------------------------------------------------------------
2117 void wxQTMediaBackend::FinishLoad()
2119 m_timer
= new _wxQTTimer(m_movie
, (wxQTMediaBackend
*) this);
2122 //get the real size of the movie
2124 ::GetMovieNaturalBoundsRect (m_movie
, &outRect
);
2125 wxASSERT(::GetMoviesError() == noErr
);
2127 m_bestSize
.x
= outRect
.right
- outRect
.left
;
2128 m_bestSize
.y
= outRect
.bottom
- outRect
.top
;
2130 //reparent movie/*AudioMediaCharacteristic*/
2131 if(GetMovieIndTrackType(m_movie
, 1,
2132 VisualMediaCharacteristic
,
2133 movieTrackCharacteristic
|
2134 movieTrackEnabledOnly
) != NULL
)
2136 CreatePortAssociation(m_ctrl
->GetHWND(), NULL
, 0L);
2138 SetMovieGWorld(m_movie
,
2139 (CGrafPtr
) GetNativeWindowPort(m_ctrl
->GetHWND()),
2143 //we want millisecond precision
2144 ::SetMovieTimeScale(m_movie
, 1000);
2145 wxASSERT(::GetMoviesError() == noErr
);
2148 //Here, if the parent of the control has a sizer - we
2149 //tell it to recalculate the size of this control since
2150 //the user opened a seperate media file
2152 m_ctrl
->InvalidateBestSize();
2153 m_ctrl
->GetParent()->Layout();
2154 m_ctrl
->GetParent()->Refresh();
2155 m_ctrl
->GetParent()->Update();
2158 //---------------------------------------------------------------------------
2159 // wxQTMediaBackend::Move
2162 //---------------------------------------------------------------------------
2163 bool wxQTMediaBackend::Play()
2165 ::StartMovie(m_movie
);
2166 m_timer
->SetPaused(false);
2167 m_timer
->Start(MOVIE_DELAY
, wxTIMER_CONTINUOUS
);
2168 return ::GetMoviesError() == noErr
;
2171 //---------------------------------------------------------------------------
2172 // wxQTMediaBackend::Move
2175 //---------------------------------------------------------------------------
2176 bool wxQTMediaBackend::Pause()
2178 ::StopMovie(m_movie
);
2179 m_timer
->SetPaused(true);
2181 return ::GetMoviesError() == noErr
;
2184 //---------------------------------------------------------------------------
2185 // wxQTMediaBackend::Move
2188 //---------------------------------------------------------------------------
2189 bool wxQTMediaBackend::Stop()
2191 m_timer
->SetPaused(false);
2194 ::StopMovie(m_movie
);
2195 if(::GetMoviesError() != noErr
)
2198 ::GoToBeginningOfMovie(m_movie
);
2199 return ::GetMoviesError() == noErr
;
2202 //---------------------------------------------------------------------------
2203 // wxQTMediaBackend::Move
2206 //---------------------------------------------------------------------------
2207 double wxQTMediaBackend::GetPlaybackRate()
2209 return ( ((double)::GetMovieRate(m_movie
)) / 0x10000);
2212 //---------------------------------------------------------------------------
2213 // wxQTMediaBackend::Move
2216 //---------------------------------------------------------------------------
2217 bool wxQTMediaBackend::SetPlaybackRate(double dRate
)
2219 ::SetMovieRate(m_movie
, (Fixed
) (dRate
* 0x10000));
2220 return ::GetMoviesError() == noErr
;
2223 //---------------------------------------------------------------------------
2224 // wxQTMediaBackend::Move
2227 //---------------------------------------------------------------------------
2228 bool wxQTMediaBackend::SetPosition(wxLongLong where
)
2230 TimeRecord theTimeRecord
;
2231 memset(&theTimeRecord
, 0, sizeof(TimeRecord
));
2232 theTimeRecord
.value
.lo
= where
.GetValue();
2233 theTimeRecord
.scale
= ::GetMovieTimeScale(m_movie
);
2234 theTimeRecord
.base
= ::GetMovieTimeBase(m_movie
);
2235 ::SetMovieTime(m_movie
, &theTimeRecord
);
2237 if (::GetMoviesError() != noErr
)
2243 //---------------------------------------------------------------------------
2244 // wxQTMediaBackend::GetPosition
2246 // 1) Calls GetMovieTime to get the position we are in in the movie
2247 // in milliseconds (we called
2248 //---------------------------------------------------------------------------
2249 wxLongLong
wxQTMediaBackend::GetPosition()
2251 return ::GetMovieTime(m_movie
, NULL
);
2254 //---------------------------------------------------------------------------
2255 // wxQTMediaBackend::Move
2258 //---------------------------------------------------------------------------
2259 wxLongLong
wxQTMediaBackend::GetDuration()
2261 return ::GetMovieDuration(m_movie
);
2264 //---------------------------------------------------------------------------
2265 // wxQTMediaBackend::Move
2268 //---------------------------------------------------------------------------
2269 wxMediaState
wxQTMediaBackend::GetState()
2271 if ( !m_timer
|| (m_timer
->IsRunning() == false &&
2272 m_timer
->GetPaused() == false) )
2273 return wxMEDIASTATE_STOPPED
;
2275 if( m_timer
->IsRunning() == true )
2276 return wxMEDIASTATE_PLAYING
;
2278 return wxMEDIASTATE_PAUSED
;
2281 //---------------------------------------------------------------------------
2282 // wxQTMediaBackend::Move
2285 //---------------------------------------------------------------------------
2286 void wxQTMediaBackend::Cleanup()
2292 DisposeMovie(m_movie
);
2295 //---------------------------------------------------------------------------
2296 // wxQTMediaBackend::Move
2299 //---------------------------------------------------------------------------
2300 wxSize
wxQTMediaBackend::GetVideoSize() const
2305 //---------------------------------------------------------------------------
2306 // wxQTMediaBackend::Move
2309 //---------------------------------------------------------------------------
2310 void wxQTMediaBackend::Move(int x
, int y
, int w
, int h
)
2314 Rect theRect
= {0, 0, h
, w
};
2316 ::SetMovieBox(m_movie
, &theRect
);
2317 wxASSERT(::GetMoviesError() == noErr
);
2321 //---------------------------------------------------------------------------
2322 // End QT Compilation Guard
2323 //---------------------------------------------------------------------------
2324 #endif //wxUSE_QUICKTIME
2326 //in source file that contains stuff you don't directly use
2327 #include <wx/html/forcelnk.h>
2328 FORCE_LINK_ME(basewxmediabackends
);
2330 //---------------------------------------------------------------------------
2331 // End wxMediaCtrl Compilation Guard and this file
2332 //---------------------------------------------------------------------------
2333 #endif //wxUSE_MEDIACTRL