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 /////////////////////////////////////////////////////////////////////////////
14 - extract different backends in different files (better yet, make backends
15 dynamically loadable...), they have nothing to do with each other and
16 this file is huge and also separate the standard contents from our code
20 //===========================================================================
22 //===========================================================================
24 //---------------------------------------------------------------------------
25 // Pre-compiled header stuff
26 //---------------------------------------------------------------------------
28 // For compilers that support precompilation, includes "wx.h".
29 #include "wx/wxprec.h"
35 //---------------------------------------------------------------------------
37 //---------------------------------------------------------------------------
38 #include "wx/mediactrl.h"
40 //---------------------------------------------------------------------------
42 //---------------------------------------------------------------------------
45 //---------------------------------------------------------------------------
47 //---------------------------------------------------------------------------
48 #include "wx/log.h" //wxLogDebug
49 #include "wx/math.h" //log10 & pow
50 #include "wx/msw/private.h" //user info and wndproc setting/getting
51 #include "wx/dcclient.h"
53 #include "wx/dynlib.h"
55 //---------------------------------------------------------------------------
56 // Externals (somewhere in src/msw/app.cpp and src/msw/window.cpp)
57 //---------------------------------------------------------------------------
58 extern "C" WXDLLIMPEXP_BASE HINSTANCE
wxGetInstance(void);
60 extern WXDLLIMPEXP_CORE wxChar
*wxCanvasClassName
;
62 extern WXDLLIMPEXP_CORE
const wxChar
*wxCanvasClassName
;
65 LRESULT WXDLLIMPEXP_CORE APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
66 WPARAM wParam
, LPARAM lParam
);
68 //===========================================================================
69 // BACKEND DECLARATIONS
70 //===========================================================================
72 //---------------------------------------------------------------------------
76 //---------------------------------------------------------------------------
78 //---------------------------------------------------------------------------
79 // wxActiveXContainer - includes all the COM-specific stuff we need
80 //---------------------------------------------------------------------------
81 #include "wx/msw/ole/activex.h"
83 //---------------------------------------------------------------------------
84 // IIDS - used by CoCreateInstance and IUnknown::QueryInterface
86 // [idl name] [idl decription]
87 // amcompat.idl Microsoft Active Movie Control (Ver 2.0)
88 // nscompat.idl Microsoft NetShow Player (Ver 1.0)
89 // msdxm.idl Windows Media Player (Ver 1.0)
92 // First, when I say I "from XXX.idl", I mean I go into the COM Browser
93 // ($Microsoft Visual Studio$/Common/Tools/OLEVIEW.EXE), open
94 // "type libraries", open a specific type library (for quartz for example its
95 // "ActiveMovie control type library (V1.0)"), save it as an .idl, compile the
96 // idl using the midl compiler that comes with visual studio
97 // ($Microsoft Visual Studio$/VC98/bin/midl.exe on VC6) with the /h argument
98 // to make it generate stubs (a .h & .c file), then clean up the generated
99 // interfaces I want with the STDMETHOD wrappers and then put them into
102 // According to the MSDN docs, IMediaPlayer requires Windows 98 SE
103 // or greater. NetShow is available on Windows 3.1 and I'm guessing
104 // IActiveMovie is too. IMediaPlayer is essentially the Windows Media
107 // Some of these are not used but are kept here for future reference anyway
108 //---------------------------------------------------------------------------
109 const IID IID_IActiveMovie
= {0x05589FA2,0xC356,0x11CE,{0xBF,0x01,0x00,0xAA,0x00,0x55,0x59,0x5A}};
110 const IID IID_IActiveMovie2
= {0xB6CD6554,0xE9CB,0x11D0,{0x82,0x1F,0x00,0xA0,0xC9,0x1F,0x9C,0xA0}};
111 const IID IID_IActiveMovie3
= {0x265EC140,0xAE62,0x11D1,{0x85,0x00,0x00,0xA0,0xC9,0x1F,0x9C,0xA0}};
113 const IID IID_INSOPlay
= {0x2179C5D1,0xEBFF,0x11CF,{0xB6,0xFD,0x00,0xAA,0x00,0xB4,0xE2,0x20}};
114 const IID IID_INSPlay
= {0xE7C4BE80,0x7960,0x11D0,{0xB7,0x27,0x00,0xAA,0x00,0xB4,0xE2,0x20}};
115 const IID IID_INSPlay1
= {0x265EC141,0xAE62,0x11D1,{0x85,0x00,0x00,0xA0,0xC9,0x1F,0x9C,0xA0}};
117 const IID IID_IMediaPlayer
= {0x22D6F311,0xB0F6,0x11D0,{0x94,0xAB,0x00,0x80,0xC7,0x4C,0x7E,0x95}};
118 const IID IID_IMediaPlayer2
= {0x20D4F5E0,0x5475,0x11D2,{0x97,0x74,0x00,0x00,0xF8,0x08,0x55,0xE6}};
120 const CLSID CLSID_ActiveMovie
= {0x05589FA1,0xC356,0x11CE,{0xBF,0x01,0x00,0xAA,0x00,0x55,0x59,0x5A}};
121 const CLSID CLSID_MediaPlayer
= {0x22D6F312,0xB0F6,0x11D0,{0x94,0xAB,0x00,0x80,0xC7,0x4C,0x7E,0x95}};
122 const CLSID CLSID_NSPlay
= {0x2179C5D3,0xEBFF,0x11CF,{0xB6,0xFD,0x00,0xAA,0x00,0xB4,0xE2,0x20}};
124 const IID IID_IAMOpenProgress
= {0x8E1C39A1, 0xDE53, 0x11CF,{0xAA, 0x63, 0x00, 0x80, 0xC7, 0x44, 0x52, 0x8D}};
127 const CLSID CLSID_FilgraphManager
= {0xE436EBB3,0x524F,0x11CE,{0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
128 const IID IID_IMediaEvent
= {0x56A868B6,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
131 const CLSID CLSID_VideoMixingRenderer9
={0x51B4ABF3, 0x748F, 0x4E3B,{0xA2, 0x76, 0xC8, 0x28, 0x33, 0x0E, 0x92, 0x6A}};
132 const IID IID_IVMRWindowlessControl9
= {0x8F537D09, 0xF85E, 0x4414,{0xB2, 0x3B, 0x50, 0x2E, 0x54, 0xC7, 0x99, 0x27}};
133 const IID IID_IFilterGraph
= {0x56A8689F, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
134 const IID IID_IGraphBuilder
= {0x56A868A9, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
135 const IID IID_IVMRFilterConfig9
= {0x5A804648, 0x4F66, 0x4867,{0x9C, 0x43, 0x4F, 0x5C, 0x82, 0x2C, 0xF1, 0xB8}};
136 const IID IID_IBaseFilter
= {0x56A86895, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
138 //---------------------------------------------------------------------------
139 // QUARTZ COM INTERFACES (dumped from quartz.idl from MSVC COM Browser)
140 //---------------------------------------------------------------------------
142 struct IAMOpenProgress
: public IUnknown
144 STDMETHOD(QueryProgress
)(LONGLONG
*pllTotal
, LONGLONG
*pllCurrent
) PURE
;
145 STDMETHOD(AbortOperation
)(void) PURE
;
148 struct IMediaEvent
: public IDispatch
150 STDMETHOD(GetEventHandle
)(LONG_PTR
*) PURE
;
151 STDMETHOD(GetEvent
)(long *, LONG_PTR
*, LONG_PTR
*, long) PURE
;
152 STDMETHOD(WaitForCompletion
)(long, long *) PURE
;
153 STDMETHOD(CancelDefaultHandling
)(long) PURE
;
154 STDMETHOD(RestoreDefaultHandling
)(long) PURE
;
155 STDMETHOD(FreeEventParams
)(long, LONG_PTR
, LONG_PTR
) PURE
;
158 //---------------------------------------------------------------------------
159 // ACTIVEMOVIE COM INTERFACES (dumped from amcompat.idl from MSVC COM Browser)
160 //---------------------------------------------------------------------------
162 enum ReadyStateConstants
164 amvUninitialized
= 0,
178 enum DisplayModeConstants
184 enum WindowSizeConstants
187 amvDoubleOriginalSize
= 1,
188 amvOneSixteenthScreen
= 2,
189 amvOneFourthScreen
= 3,
193 enum AppearanceConstants
199 enum BorderStyleConstants
205 struct IActiveMovie
: public IDispatch
207 STDMETHOD(AboutBox
)( void) PURE
;
208 STDMETHOD(Run
)( void) PURE
;
209 STDMETHOD(Pause
)( void) PURE
;
210 STDMETHOD(Stop
)( void) PURE
;
211 STDMETHOD(get_ImageSourceWidth
)(long __RPC_FAR
*pWidth
) PURE
;
212 STDMETHOD(get_ImageSourceHeight
)(long __RPC_FAR
*pHeight
) PURE
;
213 STDMETHOD(get_Author
)(BSTR __RPC_FAR
*pbstrAuthor
) PURE
;
214 STDMETHOD(get_Title
)(BSTR __RPC_FAR
*pbstrTitle
) PURE
;
215 STDMETHOD(get_Copyright
)(BSTR __RPC_FAR
*pbstrCopyright
) PURE
;
216 STDMETHOD(get_Description
)(BSTR __RPC_FAR
*pbstrDescription
) PURE
;
217 STDMETHOD(get_Rating
)(BSTR __RPC_FAR
*pbstrRating
) PURE
;
218 STDMETHOD(get_FileName
)(BSTR __RPC_FAR
*pbstrFileName
) PURE
;
219 STDMETHOD(put_FileName
)(BSTR pbstrFileName
) PURE
;
220 STDMETHOD(get_Duration
)(double __RPC_FAR
*pValue
) PURE
;
221 STDMETHOD(get_CurrentPosition
)(double __RPC_FAR
*pValue
) PURE
;
222 STDMETHOD(put_CurrentPosition
)(double pValue
) PURE
;
223 STDMETHOD(get_PlayCount
)(long __RPC_FAR
*pPlayCount
) PURE
;
224 STDMETHOD(put_PlayCount
)(long pPlayCount
) PURE
;
225 STDMETHOD(get_SelectionStart
)(double __RPC_FAR
*pValue
) PURE
;
226 STDMETHOD(put_SelectionStart
)(double pValue
) PURE
;
227 STDMETHOD(get_SelectionEnd
)(double __RPC_FAR
*pValue
) PURE
;
228 STDMETHOD(put_SelectionEnd
)(double pValue
) PURE
;
229 STDMETHOD(get_CurrentState
)(StateConstants __RPC_FAR
*pState
) PURE
;
230 STDMETHOD(get_Rate
)(double __RPC_FAR
*pValue
) PURE
;
231 STDMETHOD(put_Rate
)(double pValue
) PURE
;
232 STDMETHOD(get_Volume
)(long __RPC_FAR
*pValue
) PURE
;
233 STDMETHOD(put_Volume
)(long pValue
) PURE
;
234 STDMETHOD(get_Balance
)(long __RPC_FAR
*pValue
) PURE
;
235 STDMETHOD(put_Balance
)(long pValue
) PURE
;
236 STDMETHOD(get_EnableContextMenu
)(VARIANT_BOOL __RPC_FAR
*pEnable
) PURE
;
237 STDMETHOD(put_EnableContextMenu
)(VARIANT_BOOL pEnable
) PURE
;
238 STDMETHOD(get_ShowDisplay
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
239 STDMETHOD(put_ShowDisplay
)(VARIANT_BOOL Show
) PURE
;
240 STDMETHOD(get_ShowControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
241 STDMETHOD(put_ShowControls
)(VARIANT_BOOL Show
) PURE
;
242 STDMETHOD(get_ShowPositionControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
243 STDMETHOD(put_ShowPositionControls
)(VARIANT_BOOL Show
) PURE
;
244 STDMETHOD(get_ShowSelectionControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
245 STDMETHOD(put_ShowSelectionControls
)(VARIANT_BOOL Show
) PURE
;
246 STDMETHOD(get_ShowTracker
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
247 STDMETHOD(put_ShowTracker
)(VARIANT_BOOL Show
) PURE
;
248 STDMETHOD(get_EnablePositionControls
)(VARIANT_BOOL __RPC_FAR
*Enable
) PURE
;
249 STDMETHOD(put_EnablePositionControls
)(VARIANT_BOOL Enable
) PURE
;
250 STDMETHOD(get_EnableSelectionControls
)(VARIANT_BOOL __RPC_FAR
*Enable
) PURE
;
251 STDMETHOD(put_EnableSelectionControls
)(VARIANT_BOOL Enable
) PURE
;
252 STDMETHOD(get_EnableTracker
)(VARIANT_BOOL __RPC_FAR
*Enable
) PURE
;
253 STDMETHOD(put_EnableTracker
)(VARIANT_BOOL Enable
) PURE
;
254 STDMETHOD(get_AllowHideDisplay
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
255 STDMETHOD(put_AllowHideDisplay
)(VARIANT_BOOL Show
) PURE
;
256 STDMETHOD(get_AllowHideControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
257 STDMETHOD(put_AllowHideControls
)(VARIANT_BOOL Show
) PURE
;
258 STDMETHOD(get_DisplayMode
)(DisplayModeConstants __RPC_FAR
*pValue
) PURE
;
259 STDMETHOD(put_DisplayMode
)(DisplayModeConstants pValue
) PURE
;
260 STDMETHOD(get_AllowChangeDisplayMode
)(VARIANT_BOOL __RPC_FAR
*fAllow
) PURE
;
261 STDMETHOD(put_AllowChangeDisplayMode
)(VARIANT_BOOL fAllow
) PURE
;
262 STDMETHOD(get_FilterGraph
)(IUnknown __RPC_FAR
*__RPC_FAR
*ppFilterGraph
) PURE
;
263 STDMETHOD(put_FilterGraph
)(IUnknown __RPC_FAR
*ppFilterGraph
) PURE
;
264 STDMETHOD(get_FilterGraphDispatch
)(IDispatch __RPC_FAR
*__RPC_FAR
*pDispatch
) PURE
;
265 STDMETHOD(get_DisplayForeColor
)(unsigned long __RPC_FAR
*ForeColor
) PURE
;
266 STDMETHOD(put_DisplayForeColor
)(unsigned long ForeColor
) PURE
;
267 STDMETHOD(get_DisplayBackColor
)(unsigned long __RPC_FAR
*BackColor
) PURE
;
268 STDMETHOD(put_DisplayBackColor
)(unsigned long BackColor
) PURE
;
269 STDMETHOD(get_MovieWindowSize
)(WindowSizeConstants __RPC_FAR
*WindowSize
) PURE
;
270 STDMETHOD(put_MovieWindowSize
)(WindowSizeConstants WindowSize
) PURE
;
271 STDMETHOD(get_FullScreenMode
)(VARIANT_BOOL __RPC_FAR
*pEnable
) PURE
;
272 STDMETHOD(put_FullScreenMode
)(VARIANT_BOOL pEnable
) PURE
;
273 STDMETHOD(get_AutoStart
)(VARIANT_BOOL __RPC_FAR
*pEnable
) PURE
;
274 STDMETHOD(put_AutoStart
)(VARIANT_BOOL pEnable
) PURE
;
275 STDMETHOD(get_AutoRewind
)(VARIANT_BOOL __RPC_FAR
*pEnable
) PURE
;
276 STDMETHOD(put_AutoRewind
)(VARIANT_BOOL pEnable
) PURE
;
277 STDMETHOD(get_hWnd
)(long __RPC_FAR
*hWnd
) PURE
;
278 STDMETHOD(get_Appearance
)(AppearanceConstants __RPC_FAR
*pAppearance
) PURE
;
279 STDMETHOD(put_Appearance
)(AppearanceConstants pAppearance
) PURE
;
280 STDMETHOD(get_BorderStyle
)(BorderStyleConstants __RPC_FAR
*pBorderStyle
) PURE
;
281 STDMETHOD(put_BorderStyle
)(BorderStyleConstants pBorderStyle
) PURE
;
282 STDMETHOD(get_Enabled
)(VARIANT_BOOL __RPC_FAR
*pEnabled
) PURE
;
283 STDMETHOD(put_Enabled
)(VARIANT_BOOL pEnabled
) PURE
;
284 STDMETHOD(get_Info
)(long __RPC_FAR
*ppInfo
) PURE
;
289 struct IActiveMovie2
: public IActiveMovie
291 STDMETHOD(IsSoundCardEnabled
)(VARIANT_BOOL __RPC_FAR
*pbSoundCard
) PURE
;
292 STDMETHOD(get_ReadyState
)(ReadyStateConstants __RPC_FAR
*pValue
) PURE
;
295 struct IActiveMovie3
: public IActiveMovie2
297 STDMETHOD(get_MediaPlayer
)(IDispatch __RPC_FAR
*__RPC_FAR
*ppDispatch
) PURE
;
301 //---------------------------------------------------------------------------
302 // MEDIAPLAYER COM INTERFACES (dumped from msdxm.idl from MSVC COM Browser)
303 //---------------------------------------------------------------------------
305 enum MPPlayStateConstants
316 enum MPDisplaySizeConstants
323 mpOneSixteenthScreen
= 5,
324 mpOneFourthScreen
= 6,
328 enum MPReadyStateConstants
330 mpReadyStateUninitialized
= 0,
331 mpReadyStateLoading
= 1,
332 mpReadyStateInteractive
= 3,
333 mpReadyStateComplete
= 4
336 typedef unsigned long VB_OLE_COLOR
;
338 enum MPDisplayModeConstants
358 mpShowDescription
= 5,
363 mpClipCopyright
= 10,
365 mpClipDescription
= 12,
368 mpBannerMoreInfo
= 15,
372 enum DVDMenuIDConstants
376 dvdMenu_Subpicture
= 4,
382 enum MPShowDialogConstants
384 mpShowDialogHelp
= 0,
385 mpShowDialogStatistics
= 1,
386 mpShowDialogOptions
= 2,
387 mpShowDialogContextMenu
= 3
391 struct IMediaPlayer
: public IDispatch
393 STDMETHOD(get_CurrentPosition
)(double __RPC_FAR
*pCurrentPosition
) PURE
;
394 STDMETHOD(put_CurrentPosition
)(double pCurrentPosition
) PURE
;
395 STDMETHOD(get_Duration
)(double __RPC_FAR
*pDuration
) PURE
;
396 STDMETHOD(get_ImageSourceWidth
)(long __RPC_FAR
*pWidth
) PURE
;
397 STDMETHOD(get_ImageSourceHeight
)(long __RPC_FAR
*pHeight
) PURE
;
398 STDMETHOD(get_MarkerCount
)(long __RPC_FAR
*pMarkerCount
) PURE
;
399 STDMETHOD(get_CanScan
)(VARIANT_BOOL __RPC_FAR
*pCanScan
) PURE
;
400 STDMETHOD(get_CanSeek
)(VARIANT_BOOL __RPC_FAR
*pCanSeek
) PURE
;
401 STDMETHOD(get_CanSeekToMarkers
)(VARIANT_BOOL __RPC_FAR
*pCanSeekToMarkers
) PURE
;
402 STDMETHOD(get_CurrentMarker
)(long __RPC_FAR
*pCurrentMarker
) PURE
;
403 STDMETHOD(put_CurrentMarker
)(long pCurrentMarker
) PURE
;
404 STDMETHOD(get_FileName
)(BSTR __RPC_FAR
*pbstrFileName
) PURE
;
405 STDMETHOD(put_FileName
)(BSTR pbstrFileName
) PURE
;
406 STDMETHOD(get_SourceLink
)(BSTR __RPC_FAR
*pbstrSourceLink
) PURE
;
407 STDMETHOD(get_CreationDate
)(DATE __RPC_FAR
*pCreationDate
) PURE
;
408 STDMETHOD(get_ErrorCorrection
)(BSTR __RPC_FAR
*pbstrErrorCorrection
) PURE
;
409 STDMETHOD(get_Bandwidth
)(long __RPC_FAR
*pBandwidth
) PURE
;
410 STDMETHOD(get_SourceProtocol
)(long __RPC_FAR
*pSourceProtocol
) PURE
;
411 STDMETHOD(get_ReceivedPackets
)(long __RPC_FAR
*pReceivedPackets
) PURE
;
412 STDMETHOD(get_RecoveredPackets
)(long __RPC_FAR
*pRecoveredPackets
) PURE
;
413 STDMETHOD(get_LostPackets
)(long __RPC_FAR
*pLostPackets
) PURE
;
414 STDMETHOD(get_ReceptionQuality
)(long __RPC_FAR
*pReceptionQuality
) PURE
;
415 STDMETHOD(get_BufferingCount
)(long __RPC_FAR
*pBufferingCount
) PURE
;
416 STDMETHOD(get_IsBroadcast
)(VARIANT_BOOL __RPC_FAR
*pIsBroadcast
) PURE
;
417 STDMETHOD(get_BufferingProgress
)(long __RPC_FAR
*pBufferingProgress
) PURE
;
418 STDMETHOD(get_ChannelName
)(BSTR __RPC_FAR
*pbstrChannelName
) PURE
;
419 STDMETHOD(get_ChannelDescription
)(BSTR __RPC_FAR
*pbstrChannelDescription
) PURE
;
420 STDMETHOD(get_ChannelURL
)(BSTR __RPC_FAR
*pbstrChannelURL
) PURE
;
421 STDMETHOD(get_ContactAddress
)(BSTR __RPC_FAR
*pbstrContactAddress
) PURE
;
422 STDMETHOD(get_ContactPhone
)(BSTR __RPC_FAR
*pbstrContactPhone
) PURE
;
423 STDMETHOD(get_ContactEmail
)(BSTR __RPC_FAR
*pbstrContactEmail
) PURE
;
424 STDMETHOD(get_BufferingTime
)(double __RPC_FAR
*pBufferingTime
) PURE
;
425 STDMETHOD(put_BufferingTime
)(double pBufferingTime
) PURE
;
426 STDMETHOD(get_AutoStart
)(VARIANT_BOOL __RPC_FAR
*pAutoStart
) PURE
;
427 STDMETHOD(put_AutoStart
)(VARIANT_BOOL pAutoStart
) PURE
;
428 STDMETHOD(get_AutoRewind
)(VARIANT_BOOL __RPC_FAR
*pAutoRewind
) PURE
;
429 STDMETHOD(put_AutoRewind
)(VARIANT_BOOL pAutoRewind
) PURE
;
430 STDMETHOD(get_Rate
)(double __RPC_FAR
*pRate
) PURE
;
431 STDMETHOD(put_Rate
)(double pRate
) PURE
;
432 STDMETHOD(get_SendKeyboardEvents
)(VARIANT_BOOL __RPC_FAR
*pSendKeyboardEvents
) PURE
;
433 STDMETHOD(put_SendKeyboardEvents
)(VARIANT_BOOL pSendKeyboardEvents
) PURE
;
434 STDMETHOD(get_SendMouseClickEvents
)(VARIANT_BOOL __RPC_FAR
*pSendMouseClickEvents
) PURE
;
435 STDMETHOD(put_SendMouseClickEvents
)(VARIANT_BOOL pSendMouseClickEvents
) PURE
;
436 STDMETHOD(get_SendMouseMoveEvents
)(VARIANT_BOOL __RPC_FAR
*pSendMouseMoveEvents
) PURE
;
437 STDMETHOD(put_SendMouseMoveEvents
)(VARIANT_BOOL pSendMouseMoveEvents
) PURE
;
438 STDMETHOD(get_PlayCount
)(long __RPC_FAR
*pPlayCount
) PURE
;
439 STDMETHOD(put_PlayCount
)(long pPlayCount
) PURE
;
440 STDMETHOD(get_ClickToPlay
)(VARIANT_BOOL __RPC_FAR
*pClickToPlay
) PURE
;
441 STDMETHOD(put_ClickToPlay
)(VARIANT_BOOL pClickToPlay
) PURE
;
442 STDMETHOD(get_AllowScan
)(VARIANT_BOOL __RPC_FAR
*pAllowScan
) PURE
;
443 STDMETHOD(put_AllowScan
)(VARIANT_BOOL pAllowScan
) PURE
;
444 STDMETHOD(get_EnableContextMenu
)(VARIANT_BOOL __RPC_FAR
*pEnableContextMenu
) PURE
;
445 STDMETHOD(put_EnableContextMenu
)(VARIANT_BOOL pEnableContextMenu
) PURE
;
446 STDMETHOD(get_CursorType
)(long __RPC_FAR
*pCursorType
) PURE
;
447 STDMETHOD(put_CursorType
)(long pCursorType
) PURE
;
448 STDMETHOD(get_CodecCount
)(long __RPC_FAR
*pCodecCount
) PURE
;
449 STDMETHOD(get_AllowChangeDisplaySize
)(VARIANT_BOOL __RPC_FAR
*pAllowChangeDisplaySize
) PURE
;
450 STDMETHOD(put_AllowChangeDisplaySize
)( VARIANT_BOOL pAllowChangeDisplaySize
) PURE
;
451 STDMETHOD(get_IsDurationValid
)(VARIANT_BOOL __RPC_FAR
*pIsDurationValid
) PURE
;
452 STDMETHOD(get_OpenState
)(long __RPC_FAR
*pOpenState
) PURE
;
453 STDMETHOD(get_SendOpenStateChangeEvents
)(VARIANT_BOOL __RPC_FAR
*pSendOpenStateChangeEvents
) PURE
;
454 STDMETHOD(put_SendOpenStateChangeEvents
)(VARIANT_BOOL pSendOpenStateChangeEvents
) PURE
;
455 STDMETHOD(get_SendWarningEvents
)( VARIANT_BOOL __RPC_FAR
*pSendWarningEvents
) PURE
;
456 STDMETHOD(put_SendWarningEvents
)(VARIANT_BOOL pSendWarningEvents
) PURE
;
457 STDMETHOD(get_SendErrorEvents
)(VARIANT_BOOL __RPC_FAR
*pSendErrorEvents
) PURE
;
458 STDMETHOD(put_SendErrorEvents
)(VARIANT_BOOL pSendErrorEvents
) PURE
;
459 STDMETHOD(get_PlayState
)(MPPlayStateConstants __RPC_FAR
*pPlayState
) PURE
;
460 STDMETHOD(get_SendPlayStateChangeEvents
)(VARIANT_BOOL __RPC_FAR
*pSendPlayStateChangeEvents
) PURE
;
461 STDMETHOD(put_SendPlayStateChangeEvents
)(VARIANT_BOOL pSendPlayStateChangeEvents
) PURE
;
462 STDMETHOD(get_DisplaySize
)(MPDisplaySizeConstants __RPC_FAR
*pDisplaySize
) PURE
;
463 STDMETHOD(put_DisplaySize
)(MPDisplaySizeConstants pDisplaySize
) PURE
;
464 STDMETHOD(get_InvokeURLs
)(VARIANT_BOOL __RPC_FAR
*pInvokeURLs
) PURE
;
465 STDMETHOD(put_InvokeURLs
)(VARIANT_BOOL pInvokeURLs
) PURE
;
466 STDMETHOD(get_BaseURL
)(BSTR __RPC_FAR
*pbstrBaseURL
) PURE
;
467 STDMETHOD(put_BaseURL
)(BSTR pbstrBaseURL
) PURE
;
468 STDMETHOD(get_DefaultFrame
)(BSTR __RPC_FAR
*pbstrDefaultFrame
) PURE
;
469 STDMETHOD(put_DefaultFrame
)(BSTR pbstrDefaultFrame
) PURE
;
470 STDMETHOD(get_HasError
)(VARIANT_BOOL __RPC_FAR
*pHasError
) PURE
;
471 STDMETHOD(get_ErrorDescription
)(BSTR __RPC_FAR
*pbstrErrorDescription
) PURE
;
472 STDMETHOD(get_ErrorCode
)(long __RPC_FAR
*pErrorCode
) PURE
;
473 STDMETHOD(get_AnimationAtStart
)(VARIANT_BOOL __RPC_FAR
*pAnimationAtStart
) PURE
;
474 STDMETHOD(put_AnimationAtStart
)(VARIANT_BOOL pAnimationAtStart
) PURE
;
475 STDMETHOD(get_TransparentAtStart
)( VARIANT_BOOL __RPC_FAR
*pTransparentAtStart
) PURE
;
476 STDMETHOD(put_TransparentAtStart
)(VARIANT_BOOL pTransparentAtStart
) PURE
;
477 STDMETHOD(get_Volume
)(long __RPC_FAR
*pVolume
) PURE
;
478 STDMETHOD(put_Volume
)(long pVolume
) PURE
;
479 STDMETHOD(get_Balance
)(long __RPC_FAR
*pBalance
) PURE
;
480 STDMETHOD(put_Balance
)(long pBalance
) PURE
;
481 STDMETHOD(get_ReadyState
)(MPReadyStateConstants __RPC_FAR
*pValue
) PURE
;
482 STDMETHOD(get_SelectionStart
)(double __RPC_FAR
*pValue
) PURE
;
483 STDMETHOD(put_SelectionStart
)(double pValue
) PURE
;
484 STDMETHOD(get_SelectionEnd
)(double __RPC_FAR
*pValue
) PURE
;
485 STDMETHOD(put_SelectionEnd
)(double pValue
) PURE
;
486 STDMETHOD(get_ShowDisplay
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
487 STDMETHOD(put_ShowDisplay
)(VARIANT_BOOL Show
) PURE
;
488 STDMETHOD(get_ShowControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
489 STDMETHOD(put_ShowControls
)(VARIANT_BOOL Show
) PURE
;
490 STDMETHOD(get_ShowPositionControls
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
491 STDMETHOD(put_ShowPositionControls
)(VARIANT_BOOL Show
) PURE
;
492 STDMETHOD(get_ShowTracker
)(VARIANT_BOOL __RPC_FAR
*Show
) PURE
;
493 STDMETHOD(put_ShowTracker
)(VARIANT_BOOL Show
) PURE
;
494 STDMETHOD(get_EnablePositionControls
)(VARIANT_BOOL __RPC_FAR
*Enable
) PURE
;
495 STDMETHOD(put_EnablePositionControls
)(VARIANT_BOOL Enable
) PURE
;
496 STDMETHOD(get_EnableTracker
)(VARIANT_BOOL __RPC_FAR
*Enable
) PURE
;
497 STDMETHOD(put_EnableTracker
)(VARIANT_BOOL Enable
) PURE
;
498 STDMETHOD(get_Enabled
)(VARIANT_BOOL __RPC_FAR
*pEnabled
) PURE
;
499 STDMETHOD(put_Enabled
)(VARIANT_BOOL pEnabled
) PURE
;
500 STDMETHOD(get_DisplayForeColor
)(VB_OLE_COLOR __RPC_FAR
*ForeColor
) PURE
;
501 STDMETHOD(put_DisplayForeColor
)(VB_OLE_COLOR ForeColor
) PURE
;
502 STDMETHOD(get_DisplayBackColor
)(VB_OLE_COLOR __RPC_FAR
*BackColor
) PURE
;
503 STDMETHOD(put_DisplayBackColor
)(VB_OLE_COLOR BackColor
) PURE
;
504 STDMETHOD(get_DisplayMode
)(MPDisplayModeConstants __RPC_FAR
*pValue
) PURE
;
505 STDMETHOD(put_DisplayMode
)(MPDisplayModeConstants pValue
) PURE
;
506 STDMETHOD(get_VideoBorder3D
)(VARIANT_BOOL __RPC_FAR
*pVideoBorderWidth
) PURE
;
507 STDMETHOD(put_VideoBorder3D
)(VARIANT_BOOL pVideoBorderWidth
) PURE
;
508 STDMETHOD(get_VideoBorderWidth
)(long __RPC_FAR
*pVideoBorderWidth
) PURE
;
509 STDMETHOD(put_VideoBorderWidth
)(long pVideoBorderWidth
) PURE
;
510 STDMETHOD(get_VideoBorderColor
)(VB_OLE_COLOR __RPC_FAR
*pVideoBorderWidth
) PURE
;
511 STDMETHOD(put_VideoBorderColor
)(VB_OLE_COLOR pVideoBorderWidth
) PURE
;
512 STDMETHOD(get_ShowGotoBar
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
513 STDMETHOD(put_ShowGotoBar
)(VARIANT_BOOL pbool
) PURE
;
514 STDMETHOD(get_ShowStatusBar
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
515 STDMETHOD(put_ShowStatusBar
)(VARIANT_BOOL pbool
) PURE
;
516 STDMETHOD(get_ShowCaptioning
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
517 STDMETHOD(put_ShowCaptioning
)(VARIANT_BOOL pbool
) PURE
;
518 STDMETHOD(get_ShowAudioControls
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
519 STDMETHOD(put_ShowAudioControls
)(VARIANT_BOOL pbool
) PURE
;
520 STDMETHOD(get_CaptioningID
)( BSTR __RPC_FAR
*pstrText
) PURE
;
521 STDMETHOD(put_CaptioningID
)(BSTR pstrText
) PURE
;
522 STDMETHOD(get_Mute
)(VARIANT_BOOL __RPC_FAR
*vbool
) PURE
;
523 STDMETHOD(put_Mute
)(VARIANT_BOOL vbool
) PURE
;
524 STDMETHOD(get_CanPreview
)(VARIANT_BOOL __RPC_FAR
*pCanPreview
) PURE
;
525 STDMETHOD(get_PreviewMode
)(VARIANT_BOOL __RPC_FAR
*pPreviewMode
) PURE
;
526 STDMETHOD(put_PreviewMode
)(VARIANT_BOOL pPreviewMode
) PURE
;
527 STDMETHOD(get_HasMultipleItems
)(VARIANT_BOOL __RPC_FAR
*pHasMuliItems
) PURE
;
528 STDMETHOD(get_Language
)(long __RPC_FAR
*pLanguage
) PURE
;
529 STDMETHOD(put_Language
)(long pLanguage
) PURE
;
530 STDMETHOD(get_AudioStream
)(long __RPC_FAR
*pStream
) PURE
;
531 STDMETHOD(put_AudioStream
)(long pStream
) PURE
;
532 STDMETHOD(get_SAMIStyle
)(BSTR __RPC_FAR
*pbstrStyle
) PURE
;
533 STDMETHOD(put_SAMIStyle
)(BSTR pbstrStyle
) PURE
;
534 STDMETHOD(get_SAMILang
)(BSTR __RPC_FAR
*pbstrLang
) PURE
;
535 STDMETHOD(put_SAMILang
)(BSTR pbstrLang
) PURE
;
536 STDMETHOD(get_SAMIFileName
)(BSTR __RPC_FAR
*pbstrFileName
) PURE
;
537 STDMETHOD(put_SAMIFileName
)(BSTR pbstrFileName
) PURE
;
538 STDMETHOD(get_StreamCount
)( long __RPC_FAR
*pStreamCount
) PURE
;
539 STDMETHOD(get_ClientId
)(BSTR __RPC_FAR
*pbstrClientId
) PURE
;
540 STDMETHOD(get_ConnectionSpeed
)(long __RPC_FAR
*plConnectionSpeed
) PURE
;
541 STDMETHOD(get_AutoSize
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
542 STDMETHOD(put_AutoSize
)(VARIANT_BOOL pbool
) PURE
;
543 STDMETHOD(get_EnableFullScreenControls
)(VARIANT_BOOL __RPC_FAR
*pbVal
) PURE
;
544 STDMETHOD(put_EnableFullScreenControls
)(VARIANT_BOOL pbVal
) PURE
;
545 STDMETHOD(get_ActiveMovie
)(IDispatch __RPC_FAR
*__RPC_FAR
*ppdispatch
) PURE
;
546 STDMETHOD(get_NSPlay
)(IDispatch __RPC_FAR
*__RPC_FAR
*ppdispatch
) PURE
;
547 STDMETHOD(get_WindowlessVideo
)(VARIANT_BOOL __RPC_FAR
*pbool
) PURE
;
548 STDMETHOD(put_WindowlessVideo
)(VARIANT_BOOL pbool
) PURE
;
549 STDMETHOD(Play
)(void) PURE
;
550 STDMETHOD(Stop
)(void) PURE
;
551 STDMETHOD(Pause
)(void) PURE
;
552 STDMETHOD(GetMarkerTime
)(long MarkerNum
,
553 double __RPC_FAR
*pMarkerTime
) PURE
;
554 STDMETHOD(GetMarkerName
)(long MarkerNum
,
555 BSTR __RPC_FAR
*pbstrMarkerName
) PURE
;
556 STDMETHOD(AboutBox
)(void) PURE
;
557 STDMETHOD(GetCodecInstalled
)(long CodecNum
,
558 VARIANT_BOOL __RPC_FAR
*pCodecInstalled
) PURE
;
559 STDMETHOD(GetCodecDescription
)(long CodecNum
,
560 BSTR __RPC_FAR
*pbstrCodecDescription
) PURE
;
561 STDMETHOD(GetCodecURL
)(long CodecNum
,
562 BSTR __RPC_FAR
*pbstrCodecURL
) PURE
;
563 STDMETHOD(GetMoreInfoURL
)(MPMoreInfoType MoreInfoType
,
564 BSTR __RPC_FAR
*pbstrMoreInfoURL
) PURE
;
565 STDMETHOD(GetMediaInfoString
)(MPMediaInfoType MediaInfoType
,
566 BSTR __RPC_FAR
*pbstrMediaInfo
) PURE
;
567 STDMETHOD(Cancel
)(void) PURE
;
568 STDMETHOD(Open
)(BSTR bstrFileName
) PURE
;
569 STDMETHOD(IsSoundCardEnabled
)(VARIANT_BOOL __RPC_FAR
*pbSoundCard
) PURE
;
570 STDMETHOD(Next
)(void) PURE
;
571 STDMETHOD(Previous
)(void) PURE
;
572 STDMETHOD(StreamSelect
)(long StreamNum
) PURE
;
573 STDMETHOD(FastForward
)(void) PURE
;
574 STDMETHOD(FastReverse
)(void) PURE
;
575 STDMETHOD(GetStreamName
)(long StreamNum
,
576 BSTR __RPC_FAR
*pbstrStreamName
) PURE
;
577 STDMETHOD(GetStreamGroup
)(long StreamNum
,
578 long __RPC_FAR
*pStreamGroup
) PURE
;
579 STDMETHOD(GetStreamSelected
)(long StreamNum
, VARIANT_BOOL __RPC_FAR
*pStreamSelected
) PURE
;
582 struct IMediaPlayer2
: public IMediaPlayer
584 STDMETHOD(get_DVD
)(struct IMediaPlayerDvd __RPC_FAR
*__RPC_FAR
*ppdispatch
) PURE
;
585 STDMETHOD(GetMediaParameter
)(long EntryNum
, BSTR bstrParameterName
, BSTR __RPC_FAR
*pbstrParameterValue
) PURE
;
586 STDMETHOD(GetMediaParameterName(long EntryNum
, long Index
, BSTR __RPC_FAR
*pbstrParameterName
) PURE
;
587 STDMETHOD(get_EntryCount
)(long __RPC_FAR
*pNumberEntries
) PURE
;
588 STDMETHOD(GetCurrentEntry
)(long __RPC_FAR
*pEntryNumber
) PURE
;
589 STDMETHOD(SetCurrentEntry
)(long EntryNumber
) PURE
;
590 STDMETHOD(ShowDialog
)(MPShowDialogConstants mpDialogIndex
) PURE
;
593 //---------------------------------------------------------------------------
594 // NETSHOW COM INTERFACES (dumped from nscompat.idl from MSVC COM Browser)
595 //---------------------------------------------------------------------------
597 struct INSOPlay
: public IDispatch
599 STDMETHOD(get_ImageSourceWidth
)(long __RPC_FAR
*pWidth
) PURE
;
600 STDMETHOD(get_ImageSourceHeight
)(long __RPC_FAR
*pHeight
) PURE
;
601 STDMETHOD(get_Duration
)(double __RPC_FAR
*pDuration
) PURE
;
602 STDMETHOD(get_Author
)(BSTR __RPC_FAR
*pbstrAuthor
) PURE
;
603 STDMETHOD(get_Copyright
)(BSTR __RPC_FAR
*pbstrCopyright
) PURE
;
604 STDMETHOD(get_Description
)(BSTR __RPC_FAR
*pbstrDescription
) PURE
;
605 STDMETHOD(get_Rating
)(BSTR __RPC_FAR
*pbstrRating
) PURE
;
606 STDMETHOD(get_Title
)(BSTR __RPC_FAR
*pbstrTitle
) PURE
;
607 STDMETHOD(get_SourceLink
)(BSTR __RPC_FAR
*pbstrSourceLink
) PURE
;
608 STDMETHOD(get_MarkerCount
)(long __RPC_FAR
*pMarkerCount
) PURE
;
609 STDMETHOD(get_CanScan
)(VARIANT_BOOL __RPC_FAR
*pCanScan
) PURE
;
610 STDMETHOD(get_CanSeek
)(VARIANT_BOOL __RPC_FAR
*pCanSeek
) PURE
;
611 STDMETHOD(get_CanSeekToMarkers
)(VARIANT_BOOL __RPC_FAR
*pCanSeekToMarkers
) PURE
;
612 STDMETHOD(get_CreationDate
)(DATE __RPC_FAR
*pCreationDate
) PURE
;
613 STDMETHOD(get_Bandwidth
)(long __RPC_FAR
*pBandwidth
) PURE
;
614 STDMETHOD(get_ErrorCorrection
)(BSTR __RPC_FAR
*pbstrErrorCorrection
) PURE
;
615 STDMETHOD(get_AutoStart
)(VARIANT_BOOL __RPC_FAR
*pAutoStart
) PURE
;
616 STDMETHOD(put_AutoStart
)(VARIANT_BOOL pAutoStart
) PURE
;
617 STDMETHOD(get_AutoRewind
)(VARIANT_BOOL __RPC_FAR
*pAutoRewind
) PURE
;
618 STDMETHOD(put_AutoRewind
)(VARIANT_BOOL pAutoRewind
) PURE
;
619 STDMETHOD(get_AllowChangeControlType
)(VARIANT_BOOL __RPC_FAR
*pAllowChangeControlType
) PURE
;
620 STDMETHOD(put_AllowChangeControlType
)(VARIANT_BOOL pAllowChangeControlType
) PURE
;
621 STDMETHOD(get_InvokeURLs
)(VARIANT_BOOL __RPC_FAR
*pInvokeURLs
) PURE
;
622 STDMETHOD(put_InvokeURLs
)(VARIANT_BOOL pInvokeURLs
) PURE
;
623 STDMETHOD(get_EnableContextMenu
)(VARIANT_BOOL __RPC_FAR
*pEnableContextMenu
) PURE
;
624 STDMETHOD(put_EnableContextMenu
)(VARIANT_BOOL pEnableContextMenu
) PURE
;
625 STDMETHOD(get_TransparentAtStart
)(VARIANT_BOOL __RPC_FAR
*pTransparentAtStart
) PURE
;
626 STDMETHOD(put_TransparentAtStart
)(VARIANT_BOOL pTransparentAtStart
) PURE
;
627 STDMETHOD(get_TransparentOnStop
)(VARIANT_BOOL __RPC_FAR
*pTransparentOnStop
) PURE
;
628 STDMETHOD(put_TransparentOnStop
)(VARIANT_BOOL pTransparentOnStop
) PURE
;
629 STDMETHOD(get_ClickToPlay
)(VARIANT_BOOL __RPC_FAR
*pClickToPlay
) PURE
;
630 STDMETHOD(put_ClickToPlay
)(VARIANT_BOOL pClickToPlay
) PURE
;
631 STDMETHOD(get_FileName
)(BSTR __RPC_FAR
*pbstrFileName
) PURE
;
632 STDMETHOD(put_FileName
)(BSTR pbstrFileName
) PURE
;
633 STDMETHOD(get_CurrentPosition
)(double __RPC_FAR
*pCurrentPosition
) PURE
;
634 STDMETHOD(put_CurrentPosition
)(double pCurrentPosition
) PURE
;
635 STDMETHOD(get_Rate
)(double __RPC_FAR
*pRate
) PURE
;
636 STDMETHOD(put_Rate
)(double pRate
) PURE
;
637 STDMETHOD(get_CurrentMarker
)(long __RPC_FAR
*pCurrentMarker
) PURE
;
638 STDMETHOD(put_CurrentMarker
)(long pCurrentMarker
) PURE
;
639 STDMETHOD(get_PlayCount
)(long __RPC_FAR
*pPlayCount
) PURE
;
640 STDMETHOD(put_PlayCount
)(long pPlayCount
) PURE
;
641 STDMETHOD(get_CurrentState
)(long __RPC_FAR
*pCurrentState
) PURE
;
642 STDMETHOD(get_DisplaySize
)(long __RPC_FAR
*pDisplaySize
) PURE
;
643 STDMETHOD(put_DisplaySize
)(long pDisplaySize
) PURE
;
644 STDMETHOD(get_MainWindow
)(long __RPC_FAR
*pMainWindow
) PURE
;
645 STDMETHOD(get_ControlType
)(long __RPC_FAR
*pControlType
) PURE
;
646 STDMETHOD(put_ControlType
)(long pControlType
) PURE
;
647 STDMETHOD(get_AllowScan
)(VARIANT_BOOL __RPC_FAR
*pAllowScan
) PURE
;
648 STDMETHOD(put_AllowScan
)(VARIANT_BOOL pAllowScan
) PURE
;
649 STDMETHOD(get_SendKeyboardEvents
)(VARIANT_BOOL __RPC_FAR
*pSendKeyboardEvents
) PURE
;
650 STDMETHOD(put_SendKeyboardEvents
)(VARIANT_BOOL pSendKeyboardEvents
) PURE
;
651 STDMETHOD(get_SendMouseClickEvents
)(VARIANT_BOOL __RPC_FAR
*pSendMouseClickEvents
) PURE
;
652 STDMETHOD(put_SendMouseClickEvents
)(VARIANT_BOOL pSendMouseClickEvents
) PURE
;
653 STDMETHOD(get_SendMouseMoveEvents
)(VARIANT_BOOL __RPC_FAR
*pSendMouseMoveEvents
) PURE
;
654 STDMETHOD(put_SendMouseMoveEvents
)(VARIANT_BOOL pSendMouseMoveEvents
) PURE
;
655 STDMETHOD(get_SendStateChangeEvents
)(VARIANT_BOOL __RPC_FAR
*pSendStateChangeEvents
) PURE
;
656 STDMETHOD(put_SendStateChangeEvents
)(VARIANT_BOOL pSendStateChangeEvents
) PURE
;
657 STDMETHOD(get_ReceivedPackets
)(long __RPC_FAR
*pReceivedPackets
) PURE
;
658 STDMETHOD(get_RecoveredPackets
)(long __RPC_FAR
*pRecoveredPackets
) PURE
;
659 STDMETHOD(get_LostPackets
)(long __RPC_FAR
*pLostPackets
) PURE
;
660 STDMETHOD(get_ReceptionQuality
)(long __RPC_FAR
*pReceptionQuality
) PURE
;
661 STDMETHOD(get_BufferingCount
)(long __RPC_FAR
*pBufferingCount
) PURE
;
662 STDMETHOD(get_CursorType
)(long __RPC_FAR
*pCursorType
) PURE
;
663 STDMETHOD(put_CursorType
)(long pCursorType
) PURE
;
664 STDMETHOD(get_AnimationAtStart
)(VARIANT_BOOL __RPC_FAR
*pAnimationAtStart
) PURE
;
665 STDMETHOD(put_AnimationAtStart
)(VARIANT_BOOL pAnimationAtStart
) PURE
;
666 STDMETHOD(get_AnimationOnStop
)(VARIANT_BOOL __RPC_FAR
*pAnimationOnStop
) PURE
;
667 STDMETHOD(put_AnimationOnStop
)(VARIANT_BOOL pAnimationOnStop
) PURE
;
668 STDMETHOD(Play
)(void) PURE
;
669 STDMETHOD(Pause
)(void) PURE
;
670 STDMETHOD(Stop
)(void) PURE
;
671 STDMETHOD(GetMarkerTime
)(long MarkerNum
, double __RPC_FAR
*pMarkerTime
) PURE
;
672 STDMETHOD(GetMarkerName
)(long MarkerNum
, BSTR __RPC_FAR
*pbstrMarkerName
) PURE
;
675 struct INSPlay
: public INSOPlay
677 STDMETHOD(get_ChannelName
)(BSTR __RPC_FAR
*pbstrChannelName
) PURE
;
678 STDMETHOD(get_ChannelDescription
)(BSTR __RPC_FAR
*pbstrChannelDescription
) PURE
;
679 STDMETHOD(get_ChannelURL
)(BSTR __RPC_FAR
*pbstrChannelURL
) PURE
;
680 STDMETHOD(get_ContactAddress
)(BSTR __RPC_FAR
*pbstrContactAddress
) PURE
;
681 STDMETHOD(get_ContactPhone
)(BSTR __RPC_FAR
*pbstrContactPhone
) PURE
;
682 STDMETHOD(get_ContactEmail
)(BSTR __RPC_FAR
*pbstrContactEmail
) PURE
;
683 STDMETHOD(get_AllowChangeDisplaySize
)(VARIANT_BOOL __RPC_FAR
*pAllowChangeDisplaySize
) PURE
;
684 STDMETHOD(put_AllowChangeDisplaySize
)(VARIANT_BOOL pAllowChangeDisplaySize
) PURE
;
685 STDMETHOD(get_CodecCount
)(long __RPC_FAR
*pCodecCount
) PURE
;
686 STDMETHOD(get_IsBroadcast
)(VARIANT_BOOL __RPC_FAR
*pIsBroadcast
) PURE
;
687 STDMETHOD(get_IsDurationValid
)(VARIANT_BOOL __RPC_FAR
*pIsDurationValid
) PURE
;
688 STDMETHOD(get_SourceProtocol
)(long __RPC_FAR
*pSourceProtocol
) PURE
;
689 STDMETHOD(get_OpenState
)(long __RPC_FAR
*pOpenState
) PURE
;
690 STDMETHOD(get_SendOpenStateChangeEvents
)(VARIANT_BOOL __RPC_FAR
*pSendOpenStateChangeEvents
) PURE
;
691 STDMETHOD(put_SendOpenStateChangeEvents
)(VARIANT_BOOL pSendOpenStateChangeEvents
) PURE
;
692 STDMETHOD(get_SendWarningEvents
)(VARIANT_BOOL __RPC_FAR
*pSendWarningEvents
) PURE
;
693 STDMETHOD(put_SendWarningEvents
)(VARIANT_BOOL pSendWarningEvents
) PURE
;
694 STDMETHOD(get_SendErrorEvents
)(VARIANT_BOOL __RPC_FAR
*pSendErrorEvents
) PURE
;
695 STDMETHOD(put_SendErrorEvents
)(VARIANT_BOOL pSendErrorEvents
) PURE
;
696 STDMETHOD(get_HasError
)(VARIANT_BOOL __RPC_FAR
*pHasError
) PURE
;
697 STDMETHOD(get_ErrorDescription
)(BSTR __RPC_FAR
*pbstrErrorDescription
) PURE
;
698 STDMETHOD(get_ErrorCode
)(long __RPC_FAR
*pErrorCode
) PURE
;
699 STDMETHOD(get_PlayState
)(long __RPC_FAR
*pPlayState
) PURE
;
700 STDMETHOD(get_SendPlayStateChangeEvents
)(VARIANT_BOOL __RPC_FAR
*pSendPlayStateChangeEvents
) PURE
;
701 STDMETHOD(put_SendPlayStateChangeEvents
)(VARIANT_BOOL pSendPlayStateChangeEvents
) PURE
;
702 STDMETHOD(get_BufferingTime
)(double __RPC_FAR
*pBufferingTime
) PURE
;
703 STDMETHOD(put_BufferingTime
)(double pBufferingTime
) PURE
;
704 STDMETHOD(get_UseFixedUDPPort
)(VARIANT_BOOL __RPC_FAR
*pUseFixedUDPPort
) PURE
;
705 STDMETHOD(put_UseFixedUDPPort
)(VARIANT_BOOL pUseFixedUDPPort
) PURE
;
706 STDMETHOD(get_FixedUDPPort
)(long __RPC_FAR
*pFixedUDPPort
) PURE
;
707 STDMETHOD(put_FixedUDPPort
)(long pFixedUDPPort
) PURE
;
708 STDMETHOD(get_UseHTTPProxy
)(VARIANT_BOOL __RPC_FAR
*pUseHTTPProxy
) PURE
;
709 STDMETHOD(put_UseHTTPProxy
)(VARIANT_BOOL pUseHTTPProxy
) PURE
;
710 STDMETHOD(get_EnableAutoProxy
)(VARIANT_BOOL __RPC_FAR
*pEnableAutoProxy
) PURE
;
711 STDMETHOD(put_EnableAutoProxy
)(VARIANT_BOOL pEnableAutoProxy
) PURE
;
712 STDMETHOD(get_HTTPProxyHost
)(BSTR __RPC_FAR
*pbstrHTTPProxyHost
) PURE
;
713 STDMETHOD(put_HTTPProxyHost
)(BSTR pbstrHTTPProxyHost
) PURE
;
714 STDMETHOD(get_HTTPProxyPort
)(long __RPC_FAR
*pHTTPProxyPort
) PURE
;
715 STDMETHOD(put_HTTPProxyPort
)(long pHTTPProxyPort
) PURE
;
716 STDMETHOD(get_EnableMulticast
)(VARIANT_BOOL __RPC_FAR
*pEnableMulticast
) PURE
;
717 STDMETHOD(put_EnableMulticast
)(VARIANT_BOOL pEnableMulticast
) PURE
;
718 STDMETHOD(get_EnableUDP
)(VARIANT_BOOL __RPC_FAR
*pEnableUDP
) PURE
;
719 STDMETHOD(put_EnableUDP
)(VARIANT_BOOL pEnableUDP
) PURE
;
720 STDMETHOD(get_EnableTCP
)(VARIANT_BOOL __RPC_FAR
*pEnableTCP
) PURE
;
721 STDMETHOD(put_EnableTCP
)(VARIANT_BOOL pEnableTCP
) PURE
;
722 STDMETHOD(get_EnableHTTP
)(VARIANT_BOOL __RPC_FAR
*pEnableHTTP
) PURE
;
723 STDMETHOD(put_EnableHTTP
)(VARIANT_BOOL pEnableHTTP
) PURE
;
724 STDMETHOD(get_BufferingProgress
)(long __RPC_FAR
*pBufferingProgress
) PURE
;
725 STDMETHOD(get_BaseURL
)(BSTR __RPC_FAR
*pbstrBaseURL
) PURE
;
726 STDMETHOD(put_BaseURL
)(BSTR pbstrBaseURL
) PURE
;
727 STDMETHOD(get_DefaultFrame
)(BSTR __RPC_FAR
*pbstrDefaultFrame
) PURE
;
728 STDMETHOD(put_DefaultFrame
)(BSTR pbstrDefaultFrame
) PURE
;
729 STDMETHOD(AboutBox
))(void) PURE
;
730 STDMETHOD(Cancel
)(void) PURE
;
731 STDMETHOD(GetCodecInstalled
)(long CodecNum
, VARIANT_BOOL __RPC_FAR
*pCodecInstalled
) PURE
;
732 STDMETHOD(GetCodecDescription
)(long CodecNum
, BSTR __RPC_FAR
*pbstrCodecDescription
) PURE
;
733 STDMETHOD(GetCodecURL
)(long CodecNum
, BSTR __RPC_FAR
*pbstrCodecURL
) PURE
;
734 STDMETHOD(Open
)(BSTR bstrFileName
) PURE
;
738 struct INSPlay1
: public INSPlay
740 STDMETHOD(get_MediaPlayer
)(IDispatch __RPC_FAR
*__RPC_FAR
*ppdispatch
) PURE
;
743 //---------------------------------------------------------------------------
744 // MISC COM INTERFACES
745 //---------------------------------------------------------------------------
746 typedef enum _FilterState
752 typedef enum _PinDirection
{
757 typedef struct _FilterInfo
{
759 struct IFilterGraph
*pGraph
;
762 typedef struct _PinInfo
{
763 struct IBaseFilter
*pFilter
;
771 typedef struct _MediaType
{
774 BOOL bFixedSizeSamples
;
775 BOOL bTemporalCompression
;
783 struct IFilterGraph
: public IUnknown
785 STDMETHOD(AddFilter
)(IBaseFilter
*, LPCWSTR
) PURE
;
786 STDMETHOD(RemoveFilter
)(IBaseFilter
*) PURE
;
787 STDMETHOD(EnumFilters
)(IEnumFilters
**) PURE
;
788 STDMETHOD(FindFilterByName
)(LPCWSTR
, IBaseFilter
**) PURE
;
789 STDMETHOD(ConnectDirect
)(IPin
*, IPin
*, const AM_MEDIA_TYPE
*) PURE
;
790 STDMETHOD(Reconnect
)(IPin
*) PURE
;
791 STDMETHOD(Disconnect
)(IPin
*) PURE
;
792 STDMETHOD(SetDefaultSyncSource
)() PURE
;
795 struct IGraphBuilder
: public IFilterGraph
797 STDMETHOD(Connect
)(IPin
*, IPin
*) PURE
;
798 STDMETHOD(Render
)(IPin
*) PURE
;
799 STDMETHOD(RenderFile
)(LPCWSTR
, LPCWSTR
) PURE
;
800 STDMETHOD(AddSourceFilter
)(LPCWSTR
, LPCWSTR
, IBaseFilter
**) PURE
;
801 STDMETHOD(SetLogFile
)(DWORD_PTR
) PURE
;
802 STDMETHOD(Abort
)() PURE
;
803 STDMETHOD(ShouldOperationContinue
)() PURE
;
806 struct IReferenceClock
;
808 #define REFERENCE_TIME LONGLONG
809 struct IMediaFilter
: public IPersist
811 STDMETHOD(Stop
)( void) PURE
;
812 STDMETHOD(Pause
)( void) PURE
;
813 STDMETHOD(Run
)(REFERENCE_TIME tStart
) PURE
;
814 STDMETHOD(GetState
)(DWORD dwMilliSecsTimeout
,
815 FILTER_STATE
*State
) PURE
;
816 STDMETHOD(SetSyncSource
)(IReferenceClock
*pClock
) PURE
;
817 STDMETHOD(GetSyncSource
)(IReferenceClock
**pClock
) PURE
;
820 struct IBaseFilter
: public IMediaFilter
822 STDMETHOD(EnumPins
)(IEnumPins
**ppEnum
) PURE
;
823 STDMETHOD(FindPin
)(LPCWSTR Id
, IPin
**ppPin
) PURE
;
824 STDMETHOD(QueryFilterInfo
)(FILTER_INFO
*pInfo
) PURE
;
825 STDMETHOD(JoinFilterGraph
)(IFilterGraph
*pGraph
, LPCWSTR pName
) PURE
;
826 STDMETHOD(QueryVendorInfo
)(LPWSTR
*pVendorInfo
) PURE
;
830 //###########################################################################
836 //###########################################################################
838 typedef BOOL (WINAPI
* LPAMGETERRORTEXT
)(HRESULT
, wxChar
*, DWORD
);
840 class WXDLLIMPEXP_MEDIA wxAMMediaBackend
: public wxMediaBackendCommonBase
844 virtual ~wxAMMediaBackend();
847 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
852 const wxValidator
& validator
,
853 const wxString
& name
);
856 virtual bool Pause();
859 virtual bool Load(const wxString
& fileName
);
860 virtual bool Load(const wxURI
& location
);
861 virtual bool Load(const wxURI
& location
, const wxURI
& proxy
);
863 bool DoLoad(const wxString
& location
);
866 virtual wxMediaState
GetState();
868 virtual bool SetPosition(wxLongLong where
);
869 virtual wxLongLong
GetPosition();
870 virtual wxLongLong
GetDuration();
872 virtual void Move(int x
, int y
, int w
, int h
);
873 wxSize
GetVideoSize() const;
875 virtual double GetPlaybackRate();
876 virtual bool SetPlaybackRate(double);
878 virtual double GetVolume();
879 virtual bool SetVolume(double);
881 virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags
);
884 void DoGetDownloadProgress(wxLongLong
*, wxLongLong
*);
885 virtual wxLongLong
GetDownloadProgress()
887 wxLongLong progress
, total
;
888 DoGetDownloadProgress(&progress
, &total
);
891 virtual wxLongLong
GetDownloadTotal()
893 wxLongLong progress
, total
;
894 DoGetDownloadProgress(&progress
, &total
);
898 wxActiveXContainer
* m_pAX
;
905 wxDynamicLibrary m_dllQuartz
;
906 LPAMGETERRORTEXT m_lpAMGetErrorText
;
907 wxString
GetErrorString(HRESULT hrdsv
);
908 #endif // __WXDEBUG__
910 DECLARE_DYNAMIC_CLASS(wxAMMediaBackend
)
913 //---------------------------------------------------------------------------
917 //---------------------------------------------------------------------------
919 //---------------------------------------------------------------------------
921 //---------------------------------------------------------------------------
922 #include <mmsystem.h>
924 class WXDLLIMPEXP_MEDIA wxMCIMediaBackend
: public wxMediaBackendCommonBase
929 ~wxMCIMediaBackend();
931 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
936 const wxValidator
& validator
,
937 const wxString
& name
);
940 virtual bool Pause();
943 virtual bool Load(const wxURI
& location
,
945 { return wxMediaBackend::Load(location
, proxy
); }
947 virtual bool Load(const wxString
& fileName
);
948 virtual bool Load(const wxURI
& location
);
950 virtual wxMediaState
GetState();
952 virtual bool SetPosition(wxLongLong where
);
953 virtual wxLongLong
GetPosition();
954 virtual wxLongLong
GetDuration();
956 virtual void Move(int x
, int y
, int w
, int h
);
957 wxSize
GetVideoSize() const;
959 virtual double GetPlaybackRate();
960 virtual bool SetPlaybackRate(double dRate
);
962 virtual double GetVolume();
963 virtual bool SetVolume(double);
965 static LRESULT CALLBACK
NotifyWndProc(HWND hWnd
, UINT nMsg
,
966 WPARAM wParam
, LPARAM lParam
);
968 LRESULT CALLBACK
OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
969 WPARAM wParam
, LPARAM lParam
);
971 MCIDEVICEID m_hDev
; //Our MCI Device ID/Handler
972 HWND m_hNotifyWnd
; //Window to use for MCI events
973 bool m_bVideo
; //Whether or not we have video
975 DECLARE_DYNAMIC_CLASS(wxMCIMediaBackend
)
978 //---------------------------------------------------------------------------
982 // We don't include Quicktime headers here and define all the types
983 // ourselves because looking for the quicktime libaries etc. would
984 // be tricky to do and making this a dependency for the MSVC projects
985 // would be unrealistic.
987 // Thanks to Robert Roebling for the wxDL macro/library idea
988 //---------------------------------------------------------------------------
990 //---------------------------------------------------------------------------
992 //---------------------------------------------------------------------------
993 //#include <qtml.h> //Windoze QT include
994 //#include <QuickTimeComponents.h> //Standard QT stuff
995 #include "wx/dynlib.h"
997 //---------------------------------------------------------------------------
999 //---------------------------------------------------------------------------
1000 typedef struct MovieRecord
* Movie
;
1001 typedef wxInt16 OSErr
;
1002 typedef wxInt32 OSStatus
;
1005 typedef unsigned char Str255
[256];
1006 #define StringPtr unsigned char*
1007 #define newMovieActive 1
1008 #define newMovieAsyncOK (1 << 8)
1012 #define OSType unsigned long
1013 #define CGrafPtr struct GrafPort *
1014 #define TimeScale long
1015 #define TimeBase struct TimeBaseRecord *
1016 typedef struct ComponentInstanceRecord
* ComponentInstance
;
1017 #define kMovieLoadStatePlayable 10000
1019 #define MovieController ComponentInstance
1021 #ifndef URLDataHandlerSubType
1022 #if defined(__WATCOMC__) || defined(__MINGW32__)
1023 // use magic numbers for compilers which complain about multicharacter integers
1024 const OSType URLDataHandlerSubType
= 1970433056;
1025 const OSType VisualMediaCharacteristic
= 1702454643;
1027 const OSType URLDataHandlerSubType
= 'url ';
1028 const OSType VisualMediaCharacteristic
= 'eyes';
1035 Str255 name
; /*Str63 on mac, Str255 on msw */
1051 wide value
; /* units */
1052 TimeScale scale
; /* units per second */
1061 struct EventRecord
{
1071 mcScaleMovieToFit
= 2,
1077 //---------------------------------------------------------------------------
1079 //---------------------------------------------------------------------------
1080 #define wxDL_METHOD_DEFINE( rettype, name, args, shortargs, defret ) \
1081 typedef rettype (* name ## Type) args ; \
1082 name ## Type pfn_ ## name; \
1084 { if (m_ok) return pfn_ ## name shortargs ; return defret; }
1086 #define wxDL_VOIDMETHOD_DEFINE( name, args, shortargs ) \
1087 typedef void (* name ## Type) args ; \
1088 name ## Type pfn_ ## name; \
1090 { if (m_ok) pfn_ ## name shortargs ; }
1092 #define wxDL_METHOD_LOAD( lib, name, success ) \
1093 pfn_ ## name = (name ## Type) lib.GetSymbol( wxT(#name), &success ); \
1094 if (!success) { wxLog::EnableLogging(bWasLoggingEnabled); return false; }
1097 class WXDLLIMPEXP_MEDIA wxQuickTimeLibrary
1100 ~wxQuickTimeLibrary()
1102 if(m_dll
.IsLoaded())
1107 bool IsOk() const {return m_ok
;}
1110 wxDynamicLibrary m_dll
;
1114 wxDL_VOIDMETHOD_DEFINE( StartMovie
, (Movie m
), (m
) );
1115 wxDL_VOIDMETHOD_DEFINE( StopMovie
, (Movie m
), (m
) );
1116 wxDL_METHOD_DEFINE( bool, IsMovieDone
, (Movie m
), (m
), false);
1117 wxDL_VOIDMETHOD_DEFINE( GoToBeginningOfMovie
, (Movie m
), (m
) );
1118 wxDL_METHOD_DEFINE( OSErr
, GetMoviesError
, (), (), -1);
1119 wxDL_METHOD_DEFINE( OSErr
, EnterMovies
, (), (), -1);
1120 wxDL_VOIDMETHOD_DEFINE( ExitMovies
, (), () );
1121 wxDL_METHOD_DEFINE( OSErr
, InitializeQTML
, (long flags
), (flags
), -1);
1122 wxDL_VOIDMETHOD_DEFINE( TerminateQTML
, (), () );
1124 wxDL_METHOD_DEFINE( OSErr
, NativePathNameToFSSpec
,
1125 (char* inName
, FSSpec
* outFile
, long flags
),
1126 (inName
, outFile
, flags
), -1);
1128 wxDL_METHOD_DEFINE( OSErr
, OpenMovieFile
,
1129 (const FSSpec
* fileSpec
, short * resRefNum
, wxInt8 permission
),
1130 (fileSpec
, resRefNum
, permission
), -1 );
1132 wxDL_METHOD_DEFINE( OSErr
, CloseMovieFile
,
1133 (short resRefNum
), (resRefNum
), -1);
1135 wxDL_METHOD_DEFINE( OSErr
, NewMovieFromFile
,
1136 (Movie
* theMovie
, short resRefNum
, short * resId
,
1137 StringPtr resName
, short newMovieFlags
,
1138 bool * dataRefWasChanged
),
1139 (theMovie
, resRefNum
, resId
, resName
, newMovieFlags
,
1140 dataRefWasChanged
), -1);
1142 wxDL_VOIDMETHOD_DEFINE( SetMovieRate
, (Movie m
, Fixed rate
), (m
, rate
) );
1143 wxDL_METHOD_DEFINE( Fixed
, GetMovieRate
, (Movie m
), (m
), 0);
1144 wxDL_VOIDMETHOD_DEFINE( MoviesTask
, (Movie m
, long maxms
), (m
, maxms
) );
1145 wxDL_VOIDMETHOD_DEFINE( BlockMove
,
1146 (const char* p1
, const char* p2
, long s
), (p1
,p2
,s
) );
1147 wxDL_METHOD_DEFINE( Handle
, NewHandleClear
, (long s
), (s
), NULL
);
1149 wxDL_METHOD_DEFINE( OSErr
, NewMovieFromDataRef
,
1150 (Movie
* m
, short flags
, short * id
,
1151 Handle dataRef
, OSType dataRefType
),
1152 (m
,flags
,id
,dataRef
,dataRefType
), -1 );
1154 wxDL_VOIDMETHOD_DEFINE( DisposeHandle
, (Handle h
), (h
) );
1155 wxDL_VOIDMETHOD_DEFINE( GetMovieNaturalBoundsRect
, (Movie m
, Rect
* r
), (m
,r
) );
1156 wxDL_METHOD_DEFINE( void*, GetMovieIndTrackType
,
1157 (Movie m
, long index
, OSType type
, long flags
),
1158 (m
,index
,type
,flags
), NULL
);
1159 wxDL_VOIDMETHOD_DEFINE( CreatePortAssociation
,
1160 (void* hWnd
, void* junk
, long morejunk
), (hWnd
, junk
, morejunk
) );
1161 wxDL_METHOD_DEFINE(void*, GetNativeWindowPort
, (void* hWnd
), (hWnd
), NULL
);
1162 wxDL_VOIDMETHOD_DEFINE(SetMovieGWorld
, (Movie m
, CGrafPtr port
, void* whatever
),
1163 (m
, port
, whatever
) );
1164 wxDL_VOIDMETHOD_DEFINE(DisposeMovie
, (Movie m
), (m
) );
1165 wxDL_VOIDMETHOD_DEFINE(SetMovieBox
, (Movie m
, Rect
* r
), (m
,r
));
1166 wxDL_VOIDMETHOD_DEFINE(SetMovieTimeScale
, (Movie m
, long s
), (m
,s
));
1167 wxDL_METHOD_DEFINE(long, GetMovieDuration
, (Movie m
), (m
), 0);
1168 wxDL_METHOD_DEFINE(TimeBase
, GetMovieTimeBase
, (Movie m
), (m
), 0);
1169 wxDL_METHOD_DEFINE(TimeScale
, GetMovieTimeScale
, (Movie m
), (m
), 0);
1170 wxDL_METHOD_DEFINE(long, GetMovieTime
, (Movie m
, void* cruft
), (m
,cruft
), 0);
1171 wxDL_VOIDMETHOD_DEFINE(SetMovieTime
, (Movie m
, TimeRecord
* tr
), (m
,tr
) );
1172 wxDL_METHOD_DEFINE(short, GetMovieVolume
, (Movie m
), (m
), 0);
1173 wxDL_VOIDMETHOD_DEFINE(SetMovieVolume
, (Movie m
, short sVolume
), (m
,sVolume
) );
1174 wxDL_VOIDMETHOD_DEFINE(SetMovieTimeValue
, (Movie m
, long s
), (m
,s
));
1175 wxDL_METHOD_DEFINE(ComponentInstance
, NewMovieController
, (Movie m
, const Rect
* mr
, long fl
), (m
,mr
,fl
), 0);
1176 wxDL_VOIDMETHOD_DEFINE(DisposeMovieController
, (ComponentInstance ci
), (ci
));
1177 wxDL_METHOD_DEFINE(int, MCSetVisible
, (ComponentInstance m
, int b
), (m
, b
), 0);
1180 wxDL_VOIDMETHOD_DEFINE(PrePrerollMovie
, (Movie m
, long t
, Fixed r
, WXFARPROC p1
, void* p2
), (m
,t
,r
,p1
,p2
) );
1181 wxDL_VOIDMETHOD_DEFINE(PrerollMovie
, (Movie m
, long t
, Fixed r
), (m
,t
,r
) );
1182 wxDL_METHOD_DEFINE(Fixed
, GetMoviePreferredRate
, (Movie m
), (m
), 0);
1183 wxDL_METHOD_DEFINE(long, GetMovieLoadState
, (Movie m
), (m
), 0);
1184 wxDL_METHOD_DEFINE(void*, NewRoutineDescriptor
, (WXFARPROC f
, int l
, void* junk
), (f
, l
, junk
), 0);
1185 wxDL_VOIDMETHOD_DEFINE(DisposeRoutineDescriptor
, (void* f
), (f
));
1186 wxDL_METHOD_DEFINE(void*, GetCurrentArchitecture
, (), (), 0);
1187 wxDL_METHOD_DEFINE(int, MCDoAction
, (ComponentInstance ci
, long f
, void* p
), (ci
,f
,p
), 0);
1188 wxDL_VOIDMETHOD_DEFINE(MCSetControllerBoundsRect
, (ComponentInstance ci
, Rect
* r
), (ci
,r
));
1189 wxDL_VOIDMETHOD_DEFINE(DestroyPortAssociation
, (CGrafPtr g
), (g
));
1190 wxDL_VOIDMETHOD_DEFINE(NativeEventToMacEvent
, (MSG
* p1
, EventRecord
* p2
), (p1
,p2
));
1191 wxDL_VOIDMETHOD_DEFINE(MCIsPlayerEvent
, (ComponentInstance ci
, EventRecord
* p2
), (ci
, p2
));
1192 wxDL_METHOD_DEFINE(int, MCSetMovie
, (ComponentInstance ci
, Movie m
, void* p1
, Point w
),
1194 wxDL_VOIDMETHOD_DEFINE(MCPositionController
,
1195 (ComponentInstance ci
, Rect
* r
, void* junk
, void* morejunk
), (ci
,r
,junk
,morejunk
));
1196 wxDL_VOIDMETHOD_DEFINE(MCSetActionFilterWithRefCon
,
1197 (ComponentInstance ci
, WXFARPROC cb
, void* ref
), (ci
,cb
,ref
));
1198 wxDL_VOIDMETHOD_DEFINE(MCGetControllerInfo
, (MovieController mc
, long* flags
), (mc
,flags
));
1199 wxDL_VOIDMETHOD_DEFINE(BeginUpdate
, (CGrafPtr port
), (port
));
1200 wxDL_VOIDMETHOD_DEFINE(UpdateMovie
, (Movie m
), (m
));
1201 wxDL_VOIDMETHOD_DEFINE(EndUpdate
, (CGrafPtr port
), (port
));
1202 wxDL_METHOD_DEFINE( OSErr
, GetMoviesStickyError
, (), (), -1);
1205 bool wxQuickTimeLibrary::Initialize()
1209 bool bWasLoggingEnabled
= wxLog::EnableLogging(false); //Turn off the wxDynamicLibrary logging
1211 if(!m_dll
.Load(wxT("qtmlClient.dll")))
1213 wxLog::EnableLogging(bWasLoggingEnabled
);
1217 wxDL_METHOD_LOAD( m_dll
, StartMovie
, m_ok
);
1218 wxDL_METHOD_LOAD( m_dll
, StopMovie
, m_ok
);
1219 wxDL_METHOD_LOAD( m_dll
, IsMovieDone
, m_ok
);
1220 wxDL_METHOD_LOAD( m_dll
, GoToBeginningOfMovie
, m_ok
);
1221 wxDL_METHOD_LOAD( m_dll
, GetMoviesError
, m_ok
);
1222 wxDL_METHOD_LOAD( m_dll
, EnterMovies
, m_ok
);
1223 wxDL_METHOD_LOAD( m_dll
, ExitMovies
, m_ok
);
1224 wxDL_METHOD_LOAD( m_dll
, InitializeQTML
, m_ok
);
1225 wxDL_METHOD_LOAD( m_dll
, TerminateQTML
, m_ok
);
1226 wxDL_METHOD_LOAD( m_dll
, NativePathNameToFSSpec
, m_ok
);
1227 wxDL_METHOD_LOAD( m_dll
, OpenMovieFile
, m_ok
);
1228 wxDL_METHOD_LOAD( m_dll
, CloseMovieFile
, m_ok
);
1229 wxDL_METHOD_LOAD( m_dll
, NewMovieFromFile
, m_ok
);
1230 wxDL_METHOD_LOAD( m_dll
, GetMovieRate
, m_ok
);
1231 wxDL_METHOD_LOAD( m_dll
, SetMovieRate
, m_ok
);
1232 wxDL_METHOD_LOAD( m_dll
, MoviesTask
, m_ok
);
1233 wxDL_METHOD_LOAD( m_dll
, BlockMove
, m_ok
);
1234 wxDL_METHOD_LOAD( m_dll
, NewHandleClear
, m_ok
);
1235 wxDL_METHOD_LOAD( m_dll
, NewMovieFromDataRef
, m_ok
);
1236 wxDL_METHOD_LOAD( m_dll
, DisposeHandle
, m_ok
);
1237 wxDL_METHOD_LOAD( m_dll
, GetMovieNaturalBoundsRect
, m_ok
);
1238 wxDL_METHOD_LOAD( m_dll
, GetMovieIndTrackType
, m_ok
);
1239 wxDL_METHOD_LOAD( m_dll
, CreatePortAssociation
, m_ok
);
1240 wxDL_METHOD_LOAD( m_dll
, DestroyPortAssociation
, m_ok
);
1241 wxDL_METHOD_LOAD( m_dll
, GetNativeWindowPort
, m_ok
);
1242 wxDL_METHOD_LOAD( m_dll
, SetMovieGWorld
, m_ok
);
1243 wxDL_METHOD_LOAD( m_dll
, DisposeMovie
, m_ok
);
1244 wxDL_METHOD_LOAD( m_dll
, SetMovieBox
, m_ok
);
1245 wxDL_METHOD_LOAD( m_dll
, SetMovieTimeScale
, m_ok
);
1246 wxDL_METHOD_LOAD( m_dll
, GetMovieDuration
, m_ok
);
1247 wxDL_METHOD_LOAD( m_dll
, GetMovieTimeBase
, m_ok
);
1248 wxDL_METHOD_LOAD( m_dll
, GetMovieTimeScale
, m_ok
);
1249 wxDL_METHOD_LOAD( m_dll
, GetMovieTime
, m_ok
);
1250 wxDL_METHOD_LOAD( m_dll
, SetMovieTime
, m_ok
);
1251 wxDL_METHOD_LOAD( m_dll
, GetMovieVolume
, m_ok
);
1252 wxDL_METHOD_LOAD( m_dll
, SetMovieVolume
, m_ok
);
1253 wxDL_METHOD_LOAD( m_dll
, SetMovieTimeValue
, m_ok
);
1254 wxDL_METHOD_LOAD( m_dll
, NewMovieController
, m_ok
);
1255 wxDL_METHOD_LOAD( m_dll
, DisposeMovieController
, m_ok
);
1256 wxDL_METHOD_LOAD( m_dll
, MCSetVisible
, m_ok
);
1257 wxDL_METHOD_LOAD( m_dll
, PrePrerollMovie
, m_ok
);
1258 wxDL_METHOD_LOAD( m_dll
, PrerollMovie
, m_ok
);
1259 wxDL_METHOD_LOAD( m_dll
, GetMoviePreferredRate
, m_ok
);
1260 wxDL_METHOD_LOAD( m_dll
, GetMovieLoadState
, m_ok
);
1261 wxDL_METHOD_LOAD( m_dll
, MCDoAction
, m_ok
);
1262 wxDL_METHOD_LOAD( m_dll
, MCSetControllerBoundsRect
, m_ok
);
1263 wxDL_METHOD_LOAD( m_dll
, NativeEventToMacEvent
, m_ok
);
1264 wxDL_METHOD_LOAD( m_dll
, MCIsPlayerEvent
, m_ok
);
1265 wxDL_METHOD_LOAD( m_dll
, MCSetMovie
, m_ok
);
1266 wxDL_METHOD_LOAD( m_dll
, MCSetActionFilterWithRefCon
, m_ok
);
1267 wxDL_METHOD_LOAD( m_dll
, MCGetControllerInfo
, m_ok
);
1268 wxDL_METHOD_LOAD( m_dll
, BeginUpdate
, m_ok
);
1269 wxDL_METHOD_LOAD( m_dll
, UpdateMovie
, m_ok
);
1270 wxDL_METHOD_LOAD( m_dll
, EndUpdate
, m_ok
);
1271 wxDL_METHOD_LOAD( m_dll
, GetMoviesStickyError
, m_ok
);
1273 wxLog::EnableLogging(bWasLoggingEnabled
);
1279 class WXDLLIMPEXP_MEDIA wxQTMediaBackend
: public wxMediaBackendCommonBase
1283 ~wxQTMediaBackend();
1285 virtual bool CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
1290 const wxValidator
& validator
,
1291 const wxString
& name
);
1293 virtual bool Play();
1294 virtual bool Pause();
1295 virtual bool Stop();
1297 virtual bool Load(const wxURI
& location
,
1299 { return wxMediaBackend::Load(location
, proxy
); }
1301 virtual bool Load(const wxString
& fileName
);
1302 virtual bool Load(const wxURI
& location
);
1304 virtual wxMediaState
GetState();
1306 virtual bool SetPosition(wxLongLong where
);
1307 virtual wxLongLong
GetPosition();
1308 virtual wxLongLong
GetDuration();
1310 virtual void Move(int x
, int y
, int w
, int h
);
1311 wxSize
GetVideoSize() const;
1313 virtual double GetPlaybackRate();
1314 virtual bool SetPlaybackRate(double dRate
);
1316 virtual double GetVolume();
1317 virtual bool SetVolume(double);
1322 static void PPRMProc (Movie theMovie
, OSErr theErr
, void* theRefCon
);
1323 //TODO: Last param actually long - does this work on 64bit machines?
1324 static Boolean
MCFilterProc (MovieController theController
,
1325 short action
, void *params
, LONG_PTR refCon
);
1327 static LRESULT CALLBACK
QTWndProc(HWND
, UINT
, WPARAM
, LPARAM
);
1329 virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags
);
1331 wxSize m_bestSize
; //Original movie size
1332 Movie m_movie
; //QT Movie handle/instance
1333 bool m_bVideo
; //Whether or not we have video
1334 bool m_bPlaying
; //Whether or not movie is playing
1335 wxTimer
* m_timer
; //Load or Play timer
1336 wxQuickTimeLibrary m_lib
; //DLL to load functions from
1337 ComponentInstance m_pMC
; //Movie Controller
1339 friend class wxQTMediaEvtHandler
;
1340 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend
)
1343 // helper to hijack background erasing for the QT window
1344 class WXDLLIMPEXP_MEDIA wxQTMediaEvtHandler
: public wxEvtHandler
1347 wxQTMediaEvtHandler(wxQTMediaBackend
*qtb
, WXHWND hwnd
)
1352 m_qtb
->m_ctrl
->Connect(m_qtb
->m_ctrl
->GetId(),
1353 wxEVT_ERASE_BACKGROUND
,
1354 wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground
),
1359 void OnEraseBackground(wxEraseEvent
& event
);
1362 wxQTMediaBackend
*m_qtb
;
1365 DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler
)
1369 //===========================================================================
1371 //===========================================================================
1373 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1377 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1379 IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend
, wxMediaBackend
);
1381 //---------------------------------------------------------------------------
1382 // Usual debugging macros
1383 //---------------------------------------------------------------------------
1385 #define MAX_ERROR_TEXT_LEN 160
1387 //Get the error string for Active Movie
1388 wxString
wxAMMediaBackend::GetErrorString(HRESULT hrdsv
)
1390 wxChar szError
[MAX_ERROR_TEXT_LEN
];
1391 if( m_lpAMGetErrorText
!= NULL
&&
1392 (*m_lpAMGetErrorText
)(hrdsv
, szError
, MAX_ERROR_TEXT_LEN
) == 0)
1394 return wxString::Format(wxT("DirectShow error \"%s\" \n")
1395 wxT("(numeric %X)\n")
1397 szError
, (int)hrdsv
);
1401 return wxString::Format(wxT("Unknown error \n")
1402 wxT("(numeric %X)\n")
1408 #define wxAMFAIL(x) wxFAIL_MSG(GetErrorString(x));
1409 #define wxVERIFY(x) wxASSERT((x))
1410 #define wxAMLOG(x) wxLogDebug(GetErrorString(x))
1412 #define wxAMVERIFY(x) (x)
1413 #define wxVERIFY(x) (x)
1418 //---------------------------------------------------------------------------
1419 // Standard macros for ease of use
1420 //---------------------------------------------------------------------------
1421 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
1423 //---------------------------------------------------------------------------
1426 // Queries the control periodically to see if it has reached the point
1427 // in its loading cycle where we can begin playing the media - if so
1428 // then we finish up some things like getting the original size of the video
1429 // and then sending the loaded event to our handler
1430 //---------------------------------------------------------------------------
1431 class wxAMLoadTimer
: public wxTimer
1434 wxAMLoadTimer(wxAMMediaBackend
* parent
) :
1441 MPReadyStateConstants nState
;
1442 m_parent
->m_pMP
->get_ReadyState(&nState
);
1443 if(nState
!= mpReadyStateLoading
)
1446 m_parent
->FinishLoad();
1452 IActiveMovie2
* pAM2
= NULL
;
1453 ReadyStateConstants nState
;
1454 if(m_parent
->m_pAM
->QueryInterface(IID_IActiveMovie2
,
1455 (void**)&pAM2
) == 0 &&
1456 pAM2
->get_ReadyState(&nState
) == 0)
1459 if(nState
!= amvLoading
)
1462 m_parent
->FinishLoad();
1472 m_parent
->FinishLoad();
1480 wxAMMediaBackend
* m_parent
; //Backend pointer
1483 //---------------------------------------------------------------------------
1486 // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet
1487 // Queries the control periodically to see if it has stopped -
1488 // if it has it sends the stop event
1489 //---------------------------------------------------------------------------
1490 class wxAMPlayTimer
: public wxTimer
1493 wxAMPlayTimer(wxAMMediaBackend
* parent
) :
1498 if(m_parent
->GetState() == wxMEDIASTATE_STOPPED
&&
1499 //NB: Stop events could get triggered by the interface
1500 //if ShowPlayerControls is enabled,
1501 //so we need this hack here to make an attempt
1502 //at it not getting sent - but its far from ideal -
1503 //they can still get sent in some cases
1504 m_parent
->GetPosition() == m_parent
->GetDuration())
1506 if ( m_parent
->SendStopEvent() )
1508 //Seek to beginning of movie
1509 m_parent
->wxAMMediaBackend::SetPosition(0);
1512 //send the event to our child
1513 m_parent
->QueueFinishEvent();
1519 wxAMMediaBackend
* m_parent
; //Backend pointer
1524 // The following is an alternative way - but it doesn't seem
1525 // to work with the IActiveMovie control - it probably processes
1527 //---------------------------------------------------------------------------
1530 // Query the IMediaEvent interface from the embedded WMP's
1531 // filtergraph, then process the events from it - sending
1532 // EC_COMPLETE events as stop events to the media control.
1533 //---------------------------------------------------------------------------
1534 class wxAMPlayTimer : public wxTimer
1537 wxAMPlayTimer(wxAMMediaBackend* pBE) : m_pBE(pBE), m_pME(NULL)
1541 hr = m_pBE->m_pAM->get_FilterGraph(&pGB);
1542 wxASSERT(SUCCEEDED(hr));
1543 hr = pGB->QueryInterface(IID_IMediaEvent, (void**)&m_pME);
1544 wxASSERT(SUCCEEDED(hr));
1550 SAFE_RELEASE(m_pME);
1560 // DirectShow keeps a list of queued events, and we need
1561 // to go through them one by one, stopping at (Hopefully only one)
1562 // EC_COMPLETE message
1564 while( m_pME->GetEvent(&evCode, &evParam1, &evParam2, 0) == 0 )
1566 // Cleanup memory that GetEvent allocated
1567 HRESULT hr = m_pME->FreeEventParams(evCode,
1568 evParam1, evParam2);
1571 //Even though this makes a messagebox this
1572 //is windows where we can do gui stuff in seperate
1574 wxFAIL_MSG(m_pBE->GetErrorString(hr));
1576 // If this is the end of the clip, notify handler
1577 else if(1 == evCode) //EC_COMPLETE
1579 if ( m_pBE->SendStopEvent() )
1583 m_pBE->QueueFinishEvent();
1590 wxAMMediaBackend* m_pBE; //Backend pointer
1591 IMediaEvent* m_pME; //To determine when to send stop event
1595 //---------------------------------------------------------------------------
1596 // wxAMMediaBackend Constructor
1597 //---------------------------------------------------------------------------
1598 wxAMMediaBackend::wxAMMediaBackend()
1606 //---------------------------------------------------------------------------
1607 // wxAMMediaBackend Destructor
1608 //---------------------------------------------------------------------------
1609 wxAMMediaBackend::~wxAMMediaBackend()
1611 Clear(); //Free memory from Load()
1615 m_pAX
->DissociateHandle();
1624 //---------------------------------------------------------------------------
1625 // wxAMMediaBackend::Clear
1627 // Free up interfaces and memory allocated by LoadXXX
1628 //---------------------------------------------------------------------------
1629 void wxAMMediaBackend::Clear()
1635 //---------------------------------------------------------------------------
1636 // wxAMMediaBackend::CreateControl
1637 //---------------------------------------------------------------------------
1638 bool wxAMMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
1643 const wxValidator
& validator
,
1644 const wxString
& name
)
1646 // First get the AMGetErrorText procedure in debug
1647 // mode for more meaningful messages
1649 if ( m_dllQuartz
.Load(_T("quartz.dll"), wxDL_VERBATIM
) )
1651 m_lpAMGetErrorText
= (LPAMGETERRORTEXT
)
1652 m_dllQuartz
.GetSymbolAorW(wxT("AMGetErrorText"));
1654 #endif // __WXDEBUG__
1656 // Now determine which (if any) media player interface is
1657 // available - IMediaPlayer or IActiveMovie
1658 if( ::CoCreateInstance(CLSID_MediaPlayer
, NULL
,
1659 CLSCTX_INPROC_SERVER
,
1660 IID_IMediaPlayer
, (void**)&m_pMP
) != 0 )
1662 if( ::CoCreateInstance(CLSID_ActiveMovie
, NULL
,
1663 CLSCTX_INPROC_SERVER
,
1664 IID_IActiveMovie
, (void**)&m_pAM
) != 0 )
1666 m_pAM
->QueryInterface(IID_IMediaPlayer
, (void**)&m_pMP
);
1670 m_pMP
->QueryInterface(IID_IActiveMovie
, (void**)&m_pAM
);
1674 // By default wxWindow(s) is created with a border -
1675 // so we need to get rid of those
1677 // Since we don't have a child window like most other
1678 // backends, we don't need wxCLIP_CHILDREN
1680 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
1681 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
,
1686 // Now create the ActiveX container along with the media player
1687 // interface and query them
1689 m_ctrl
= wxStaticCast(ctrl
, wxMediaCtrl
);
1690 m_pAX
= new wxActiveXContainer(ctrl
,
1691 m_pMP
? IID_IMediaPlayer
: IID_IActiveMovie
,
1696 // Here we set up wx-specific stuff for the default
1697 // settings wxMediaCtrl says it will stay to
1701 m_pMP
->put_DisplaySize(mpFitToSize
);
1702 // TODO: Unsure what actual effect this has
1703 m_pMP
->put_WindowlessVideo(VARIANT_TRUE
);
1706 m_pAM
->put_MovieWindowSize(amvDoubleOriginalSize
);
1709 m_pAM
->put_AutoStart(VARIANT_FALSE
);
1710 //by default enabled
1711 wxAMMediaBackend::ShowPlayerControls(wxMEDIACTRLPLAYERCONTROLS_NONE
);
1712 //by default with AM only 0.5
1713 wxAMMediaBackend::SetVolume(1.0);
1715 // don't erase the background of our control window so that resizing is a
1717 m_ctrl
->SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
1723 //---------------------------------------------------------------------------
1724 // wxAMMediaBackend::Load (file version)
1725 //---------------------------------------------------------------------------
1726 bool wxAMMediaBackend::Load(const wxString
& fileName
)
1728 return DoLoad(fileName
);
1731 //---------------------------------------------------------------------------
1732 // wxAMMediaBackend::Load (URL Version)
1733 //---------------------------------------------------------------------------
1734 bool wxAMMediaBackend::Load(const wxURI
& location
)
1736 // Turn off loading from a proxy as user
1737 // may have set it previously
1738 INSPlay
* pPlay
= NULL
;
1739 m_pAM
->QueryInterface(IID_INSPlay
, (void**) &pPlay
);
1742 pPlay
->put_UseHTTPProxy(VARIANT_FALSE
);
1746 return DoLoad(location
.BuildURI());
1749 //---------------------------------------------------------------------------
1750 // wxAMMediaBackend::Load (URL Version with Proxy)
1751 //---------------------------------------------------------------------------
1752 bool wxAMMediaBackend::Load(const wxURI
& location
, const wxURI
& proxy
)
1754 // Set the proxy of the NETSHOW interface
1755 INSPlay
* pPlay
= NULL
;
1756 m_pAM
->QueryInterface(IID_INSPlay
, (void**) &pPlay
);
1760 pPlay
->put_UseHTTPProxy(VARIANT_TRUE
);
1761 pPlay
->put_HTTPProxyHost(wxBasicString(proxy
.GetServer()).Get());
1762 pPlay
->put_HTTPProxyPort(wxAtoi(proxy
.GetPort()));
1766 return DoLoad(location
.BuildURI());
1769 //---------------------------------------------------------------------------
1770 // wxAMMediaBackend::DoLoad
1772 // Called by all functions - this actually renders
1773 // the file and sets up the filter graph
1774 //---------------------------------------------------------------------------
1775 bool wxAMMediaBackend::DoLoad(const wxString
& location
)
1777 Clear(); //Clear up previously allocated memory
1781 // Play the movie the normal way through the embedded
1782 // WMP. Supposively Open is better in theory because
1783 // the docs say its async and put_FileName is not -
1784 // but in practice they both seem to be async anyway
1786 hr
= m_pMP
->Open( wxBasicString(location
).Get() );
1788 hr
= m_pAM
->put_FileName( wxBasicString(location
).Get() );
1796 // In AM playing will FAIL if
1797 // the user plays before the media is loaded
1798 m_pTimer
= new wxAMLoadTimer(this);
1799 m_pTimer
->Start(20);
1803 //---------------------------------------------------------------------------
1804 // wxAMMediaBackend::FinishLoad
1806 // Called by our wxAMLoadTimer when the
1807 // embedded WMP tells its the media is ready to play.
1809 // Here we get the original size of the video and
1810 // send the loaded event to our watcher :).
1811 //---------------------------------------------------------------------------
1812 void wxAMMediaBackend::FinishLoad()
1814 //Get the original video size
1815 m_pAM
->get_ImageSourceWidth((long*)&m_bestSize
.x
);
1816 m_pAM
->get_ImageSourceHeight((long*)&m_bestSize
.y
);
1819 //Start the play timer to catch stop events
1820 //Previous load timer cleans up itself
1822 m_pTimer
= new wxAMPlayTimer(this);
1824 NotifyMovieLoaded();
1827 //---------------------------------------------------------------------------
1828 // wxAMMediaBackend::ShowPlayerControls
1829 //---------------------------------------------------------------------------
1830 bool wxAMMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags
)
1832 // Note that IMediaPlayer doesn't have a statusbar by
1833 // default but IActiveMovie does - so lets try to keep
1834 // the interface consistant
1837 m_pAM
->put_Enabled(VARIANT_FALSE
);
1838 m_pAM
->put_ShowControls(VARIANT_FALSE
);
1840 m_pMP
->put_ShowStatusBar(VARIANT_FALSE
);
1844 m_pAM
->put_Enabled(VARIANT_TRUE
);
1845 m_pAM
->put_ShowControls(VARIANT_TRUE
);
1847 m_pAM
->put_ShowPositionControls(
1848 (flags
& wxMEDIACTRLPLAYERCONTROLS_STEP
) ?
1849 VARIANT_TRUE
: VARIANT_FALSE
);
1853 m_pMP
->put_ShowStatusBar(VARIANT_TRUE
);
1854 m_pMP
->put_ShowAudioControls(
1855 (flags
& wxMEDIACTRLPLAYERCONTROLS_VOLUME
) ?
1856 VARIANT_TRUE
: VARIANT_FALSE
);
1863 //---------------------------------------------------------------------------
1864 // wxAMMediaBackend::Play
1866 // Plays the stream. If it is non-seekable, it will restart it (implicit).
1868 // Note that we use SUCCEEDED here because run/pause/stop tend to be overly
1869 // picky and return warnings on pretty much every call
1870 //---------------------------------------------------------------------------
1871 bool wxAMMediaBackend::Play()
1873 // if the movie isn't done loading yet
1874 // go into an sync getmessage loop until it is :)
1877 MPReadyStateConstants nState
;
1878 m_pMP
->get_ReadyState(&nState
);
1879 while(nState
== mpReadyStateLoading
&& wxYieldIfNeeded())
1881 m_pMP
->get_ReadyState(&nState
);
1886 IActiveMovie2
* pAM2
;
1887 ReadyStateConstants nState
;
1888 if(m_pAM
->QueryInterface(IID_IActiveMovie2
, (void**)&pAM2
) == 0 &&
1889 pAM2
->get_ReadyState(&nState
) == 0)
1891 while(nState
== amvLoading
&& wxYieldIfNeeded())
1893 pAM2
->get_ReadyState(&nState
);
1899 //Actually try to play the movie
1900 HRESULT hr
= m_pAM
->Run();
1903 m_pTimer
->Start(20);
1910 //---------------------------------------------------------------------------
1911 // wxAMMediaBackend::Pause
1913 // Pauses the stream.
1914 //---------------------------------------------------------------------------
1915 bool wxAMMediaBackend::Pause()
1917 HRESULT hr
= m_pAM
->Pause();
1924 //---------------------------------------------------------------------------
1925 // wxAMMediaBackend::Stop
1927 // Stops the stream.
1928 //---------------------------------------------------------------------------
1929 bool wxAMMediaBackend::Stop()
1931 HRESULT hr
= m_pAM
->Stop();
1935 wxAMMediaBackend::SetPosition(0);
1936 //Stop stop event timer
1944 //---------------------------------------------------------------------------
1945 // wxAMMediaBackend::SetPosition
1947 // 1) Translates the current position's time to directshow time,
1948 // which is in a scale of 1 second (in a double)
1949 // 2) Sets the play position of the IMediaSeeking interface -
1950 // passing NULL as the stop position means to keep the old
1952 //---------------------------------------------------------------------------
1953 bool wxAMMediaBackend::SetPosition(wxLongLong where
)
1955 HRESULT hr
= m_pAM
->put_CurrentPosition(
1956 ((LONGLONG
)where
.GetValue()) / 1000.0
1967 //---------------------------------------------------------------------------
1968 // wxAMMediaBackend::GetPosition
1970 // 1) Obtains the current play and stop positions from IMediaSeeking
1971 // 2) Returns the play position translated to our time base
1972 //---------------------------------------------------------------------------
1973 wxLongLong
wxAMMediaBackend::GetPosition()
1976 HRESULT hr
= m_pAM
->get_CurrentPosition(&outCur
);
1983 //h,m,s,milli - outdur is in 1 second (double)
1991 //---------------------------------------------------------------------------
1992 // wxAMMediaBackend::GetVolume
1994 // Gets the volume through the IBasicAudio interface -
1995 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
1996 // -100 per decibel.
1997 //---------------------------------------------------------------------------
1998 double wxAMMediaBackend::GetVolume()
2001 HRESULT hr
= m_pAM
->get_Volume(&lVolume
);
2007 return pow(10.0, lVolume
/2000.0);
2010 //---------------------------------------------------------------------------
2011 // wxAMMediaBackend::SetVolume
2013 // Sets the volume through the IBasicAudio interface -
2014 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
2015 // -100 per decibel.
2016 //---------------------------------------------------------------------------
2017 bool wxAMMediaBackend::SetVolume(double dVolume
)
2019 //pow(10.0, -80.0) to correct 0 == -INF
2020 long lVolume
= (long)(2000.0 * log10(pow(10.0, -80.0)+dVolume
));
2021 HRESULT hr
= m_pAM
->put_Volume( lVolume
);
2030 //---------------------------------------------------------------------------
2031 // wxAMMediaBackend::GetDuration
2033 // 1) Obtains the duration of the media from IAMMultiMediaStream
2034 // 2) Converts that value to our time base, and returns it
2036 // NB: With VBR MP3 files the default DirectShow MP3 render does not
2037 // read the Xing header correctly, resulting in skewed values for duration
2039 //---------------------------------------------------------------------------
2040 wxLongLong
wxAMMediaBackend::GetDuration()
2043 HRESULT hr
= m_pAM
->get_Duration(&outDuration
);
2050 //h,m,s,milli - outdur is in 1 second (double)
2051 outDuration
*= 1000;
2053 ll
.Assign(outDuration
);
2058 //---------------------------------------------------------------------------
2059 // wxAMMediaBackend::GetState
2061 // Returns the cached state
2062 //---------------------------------------------------------------------------
2063 wxMediaState
wxAMMediaBackend::GetState()
2065 StateConstants nState
;
2066 HRESULT hr
= m_pAM
->get_CurrentState(&nState
);
2070 return wxMEDIASTATE_STOPPED
;
2073 return (wxMediaState
)nState
;
2076 //---------------------------------------------------------------------------
2077 // wxAMMediaBackend::GetPlaybackRate
2079 // Pretty simple way of obtaining the playback rate from
2080 // the IMediaSeeking interface
2081 //---------------------------------------------------------------------------
2082 double wxAMMediaBackend::GetPlaybackRate()
2085 HRESULT hr
= m_pAM
->get_Rate(&dRate
);
2094 //---------------------------------------------------------------------------
2095 // wxAMMediaBackend::SetPlaybackRate
2097 // Sets the playback rate of the media - DirectShow is pretty good
2098 // about this, actually
2099 //---------------------------------------------------------------------------
2100 bool wxAMMediaBackend::SetPlaybackRate(double dRate
)
2102 HRESULT hr
= m_pAM
->put_Rate(dRate
);
2112 //---------------------------------------------------------------------------
2113 // wxAMMediaBackend::GetDownloadXXX
2115 // Queries for and gets the total size of the file and the current
2116 // progress in downloading that file from the IAMOpenProgress
2117 // interface from the media player interface's filter graph
2118 //---------------------------------------------------------------------------
2119 void wxAMMediaBackend::DoGetDownloadProgress(wxLongLong
* pLoadProgress
,
2120 wxLongLong
* pLoadTotal
)
2122 LONGLONG loadTotal
= 0, loadProgress
= 0;
2124 IAMOpenProgress
* pOP
;
2126 hr
= m_pAM
->get_FilterGraph(&pFG
);
2129 hr
= pFG
->QueryInterface(IID_IAMOpenProgress
, (void**)&pOP
);
2132 hr
= pOP
->QueryProgress(&loadTotal
, &loadProgress
);
2140 *pLoadProgress
= loadProgress
;
2141 *pLoadTotal
= loadTotal
;
2145 //When not loading from a URL QueryProgress will return
2146 //E_NOINTERFACE or whatever
2153 //---------------------------------------------------------------------------
2154 // wxAMMediaBackend::GetVideoSize
2156 // Obtains the cached original video size
2157 //---------------------------------------------------------------------------
2158 wxSize
wxAMMediaBackend::GetVideoSize() const
2163 //---------------------------------------------------------------------------
2164 // wxAMMediaBackend::Move
2166 // We take care of this in our redrawing
2167 //---------------------------------------------------------------------------
2168 void wxAMMediaBackend::Move(int WXUNUSED(x
), int WXUNUSED(y
),
2169 int WXUNUSED(w
), int WXUNUSED(h
))
2173 //---------------------------------------------------------------------------
2174 // End of wxAMMediaBackend
2175 //---------------------------------------------------------------------------
2177 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2179 // wxMCIMediaBackend
2181 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2183 IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend
, wxMediaBackend
);
2185 //---------------------------------------------------------------------------
2186 // Usual debugging macros for MCI returns
2187 //---------------------------------------------------------------------------
2190 #define wxMCIVERIFY(arg) \
2193 if ( (nRet = (arg)) != 0) \
2196 mciGetErrorString(nRet, sz, 5000); \
2197 wxFAIL_MSG(wxString::Format(_T("MCI Error:%s"), sz)); \
2201 #define wxMCIVERIFY(arg) (arg);
2204 //---------------------------------------------------------------------------
2205 // Simulation for <digitalv.h>
2207 // Mingw and possibly other compilers don't have the digitalv.h header
2208 // that is needed to have some essential features of mci work with
2209 // windows - so we provide the declarations for the types we use here
2210 //---------------------------------------------------------------------------
2213 DWORD_PTR dwCallback
;
2214 #ifdef MCI_USE_OFFEXT
2220 } MCI_DGV_RECT_PARMS
;
2223 DWORD_PTR dwCallback
;
2233 } MCI_DGV_WINDOW_PARMS
;
2236 DWORD_PTR dwCallback
;
2241 } MCI_DGV_SET_PARMS
;
2244 DWORD_PTR dwCallback
;
2248 wxChar
* lpstrAlgorithm
;
2249 wxChar
* lpstrQuality
;
2250 } MCI_DGV_SETAUDIO_PARMS
;
2252 //---------------------------------------------------------------------------
2253 // wxMCIMediaBackend Constructor
2255 // Here we don't need to do much except say we don't have any video :)
2256 //---------------------------------------------------------------------------
2257 wxMCIMediaBackend::wxMCIMediaBackend() : m_hNotifyWnd(NULL
), m_bVideo(false)
2261 //---------------------------------------------------------------------------
2262 // wxMCIMediaBackend Destructor
2264 // We close the mci device - note that there may not be an mci device here,
2265 // or it may fail - but we don't really care, since we're destructing
2266 //---------------------------------------------------------------------------
2267 wxMCIMediaBackend::~wxMCIMediaBackend()
2271 mciSendCommand(m_hDev
, MCI_CLOSE
, 0, 0);
2272 DestroyWindow(m_hNotifyWnd
);
2273 m_hNotifyWnd
= NULL
;
2277 //---------------------------------------------------------------------------
2278 // wxMCIMediaBackend::Create
2280 // Here we just tell wxMediaCtrl that mci does exist (which it does, on all
2281 // msw systems, at least in some form dating back to win16 days)
2282 //---------------------------------------------------------------------------
2283 bool wxMCIMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
2288 const wxValidator
& validator
,
2289 const wxString
& name
)
2293 // By default wxWindow(s) is created with a border -
2294 // so we need to get rid of those, and create with
2295 // wxCLIP_CHILDREN, so that if the driver/backend
2296 // is a child window, it refereshes properly
2298 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
2299 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
| wxCLIP_CHILDREN
,
2303 m_ctrl
= wxStaticCast(ctrl
, wxMediaCtrl
);
2307 //---------------------------------------------------------------------------
2308 // wxMCIMediaBackend::Load (file version)
2310 // Here we have MCI load a file and device, set the time format to our
2311 // default (milliseconds), and set the video (if any) to play in the control
2312 //---------------------------------------------------------------------------
2313 bool wxMCIMediaBackend::Load(const wxString
& fileName
)
2316 //if the user already called load close the previous MCI device
2320 mciSendCommand(m_hDev
, MCI_CLOSE
, 0, 0);
2321 DestroyWindow(m_hNotifyWnd
);
2322 m_hNotifyWnd
= NULL
;
2326 //Opens a file and has MCI select a device. Normally you'd put
2327 //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you
2328 //omit this it tells MCI to select the device instead. This is
2329 //good because we have no reliable way of "enumerating" the devices
2332 MCI_OPEN_PARMS openParms
;
2333 openParms
.lpstrElementName
= (wxChar
*) fileName
.c_str();
2335 if ( mciSendCommand(0, MCI_OPEN
, MCI_OPEN_ELEMENT
,
2336 (DWORD
)(LPVOID
)&openParms
) != 0)
2339 m_hDev
= openParms
.wDeviceID
;
2342 //Now set the time format for the device to milliseconds
2344 MCI_SET_PARMS setParms
;
2345 setParms
.dwCallback
= 0;
2346 setParms
.dwTimeFormat
= MCI_FORMAT_MILLISECONDS
;
2348 if (mciSendCommand(m_hDev
, MCI_SET
, MCI_SET_TIME_FORMAT
,
2349 (DWORD
)(LPVOID
)&setParms
) != 0)
2353 //Now tell the MCI device to display the video in our wxMediaCtrl
2355 MCI_DGV_WINDOW_PARMS windowParms
;
2356 windowParms
.hWnd
= (HWND
)m_ctrl
->GetHandle();
2358 m_bVideo
= (mciSendCommand(m_hDev
, MCI_WINDOW
,
2359 0x00010000L
, //MCI_DGV_WINDOW_HWND
2360 (DWORD
)(LPVOID
)&windowParms
) == 0);
2363 // Create a hidden window and register to handle
2365 // Note that wxCanvasClassName is already registered
2366 // and used by all wxWindows and normal wxControls
2368 m_hNotifyWnd
= ::CreateWindow
2382 wxLogSysError( wxT("Could not create hidden needed for ")
2383 wxT("registering for MCI events!") );
2388 wxSetWindowProc(m_hNotifyWnd
, wxMCIMediaBackend::NotifyWndProc
);
2389 wxSetWindowUserData(m_hNotifyWnd
, this);
2391 NotifyMovieLoaded();
2396 //---------------------------------------------------------------------------
2397 // wxMCIMediaBackend::Load (URL version)
2399 // MCI doesn't support URLs directly (?)
2401 // TODO: Use wxURL/wxFileSystem and mmioInstallProc
2402 //---------------------------------------------------------------------------
2403 bool wxMCIMediaBackend::Load(const wxURI
& WXUNUSED(location
))
2408 //---------------------------------------------------------------------------
2409 // wxMCIMediaBackend::Play
2411 // Plays/Resumes the MCI device... a couple notes:
2412 // 1) Certain drivers will crash and burn if we don't pass them an
2413 // MCI_PLAY_PARMS, despite the documentation that says otherwise...
2414 // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing
2415 // and will resume from a stopped state also, so there's no need to
2416 // call both, for example
2417 //---------------------------------------------------------------------------
2418 bool wxMCIMediaBackend::Play()
2420 MCI_PLAY_PARMS playParms
;
2421 playParms
.dwCallback
= (DWORD
)m_hNotifyWnd
;
2423 bool bOK
= ( mciSendCommand(m_hDev
, MCI_PLAY
, MCI_NOTIFY
,
2424 (DWORD
)(LPVOID
)&playParms
) == 0 );
2427 m_ctrl
->Show(m_bVideo
);
2432 //---------------------------------------------------------------------------
2433 // wxMCIMediaBackend::Pause
2435 // Pauses the MCI device - nothing special
2436 //---------------------------------------------------------------------------
2437 bool wxMCIMediaBackend::Pause()
2439 return (mciSendCommand(m_hDev
, MCI_PAUSE
, MCI_WAIT
, 0) == 0);
2442 //---------------------------------------------------------------------------
2443 // wxMCIMediaBackend::Stop
2445 // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline
2446 //---------------------------------------------------------------------------
2447 bool wxMCIMediaBackend::Stop()
2449 return (mciSendCommand(m_hDev
, MCI_STOP
, MCI_WAIT
, 0) == 0) &&
2450 (mciSendCommand(m_hDev
, MCI_SEEK
, MCI_SEEK_TO_START
, 0) == 0);
2453 //---------------------------------------------------------------------------
2454 // wxMCIMediaBackend::GetState
2456 // Here we get the state and convert it to a wxMediaState -
2457 // since we use direct comparisons with MCI_MODE_PLAY and
2458 // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call
2460 //---------------------------------------------------------------------------
2461 wxMediaState
wxMCIMediaBackend::GetState()
2463 MCI_STATUS_PARMS statusParms
;
2464 statusParms
.dwItem
= MCI_STATUS_MODE
;
2466 mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
2467 (DWORD
)(LPVOID
)&statusParms
);
2469 if(statusParms
.dwReturn
== MCI_MODE_PAUSE
)
2470 return wxMEDIASTATE_PAUSED
;
2471 else if(statusParms
.dwReturn
== MCI_MODE_PLAY
)
2472 return wxMEDIASTATE_PLAYING
;
2474 return wxMEDIASTATE_STOPPED
;
2477 //---------------------------------------------------------------------------
2478 // wxMCIMediaBackend::SetPosition
2480 // Here we set the position of the device in the stream.
2481 // Note that MCI actually stops the device after you seek it if the
2482 // device is playing/paused, so we need to play the file after
2483 // MCI seeks like normal APIs would
2484 //---------------------------------------------------------------------------
2485 bool wxMCIMediaBackend::SetPosition(wxLongLong where
)
2487 MCI_SEEK_PARMS seekParms
;
2488 seekParms
.dwCallback
= 0;
2489 #if wxUSE_LONGLONG_NATIVE && !wxUSE_LONGLONG_WX
2490 seekParms
.dwTo
= (DWORD
)where
.GetValue();
2491 #else /* wxUSE_LONGLONG_WX */
2492 /* no way to return it in one piece */
2493 wxASSERT( where
.GetHi()==0 );
2494 seekParms
.dwTo
= (DWORD
)where
.GetLo();
2495 #endif /* wxUSE_LONGLONG_* */
2497 //device was playing?
2498 bool bReplay
= GetState() == wxMEDIASTATE_PLAYING
;
2500 if( mciSendCommand(m_hDev
, MCI_SEEK
, MCI_TO
,
2501 (DWORD
)(LPVOID
)&seekParms
) != 0)
2504 //If the device was playing, resume it
2511 //---------------------------------------------------------------------------
2512 // wxMCIMediaBackend::GetPosition
2514 // Gets the position of the device in the stream using the current
2515 // time format... nothing special here...
2516 //---------------------------------------------------------------------------
2517 wxLongLong
wxMCIMediaBackend::GetPosition()
2519 MCI_STATUS_PARMS statusParms
;
2520 statusParms
.dwItem
= MCI_STATUS_POSITION
;
2522 if (mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
2523 (DWORD
)(LPSTR
)&statusParms
) != 0)
2526 return statusParms
.dwReturn
;
2529 //---------------------------------------------------------------------------
2530 // wxMCIMediaBackend::GetVolume
2532 // Gets the volume of the current media via the MCI_DGV_STATUS_VOLUME
2533 // message. Value ranges from 0 (minimum) to 1000 (maximum volume).
2534 //---------------------------------------------------------------------------
2535 double wxMCIMediaBackend::GetVolume()
2537 MCI_STATUS_PARMS statusParms
;
2538 statusParms
.dwCallback
= 0;
2539 statusParms
.dwItem
= 0x4019; //MCI_DGV_STATUS_VOLUME
2541 if (mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
2542 (DWORD
)(LPSTR
)&statusParms
) != 0)
2545 return ((double)statusParms
.dwReturn
) / 1000.0;
2548 //---------------------------------------------------------------------------
2549 // wxMCIMediaBackend::SetVolume
2551 // Sets the volume of the current media via the MCI_DGV_SETAUDIO_VOLUME
2552 // message. Value ranges from 0 (minimum) to 1000 (maximum volume).
2553 //---------------------------------------------------------------------------
2554 bool wxMCIMediaBackend::SetVolume(double dVolume
)
2556 MCI_DGV_SETAUDIO_PARMS audioParms
;
2557 audioParms
.dwCallback
= 0;
2558 audioParms
.dwItem
= 0x4002; //MCI_DGV_SETAUDIO_VOLUME
2559 audioParms
.dwValue
= (DWORD
) (dVolume
* 1000.0);
2560 audioParms
.dwOver
= 0;
2561 audioParms
.lpstrAlgorithm
= NULL
;
2562 audioParms
.lpstrQuality
= NULL
;
2564 if (mciSendCommand(m_hDev
, 0x0873, //MCI_SETAUDIO
2565 //MCI_DGV_SETAUDIO+(_ITEM | _VALUE)
2566 0x00800000L
| 0x01000000L
,
2567 (DWORD
)(LPSTR
)&audioParms
) != 0)
2572 //---------------------------------------------------------------------------
2573 // wxMCIMediaBackend::GetDuration
2575 // Gets the duration of the stream... nothing special
2576 //---------------------------------------------------------------------------
2577 wxLongLong
wxMCIMediaBackend::GetDuration()
2579 MCI_STATUS_PARMS statusParms
;
2580 statusParms
.dwItem
= MCI_STATUS_LENGTH
;
2582 if (mciSendCommand(m_hDev
, MCI_STATUS
, MCI_STATUS_ITEM
,
2583 (DWORD
)(LPSTR
)&statusParms
) != 0)
2586 return statusParms
.dwReturn
;
2589 //---------------------------------------------------------------------------
2590 // wxMCIMediaBackend::Move
2592 // Moves the window to a location
2593 //---------------------------------------------------------------------------
2594 void wxMCIMediaBackend::Move(int WXUNUSED(x
), int WXUNUSED(y
),
2597 if (m_hNotifyWnd
&& m_bVideo
)
2599 MCI_DGV_RECT_PARMS putParms
; //ifdefed MCI_DGV_PUT_PARMS
2600 memset(&putParms
, 0, sizeof(MCI_DGV_RECT_PARMS
));
2601 putParms
.rc
.bottom
= h
;
2602 putParms
.rc
.right
= w
;
2604 //wxStackWalker will crash and burn here on assert
2605 //and mci doesn't like 0 and 0 for some reason (out of range )
2606 //so just don't it in that case
2609 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_PUT
,
2610 0x00040000L
, //MCI_DGV_PUT_DESTINATION
2611 (DWORD
)(LPSTR
)&putParms
) );
2616 //---------------------------------------------------------------------------
2617 // wxMCIMediaBackend::GetVideoSize
2619 // Gets the original size of the movie for sizers
2620 //---------------------------------------------------------------------------
2621 wxSize
wxMCIMediaBackend::GetVideoSize() const
2625 MCI_DGV_RECT_PARMS whereParms
; //ifdefed MCI_DGV_WHERE_PARMS
2627 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_WHERE
,
2628 0x00020000L
, //MCI_DGV_WHERE_SOURCE
2629 (DWORD
)(LPSTR
)&whereParms
) );
2631 return wxSize(whereParms
.rc
.right
, whereParms
.rc
.bottom
);
2636 //---------------------------------------------------------------------------
2637 // wxMCIMediaBackend::GetPlaybackRate
2640 //---------------------------------------------------------------------------
2641 double wxMCIMediaBackend::GetPlaybackRate()
2646 //---------------------------------------------------------------------------
2647 // wxMCIMediaBackend::SetPlaybackRate
2650 //---------------------------------------------------------------------------
2651 bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate
))
2654 MCI_WAVE_SET_SAMPLESPERSEC
2655 MCI_DGV_SET_PARMS setParms;
2656 setParms.dwSpeed = (DWORD) (dRate * 1000.0);
2658 return (mciSendCommand(m_hDev, MCI_SET,
2659 0x00020000L, //MCI_DGV_SET_SPEED
2660 (DWORD)(LPSTR)&setParms) == 0);
2665 //---------------------------------------------------------------------------
2666 // [static] wxMCIMediaBackend::MSWWindowProc
2668 // Here we process a message when MCI reaches the stopping point
2670 //---------------------------------------------------------------------------
2671 LRESULT CALLBACK
wxMCIMediaBackend::NotifyWndProc(HWND hWnd
, UINT nMsg
,
2675 wxMCIMediaBackend
* backend
=
2676 (wxMCIMediaBackend
*)wxGetWindowUserData(hWnd
);
2678 return backend
->OnNotifyWndProc(hWnd
, nMsg
, wParam
, lParam
);
2681 LRESULT CALLBACK
wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd
, UINT nMsg
,
2685 if(nMsg
== MM_MCINOTIFY
)
2687 wxASSERT(lParam
== (LPARAM
) m_hDev
);
2688 if(wParam
== MCI_NOTIFY_SUCCESSFUL
&& lParam
== (LPARAM
)m_hDev
)
2690 if ( SendStopEvent() )
2692 wxMCIVERIFY( mciSendCommand(m_hDev
, MCI_SEEK
,
2693 MCI_SEEK_TO_START
, 0) );
2699 return DefWindowProc(hWnd
, nMsg
, wParam
, lParam
);
2702 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2706 // TODO: Use a less cludgy way to pause/get state/set state
2707 // FIXME: Greg Hazel reports that sometimes files that cannot be played
2708 // with this backend are treated as playable anyway - not verifyed though.
2709 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2711 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend
, wxMediaBackend
);
2713 //Time between timer calls - this is the Apple recommondation to the TCL
2715 #define MOVIE_DELAY 20
2717 #include "wx/timer.h"
2720 //---------------------------------------------------------------------------
2723 // QT, esp. QT for Windows is very picky about how you go about
2724 // async loading. If you were to go through a Windows message loop
2725 // or a MoviesTask or both and then check the movie load state
2726 // it would still return 1000 (loading)... even (pre)prerolling doesn't
2727 // help. However, making a load timer like this works
2728 //---------------------------------------------------------------------------
2729 class wxQTLoadTimer
: public wxTimer
2732 wxQTLoadTimer(Movie movie
, wxQTMediaBackend
* parent
, wxQuickTimeLibrary
* pLib
) :
2733 m_movie(movie
), m_parent(parent
), m_pLib(pLib
) {}
2737 m_pLib
->MoviesTask(m_movie
, 0);
2738 //kMovieLoadStatePlayable
2739 if(m_pLib
->GetMovieLoadState(m_movie
) >= 10000)
2741 m_parent
->FinishLoad();
2747 Movie m_movie
; //Our movie instance
2748 wxQTMediaBackend
* m_parent
; //Backend pointer
2749 wxQuickTimeLibrary
* m_pLib
; //Interfaces
2753 // --------------------------------------------------------------------------
2754 // wxQTPlayTimer - Handle Asyncronous Playing
2756 // 1) Checks to see if the movie is done, and if not continues
2757 // streaming the movie
2758 // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
2760 // --------------------------------------------------------------------------
2761 class wxQTPlayTimer
: public wxTimer
2764 wxQTPlayTimer(Movie movie
, wxQTMediaBackend
* parent
,
2765 wxQuickTimeLibrary
* pLib
) :
2766 m_movie(movie
), m_parent(parent
), m_pLib(pLib
) {}
2771 // OK, a little explaining - basically originally
2772 // we only called MoviesTask if the movie was actually
2773 // playing (not paused or stopped)... this was before
2774 // we realized MoviesTask actually handles repainting
2775 // of the current frame - so if you were to resize
2776 // or something it would previously not redraw that
2777 // portion of the movie.
2779 // So now we call MoviesTask always so that it repaints
2782 m_pLib
->MoviesTask(m_movie
, 0);
2785 // Handle the stop event - if the movie has reached
2786 // the end, notify our handler
2788 // m_bPlaying == !(Stopped | Paused)
2790 if (m_parent
->m_bPlaying
)
2792 if(m_pLib
->IsMovieDone(m_movie
))
2794 if ( m_parent
->SendStopEvent() )
2797 wxASSERT(m_pLib
->GetMoviesError() == noErr
);
2799 m_parent
->QueueFinishEvent();
2806 Movie m_movie
; //Our movie instance
2807 wxQTMediaBackend
* m_parent
; //Backend pointer
2808 wxQuickTimeLibrary
* m_pLib
; //Interfaces
2812 //---------------------------------------------------------------------------
2813 // wxQTMediaBackend::QTWndProc
2815 // Forwards events to the Movie Controller so that it can
2816 // redraw itself/process messages etc..
2817 //---------------------------------------------------------------------------
2818 LRESULT CALLBACK
wxQTMediaBackend::QTWndProc(HWND hWnd
, UINT nMsg
,
2819 WPARAM wParam
, LPARAM lParam
)
2821 wxQTMediaBackend
* pThis
= (wxQTMediaBackend
*)wxGetWindowUserData(hWnd
);
2826 msg
.wParam
= wParam
;
2827 msg
.lParam
= lParam
;
2831 EventRecord theEvent
;
2832 pThis
->m_lib
.NativeEventToMacEvent(&msg
, &theEvent
);
2833 pThis
->m_lib
.MCIsPlayerEvent(pThis
->m_pMC
, &theEvent
);
2834 return pThis
->m_ctrl
->MSWWindowProc(nMsg
, wParam
, lParam
);
2837 //---------------------------------------------------------------------------
2838 // wxQTMediaBackend Destructor
2840 // Sets m_timer to NULL signifying we havn't loaded anything yet
2841 //---------------------------------------------------------------------------
2842 wxQTMediaBackend::wxQTMediaBackend()
2843 : m_movie(NULL
), m_bPlaying(false), m_timer(NULL
), m_pMC(NULL
)
2847 //---------------------------------------------------------------------------
2848 // wxQTMediaBackend Destructor
2850 // 1) Cleans up the QuickTime movie instance
2851 // 2) Decrements the QuickTime reference counter - if this reaches
2852 // 0, QuickTime shuts down
2853 // 3) Decrements the QuickTime Windows Media Layer reference counter -
2854 // if this reaches 0, QuickTime shuts down the Windows Media Layer
2855 //---------------------------------------------------------------------------
2856 wxQTMediaBackend::~wxQTMediaBackend()
2865 m_lib
.DisposeMovieController(m_pMC
);
2869 // destroy wxQTMediaEvtHandler we pushed on it
2870 m_ctrl
->PopEventHandler(true);
2872 m_lib
.DestroyPortAssociation(
2873 (CGrafPtr
)m_lib
.GetNativeWindowPort(m_ctrl
->GetHWND()));
2875 //Note that ExitMovies() is not necessary, but
2876 //the docs are fuzzy on whether or not TerminateQTML is
2878 m_lib
.TerminateQTML();
2882 //---------------------------------------------------------------------------
2883 // wxQTMediaBackend::CreateControl
2885 // 1) Intializes QuickTime
2886 // 2) Creates the control window
2887 //---------------------------------------------------------------------------
2888 bool wxQTMediaBackend::CreateControl(wxControl
* ctrl
, wxWindow
* parent
,
2893 const wxValidator
& validator
,
2894 const wxString
& name
)
2896 if(!m_lib
.Initialize())
2899 int nError
= m_lib
.InitializeQTML(0);
2900 if (nError
!= noErr
) //-2093 no dll
2902 wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"),
2906 m_lib
.EnterMovies();
2910 // By default wxWindow(s) is created with a border -
2911 // so we need to get rid of those
2913 // Since we don't have a child window like most other
2914 // backends, we don't need wxCLIP_CHILDREN
2916 if ( !ctrl
->wxControl::Create(parent
, id
, pos
, size
,
2917 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
,
2922 m_ctrl
= wxStaticCast(ctrl
, wxMediaCtrl
);
2924 // Create a port association for our window so we
2925 // can use it as a WindowRef
2926 m_lib
.CreatePortAssociation(m_ctrl
->GetHWND(), NULL
, 0L);
2928 //Part of a suggestion from Greg Hazel to repaint
2930 m_ctrl
->PushEventHandler(new wxQTMediaEvtHandler(this, m_ctrl
->GetHWND()));
2936 //---------------------------------------------------------------------------
2937 // wxQTMediaBackend::Load (file version)
2939 // 1) Get an FSSpec from the Windows path name
2940 // 2) Open the movie
2941 // 3) Obtain the movie instance from the movie resource
2942 // 4) Close the movie resource
2943 // 5) Finish loading
2944 //---------------------------------------------------------------------------
2945 bool wxQTMediaBackend::Load(const wxString
& fileName
)
2950 short movieResFile
= 0; //= 0 because of annoying VC6 warning
2953 if (m_lib
.NativePathNameToFSSpec ((char*) (const char*) fileName
.mb_str(),
2954 &sfFile
, 0) != noErr
)
2957 if (m_lib
.OpenMovieFile (&sfFile
, &movieResFile
, fsRdPerm
) != noErr
)
2960 short movieResID
= 0;
2963 OSErr err
= m_lib
.NewMovieFromFile (
2972 //m_lib.GetMoviesStickyError() because it may not find the
2973 //proper codec and play black video and other strange effects,
2974 //not to mention mess up the dynamic backend loading scheme
2975 //of wxMediaCtrl - so it just does what the QuickTime player does
2976 if(err
== noErr
&& m_lib
.GetMoviesStickyError() == noErr
)
2978 m_lib
.CloseMovieFile (movieResFile
);
2988 //---------------------------------------------------------------------------
2989 // wxQTMediaBackend::PPRMProc (static)
2991 // Called when done PrePrerolling the movie.
2992 // Note that in 99% of the cases this does nothing...
2993 // Anyway we set up the loading timer here to tell us when the movie is done
2994 //---------------------------------------------------------------------------
2995 void wxQTMediaBackend::PPRMProc (Movie theMovie
,
2996 OSErr
WXUNUSED_UNLESS_DEBUG(theErr
),
2999 wxASSERT( theMovie
);
3000 wxASSERT( theRefCon
);
3001 wxASSERT( theErr
== noErr
);
3003 wxQTMediaBackend
* pBE
= (wxQTMediaBackend
*) theRefCon
;
3005 long lTime
= pBE
->m_lib
.GetMovieTime(theMovie
,NULL
);
3006 Fixed rate
= pBE
->m_lib
.GetMoviePreferredRate(theMovie
);
3007 pBE
->m_lib
.PrerollMovie(theMovie
,lTime
,rate
);
3008 pBE
->m_timer
= new wxQTLoadTimer(pBE
->m_movie
, pBE
, &pBE
->m_lib
);
3009 pBE
->m_timer
->Start(MOVIE_DELAY
);
3013 //---------------------------------------------------------------------------
3014 // wxQTMediaBackend::Load (URL Version)
3016 // 1) Build an escaped URI from location
3017 // 2) Create a handle to store the URI string
3018 // 3) Put the URI string inside the handle
3019 // 4) Make a QuickTime URL data ref from the handle with the URI in it
3020 // 5) Clean up the URI string handle
3021 // 6) Do some prerolling
3022 // 7) Finish Loading
3023 //---------------------------------------------------------------------------
3024 bool wxQTMediaBackend::Load(const wxURI
& location
)
3029 wxString theURI
= location
.BuildURI();
3031 Handle theHandle
= m_lib
.NewHandleClear(theURI
.length() + 1);
3032 wxASSERT(theHandle
);
3034 m_lib
.BlockMove(theURI
.mb_str(), *theHandle
, theURI
.length() + 1);
3036 //create the movie from the handle that refers to the URI
3037 OSErr err
= m_lib
.NewMovieFromDataRef(&m_movie
, newMovieActive
|
3039 /*|newMovieIdleImportOK*/,
3041 URLDataHandlerSubType
);
3043 m_lib
.DisposeHandle(theHandle
);
3050 timeNow
= m_lib
.GetMovieTime(m_movie
, NULL
);
3051 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3053 playRate
= m_lib
.GetMoviePreferredRate(m_movie
);
3054 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3057 // Note that the callback here is optional,
3058 // but without it PrePrerollMovie can be buggy
3059 // (see Apple ml). Also, some may wonder
3060 // why we need this at all - this is because
3061 // Apple docs say QuickTime streamed movies
3062 // require it if you don't use a Movie Controller,
3063 // which we don't by default.
3065 m_lib
.PrePrerollMovie(m_movie
, timeNow
, playRate
,
3066 (WXFARPROC
)wxQTMediaBackend::PPRMProc
,
3075 //---------------------------------------------------------------------------
3076 // wxQTMediaBackend::FinishLoad
3078 // 1) Create the movie timer
3079 // 2) Get real size of movie for GetBestSize/sizers
3080 // 3) Set the movie time scale to something usable so that seeking
3081 // etc. will work correctly
3082 // 4) Set our Movie Controller to display the movie if it exists,
3083 // otherwise set the bounds of the Movie
3084 // 5) Refresh parent window
3085 //---------------------------------------------------------------------------
3086 void wxQTMediaBackend::FinishLoad()
3088 // Create the playing/streaming timer
3089 m_timer
= new wxQTPlayTimer(m_movie
, (wxQTMediaBackend
*) this, &m_lib
);
3091 m_timer
->Start(MOVIE_DELAY
, wxTIMER_CONTINUOUS
);
3093 //get the real size of the movie
3095 memset(&outRect
, 0, sizeof(Rect
)); //for annoying VC6 warning
3096 m_lib
.GetMovieNaturalBoundsRect (m_movie
, &outRect
);
3097 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3099 m_bestSize
.x
= outRect
.right
- outRect
.left
;
3100 m_bestSize
.y
= outRect
.bottom
- outRect
.top
;
3103 // Handle the movie GWorld
3108 thePoint
.h
= thePoint
.v
= 0;
3109 m_lib
.MCSetMovie(m_pMC
, m_movie
,
3110 m_lib
.GetNativeWindowPort(m_ctrl
->GetHandle()),
3112 m_lib
.MCSetVisible(m_pMC
, true);
3117 m_lib
.SetMovieGWorld(m_movie
,
3118 (CGrafPtr
) m_lib
.GetNativeWindowPort(m_ctrl
->GetHWND()),
3123 // Set the movie to millisecond precision
3125 m_lib
.SetMovieTimeScale(m_movie
, 1000);
3126 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3128 NotifyMovieLoaded();
3131 //---------------------------------------------------------------------------
3132 // wxQTMediaBackend::Play
3134 // 1) Start the QT movie
3135 // 2) Start the movie loading timer
3137 // NOTE: This will still return success even when
3138 // the movie is still loading, and as mentioned in wxQTLoadTimer
3139 // I don't know of a way to force this to be sync - so if its
3140 // still loading the function will return true but the movie will
3141 // still be in the stopped state
3142 //---------------------------------------------------------------------------
3143 bool wxQTMediaBackend::Play()
3145 m_lib
.StartMovie(m_movie
);
3147 return m_lib
.GetMoviesError() == noErr
;
3150 //---------------------------------------------------------------------------
3151 // wxQTMediaBackend::Pause
3153 // 1) Stop the movie
3154 // 2) Stop the movie timer
3155 //---------------------------------------------------------------------------
3156 bool wxQTMediaBackend::Pause()
3159 m_lib
.StopMovie(m_movie
);
3160 return m_lib
.GetMoviesError() == noErr
;
3163 //---------------------------------------------------------------------------
3164 // wxQTMediaBackend::Stop
3166 // 1) Stop the movie
3167 // 2) Stop the movie timer
3168 // 3) Seek to the beginning of the movie
3169 //---------------------------------------------------------------------------
3170 bool wxQTMediaBackend::Stop()
3174 m_lib
.StopMovie(m_movie
);
3175 if(m_lib
.GetMoviesError() != noErr
)
3178 m_lib
.GoToBeginningOfMovie(m_movie
);
3179 return m_lib
.GetMoviesError() == noErr
;
3182 //---------------------------------------------------------------------------
3183 // wxQTMediaBackend::GetPlaybackRate
3185 // 1) Get the movie playback rate from ::GetMovieRate
3186 //---------------------------------------------------------------------------
3187 double wxQTMediaBackend::GetPlaybackRate()
3189 return ( ((double)m_lib
.GetMovieRate(m_movie
)) / 0x10000);
3192 //---------------------------------------------------------------------------
3193 // wxQTMediaBackend::SetPlaybackRate
3195 // 1) Convert dRate to Fixed and Set the movie rate through SetMovieRate
3196 //---------------------------------------------------------------------------
3197 bool wxQTMediaBackend::SetPlaybackRate(double dRate
)
3199 m_lib
.SetMovieRate(m_movie
, (Fixed
) (dRate
* 0x10000));
3200 return m_lib
.GetMoviesError() == noErr
;
3203 //---------------------------------------------------------------------------
3204 // wxQTMediaBackend::SetPosition
3206 // 1) Create a time record struct (TimeRecord) with appropriate values
3207 // 2) Pass struct to SetMovieTime
3208 //---------------------------------------------------------------------------
3209 bool wxQTMediaBackend::SetPosition(wxLongLong where
)
3211 //NB: For some reason SetMovieTime does not work
3212 //correctly with the Quicktime Windows SDK (6)
3213 //From Muskelkatermann at the wxForum
3214 //http://www.solidsteel.nl/users/wxwidgets/viewtopic.php?t=2957
3215 //RN - note that I have not verified this but there
3216 //is no harm in calling SetMovieTimeValue instead
3218 TimeRecord theTimeRecord
;
3219 memset(&theTimeRecord
, 0, sizeof(TimeRecord
));
3220 theTimeRecord
.value
.lo
= where
.GetLo();
3221 theTimeRecord
.scale
= m_lib
.GetMovieTimeScale(m_movie
);
3222 theTimeRecord
.base
= m_lib
.GetMovieTimeBase(m_movie
);
3223 m_lib
.SetMovieTime(m_movie
, &theTimeRecord
);
3225 m_lib
.SetMovieTimeValue(m_movie
, where
.GetLo());
3227 if (m_lib
.GetMoviesError() != noErr
)
3233 //---------------------------------------------------------------------------
3234 // wxQTMediaBackend::GetPosition
3236 // 1) Calls GetMovieTime to get the position we are in in the movie
3237 // in milliseconds (we called
3238 //---------------------------------------------------------------------------
3239 wxLongLong
wxQTMediaBackend::GetPosition()
3241 return m_lib
.GetMovieTime(m_movie
, NULL
);
3244 //---------------------------------------------------------------------------
3245 // wxQTMediaBackend::GetVolume
3247 // Gets the volume through GetMovieVolume - which returns a 16 bit short -
3249 // +--------+--------+
3251 // +--------+--------+
3253 // (1) first 8 bits are value before decimal
3254 // (2) second 8 bits are value after decimal
3256 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
3257 // 1 (full gain and sound)
3258 //---------------------------------------------------------------------------
3259 double wxQTMediaBackend::GetVolume()
3261 short sVolume
= m_lib
.GetMovieVolume(m_movie
);
3262 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3264 if(sVolume
& (128 << 8)) //negative - no sound
3267 return sVolume
/256.0;
3270 //---------------------------------------------------------------------------
3271 // wxQTMediaBackend::SetVolume
3273 // Sets the volume through SetMovieVolume - which takes a 16 bit short -
3275 // +--------+--------+
3277 // +--------+--------+
3279 // (1) first 8 bits are value before decimal
3280 // (2) second 8 bits are value after decimal
3282 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
3283 // 1 (full gain and sound)
3284 //---------------------------------------------------------------------------
3285 bool wxQTMediaBackend::SetVolume(double dVolume
)
3287 m_lib
.SetMovieVolume(m_movie
, (short) (dVolume
* 256));
3288 return m_lib
.GetMoviesError() == noErr
;
3291 //---------------------------------------------------------------------------
3292 // wxQTMediaBackend::GetDuration
3294 // Calls GetMovieDuration
3295 //---------------------------------------------------------------------------
3296 wxLongLong
wxQTMediaBackend::GetDuration()
3298 return m_lib
.GetMovieDuration(m_movie
);
3301 //---------------------------------------------------------------------------
3302 // wxQTMediaBackend::GetState
3304 // Determines the current state - if we are at the beginning we
3306 //---------------------------------------------------------------------------
3307 wxMediaState
wxQTMediaBackend::GetState()
3309 if (m_bPlaying
== true)
3310 return wxMEDIASTATE_PLAYING
;
3311 else if ( !m_movie
|| wxQTMediaBackend::GetPosition() == 0)
3312 return wxMEDIASTATE_STOPPED
;
3314 return wxMEDIASTATE_PAUSED
;
3317 //---------------------------------------------------------------------------
3318 // wxQTMediaBackend::Cleanup
3320 // Diposes of the movie timer, Disassociates the Movie Controller with
3321 // movie and hides it if it exists, and stops and disposes
3323 //---------------------------------------------------------------------------
3324 void wxQTMediaBackend::Cleanup()
3334 m_lib
.StopMovie(m_movie
);
3339 thePoint
.h
= thePoint
.v
= 0;
3340 m_lib
.MCSetVisible(m_pMC
, false);
3341 m_lib
.MCSetMovie(m_pMC
, NULL
, NULL
, thePoint
);
3344 m_lib
.DisposeMovie(m_movie
);
3348 //---------------------------------------------------------------------------
3349 // wxQTMediaBackend::ShowPlayerControls
3351 // Creates a movie controller for the Movie if the user wants it
3352 //---------------------------------------------------------------------------
3353 bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags
)
3357 //restore old wndproc
3358 wxSetWindowProc((HWND
)m_ctrl
->GetHWND(), wxWndProc
);
3359 m_lib
.DisposeMovieController(m_pMC
);
3361 m_bestSize
.y
-= 16; //movie controller height
3364 if(flags
&& m_movie
)
3367 wxRect wxrect
= m_ctrl
->GetClientRect();
3369 //make room for controller
3370 if(wxrect
.width
< 320)
3373 rect
.top
= (short)wxrect
.y
;
3374 rect
.left
= (short)wxrect
.x
;
3375 rect
.right
= (short)(rect
.left
+ wxrect
.width
);
3376 rect
.bottom
= (short)(rect
.top
+ wxrect
.height
);
3380 m_pMC
= m_lib
.NewMovieController(m_movie
, &rect
, mcTopLeftMovie
|
3381 // mcScaleMovieToFit |
3384 m_lib
.MCDoAction(m_pMC
, 32, (void*)true); //mcActionSetKeysEnabled
3385 m_lib
.MCSetActionFilterWithRefCon(m_pMC
,
3386 (WXFARPROC
)wxQTMediaBackend::MCFilterProc
, (void*)this);
3387 m_bestSize
.y
+= 16; //movie controller height
3390 // By default the movie controller uses its own color
3391 // pallette for the movie which can be bad on some files -
3392 // so turn it off. Also turn off its frame/border for
3395 // Also we take care of a couple of the interface flags here
3398 m_lib
.MCDoAction(m_pMC
, 39/*mcActionGetFlags*/, (void*)&mcFlags
);
3399 mcFlags
|= ( //(1<<0)/*mcFlagSuppressMovieFrame*/ |
3400 (1<<3)/*mcFlagsUseWindowPalette*/
3401 | ((flags
& wxMEDIACTRLPLAYERCONTROLS_STEP
)
3402 ? 0 : (1<<1)/*mcFlagSuppressStepButtons*/)
3403 | ((flags
& wxMEDIACTRLPLAYERCONTROLS_VOLUME
)
3404 ? 0 : (1<<2)/*mcFlagSuppressSpeakerButton*/)
3405 // | (1<<4) /*mcFlagDontInvalidate*/ //if we take care of repainting ourselves
3407 m_lib
.MCDoAction(m_pMC
, 38/*mcActionSetFlags*/, (void*)mcFlags
);
3409 //intercept the wndproc of our control window
3410 wxSetWindowProc((HWND
)m_ctrl
->GetHWND(),
3411 wxQTMediaBackend::QTWndProc
);
3413 //set the user data of our window
3414 wxSetWindowUserData((HWND
)m_ctrl
->GetHWND(), this);
3418 NotifyMovieSizeChanged();
3420 return m_lib
.GetMoviesError() == noErr
;
3423 //---------------------------------------------------------------------------
3424 // wxQTMediaBackend::MCFilterProc (static)
3426 // Callback for when the movie controller recieves a message
3427 //---------------------------------------------------------------------------
3429 wxQTMediaBackend::MCFilterProc(MovieController
WXUNUSED(theController
),
3431 void * WXUNUSED(params
),
3434 if(action
!= 1) //don't process idle events
3436 wxQTMediaBackend
* pThis
= (wxQTMediaBackend
*)refCon
;
3440 case 8: //play button triggered - MC will set movie to opposite state
3441 //of current - playing ? paused : playing
3442 pThis
->m_bPlaying
= !(pThis
->m_bPlaying
);
3444 // NB: Sometimes it doesn't redraw properly -
3445 // if you click on the button but don't move the mouse
3446 // the button will not change its state until you move
3447 // mcActionDraw and Refresh/Update combo do nothing
3448 // to help this unfortunately
3457 //---------------------------------------------------------------------------
3458 // wxQTMediaBackend::GetVideoSize
3460 // Returns the actual size of the QT movie
3461 //---------------------------------------------------------------------------
3462 wxSize
wxQTMediaBackend::GetVideoSize() const
3467 //---------------------------------------------------------------------------
3468 // wxQTMediaBackend::Move
3470 // Sets the bounds of either the Movie or Movie Controller
3471 //---------------------------------------------------------------------------
3472 void wxQTMediaBackend::Move(int WXUNUSED(x
), int WXUNUSED(y
), int w
, int h
)
3476 //make room for controller
3482 Rect theRect
= {0, 0, (short)h
, (short)w
};
3483 m_lib
.MCSetControllerBoundsRect(m_pMC
, &theRect
);
3487 Rect theRect
= {0, 0, (short)h
, (short)w
};
3488 m_lib
.SetMovieBox(m_movie
, &theRect
);
3491 wxASSERT(m_lib
.GetMoviesError() == noErr
);
3495 //---------------------------------------------------------------------------
3496 // wxQTMediaBackend::OnEraseBackground
3498 // Suggestion from Greg Hazel to repaint the movie when idle
3501 // TODO: We may be repainting too much here - under what exact circumstances
3502 // do we need this? I think Move also repaints correctly for the Movie
3503 // Controller, so in that instance we don't need this either
3504 //---------------------------------------------------------------------------
3505 void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent
& evt
)
3507 wxQuickTimeLibrary
& m_pLib
= m_qtb
->m_lib
;
3511 // repaint movie controller
3512 m_pLib
.MCDoAction(m_qtb
->m_pMC
, 2 /*mcActionDraw*/,
3513 m_pLib
.GetNativeWindowPort(m_hwnd
));
3515 else // no movie controller
3517 if ( m_qtb
->m_movie
)
3519 CGrafPtr port
= (CGrafPtr
)m_pLib
.GetNativeWindowPort(m_hwnd
);
3521 m_pLib
.BeginUpdate(port
);
3522 m_pLib
.UpdateMovie(m_qtb
->m_movie
);
3523 wxASSERT(m_pLib
.GetMoviesError() == noErr
);
3524 m_pLib
.EndUpdate(port
);
3528 // let the system repaint the window
3534 //---------------------------------------------------------------------------
3536 //---------------------------------------------------------------------------
3538 //in source file that contains stuff you don't directly use
3539 #include <wx/html/forcelnk.h>
3540 FORCE_LINK_ME(basewxmediabackends
);
3542 //---------------------------------------------------------------------------
3543 // End wxMediaCtrl Compilation Guard and this file
3544 //---------------------------------------------------------------------------
3545 #endif //wxUSE_MEDIACTRL
projects / wxWidgets.git / blob