]> git.saurik.com Git - wxWidgets.git/blob - src/msw/mediactrl.cpp
projects / wxWidgets.git / blob
? search:


2144d317d1b657c00d0cf1d35be9f7022ba5e90d
[wxWidgets.git] / src / msw / mediactrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/mediactrl.cpp
3 // Purpose: Built-in Media Backends for Windows
4 // Author: Ryan Norton <wxprojects@comcast.net>
5 // Modified by:
6 // Created: 11/07/04
7 // RCS-ID: $Id$
8 // Copyright: (c) Ryan Norton
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 //===========================================================================
13 // DECLARATIONS
14 //===========================================================================
15
16 //---------------------------------------------------------------------------
17 // Pre-compiled header stuff
18 //---------------------------------------------------------------------------
19
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "mediactrl.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30 #define wxUSE_DIRECTSHOW 0
31 #define wxUSE_QUICKTIME 0
32
33 //---------------------------------------------------------------------------
34 // Includes
35 //---------------------------------------------------------------------------
36 #include "wx/mediactrl.h"
37
38 //---------------------------------------------------------------------------
39 // Compilation guard
40 //---------------------------------------------------------------------------
41 #if wxUSE_MEDIACTRL
42
43 //---------------------------------------------------------------------------
44 // Externals (somewhere in src/msw/app.cpp)
45 //---------------------------------------------------------------------------
46 extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
47 #ifdef __WXWINCE__
48 extern WXDLLIMPEXP_CORE wxChar *wxCanvasClassName;
49 #else
50 extern WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName;
51 #endif
52
53 //===========================================================================
54 // BACKEND DECLARATIONS
55 //===========================================================================
56
57 //---------------------------------------------------------------------------
58 //
59 // wxAMMediaBackend
60 //
61 //---------------------------------------------------------------------------
62
63 //---------------------------------------------------------------------------
64 // Compilation guard for DirectShow
65 //---------------------------------------------------------------------------
66 #if wxUSE_DIRECTSHOW
67
68 //---------------------------------------------------------------------------
69 // COM includes
70 //---------------------------------------------------------------------------
71 #include "wx/msw/ole/oleutils.h" //wxBasicString, IID etc.
72 #include "wx/msw/ole/uuid.h" //IID etc..
73
74 //---------------------------------------------------------------------------
75 // IIDS - used by CoCreateInstance and IUnknown::QueryInterface
76 //---------------------------------------------------------------------------
77 const IID LIBID_QuartzTypeLib = {0x56A868B0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
78 const IID IID_IAMCollection = {0x56A868B9,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
79 const IID IID_IMediaControl = {0x56A868B1,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
80 const IID IID_IMediaEvent = {0x56A868B6,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
81 const IID IID_IMediaEventEx = {0x56A868C0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
82 const IID IID_IMediaPosition = {0x56A868B2,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
83 const IID IID_IBasicAudio = {0x56A868B3,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
84 const IID IID_IVideoWindow = {0x56A868B4,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
85 const IID IID_IBasicVideo = {0x56A868B5,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
86 const IID IID_IBasicVideo2 = {0x329BB360,0xF6EA,0x11D1,{0x90,0x38,0x00,0xA0,0xC9,0x69,0x72,0x98}};
87 const IID IID_IDeferredCommand = {0x56A868B8,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
88 const IID IID_IQueueCommand = {0x56A868B7,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
89 const IID IID_IFilterInfo = {0x56A868BA,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
90 const IID IID_IRegFilterInfo = {0x56A868BB,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
91 const IID IID_IMediaTypeInfo = {0x56A868BC,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
92 const IID IID_IPinInfo = {0x56A868BD,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
93 const IID IID_IAMStats = {0xBC9BCF80,0xDCD2,0x11D2,{0xAB,0xF6,0x00,0xA0,0xC9,0x05,0xF3,0x75}};
94
95 //TODO: These 4 lines needed?
96 #ifndef CLSID_DEFINED
97 #define CLSID_DEFINED
98 typedef IID CLSID;
99 #endif // CLSID_DEFINED
100
101 //COM Class Factory
102 const CLSID CLSID_FilgraphManager = {0xE436EBB3,0x524F,0x11CE,{0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
103
104 //---------------------------------------------------------------------------
105 // COM INTERFACES (dumped from midl from quartz.idl from MSVC COM Browser)
106 //---------------------------------------------------------------------------
107 MIDL_INTERFACE("56A868B9-0AD4-11CE-B03A-0020AF0BA770")
108 IAMCollection : public IDispatch
109 {
110 public:
111 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Count(
112 /* [retval][out] */ long __RPC_FAR *plCount) = 0;
113
114 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Item(
115 /* [in] */ long lItem,
116 /* [out] */ IUnknown __RPC_FAR *__RPC_FAR *ppUnk) = 0;
117
118 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get__NewEnum(
119 /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppUnk) = 0;
120
121 };
122
123 MIDL_INTERFACE("56A868B1-0AD4-11CE-B03A-0020AF0BA770")
124 IMediaControl : public IDispatch
125 {
126 public:
127 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Run( void) = 0;
128
129 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Pause( void) = 0;
130
131 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Stop( void) = 0;
132
133 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetState(
134 /* [in] */ long msTimeout,
135 /* [out] */ long __RPC_FAR *pfs) = 0;
136
137 virtual /* [id] */ HRESULT STDMETHODCALLTYPE RenderFile(
138 /* [in] */ BSTR strFilename) = 0;
139
140 virtual /* [id] */ HRESULT STDMETHODCALLTYPE AddSourceFilter(
141 /* [in] */ BSTR strFilename,
142 /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
143
144 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_FilterCollection(
145 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
146
147 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RegFilterCollection(
148 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
149
150 virtual /* [id] */ HRESULT STDMETHODCALLTYPE StopWhenReady( void) = 0;
151
152 };
153
154 MIDL_INTERFACE("56A868B6-0AD4-11CE-B03A-0020AF0BA770")
155 IMediaEvent : public IDispatch
156 {
157 public:
158 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetEventHandle(
159 /* [out] */ LONG_PTR __RPC_FAR *hEvent) = 0;
160
161 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetEvent(
162 /* [out] */ long __RPC_FAR *lEventCode,
163 /* [out] */ LONG_PTR __RPC_FAR *lParam1,
164 /* [out] */ LONG_PTR __RPC_FAR *lParam2,
165 /* [in] */ long msTimeout) = 0;
166
167 virtual /* [id] */ HRESULT STDMETHODCALLTYPE WaitForCompletion(
168 /* [in] */ long msTimeout,
169 /* [out] */ long __RPC_FAR *pEvCode) = 0;
170
171 virtual /* [id] */ HRESULT STDMETHODCALLTYPE CancelDefaultHandling(
172 /* [in] */ long lEvCode) = 0;
173
174 virtual /* [id] */ HRESULT STDMETHODCALLTYPE RestoreDefaultHandling(
175 /* [in] */ long lEvCode) = 0;
176
177 virtual /* [id] */ HRESULT STDMETHODCALLTYPE FreeEventParams(
178 /* [in] */ long lEvCode,
179 /* [in] */ LONG_PTR lParam1,
180 /* [in] */ LONG_PTR lParam2) = 0;
181
182 };
183
184 MIDL_INTERFACE("56A868C0-0AD4-11CE-B03A-0020AF0BA770")
185 IMediaEventEx : public IMediaEvent
186 {
187 public:
188 virtual HRESULT __stdcall SetNotifyWindow(
189 /* [in] */ LONG_PTR hwnd,
190 /* [in] */ long lMsg,
191 /* [in] */ LONG_PTR lInstanceData) = 0;
192
193 virtual HRESULT __stdcall SetNotifyFlags(
194 /* [in] */ long lNoNotifyFlags) = 0;
195
196 virtual HRESULT __stdcall GetNotifyFlags(
197 /* [out] */ long __RPC_FAR *lplNoNotifyFlags) = 0;
198
199 };
200
201 MIDL_INTERFACE("56A868B2-0AD4-11CE-B03A-0020AF0BA770")
202 IMediaPosition : public IDispatch
203 {
204 public:
205 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Duration(
206 /* [retval][out] */ double __RPC_FAR *plength) = 0;
207
208 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_CurrentPosition(
209 /* [in] */ double pllTime) = 0;
210
211 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CurrentPosition(
212 /* [retval][out] */ double __RPC_FAR *pllTime) = 0;
213
214 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_StopTime(
215 /* [retval][out] */ double __RPC_FAR *pllTime) = 0;
216
217 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_StopTime(
218 /* [in] */ double pllTime) = 0;
219
220 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_PrerollTime(
221 /* [retval][out] */ double __RPC_FAR *pllTime) = 0;
222
223 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_PrerollTime(
224 /* [in] */ double pllTime) = 0;
225
226 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Rate(
227 /* [in] */ double pdRate) = 0;
228
229 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Rate(
230 /* [retval][out] */ double __RPC_FAR *pdRate) = 0;
231
232 virtual /* [id] */ HRESULT STDMETHODCALLTYPE CanSeekForward(
233 /* [retval][out] */ long __RPC_FAR *pCanSeekForward) = 0;
234
235 virtual /* [id] */ HRESULT STDMETHODCALLTYPE CanSeekBackward(
236 /* [retval][out] */ long __RPC_FAR *pCanSeekBackward) = 0;
237
238 };
239
240 MIDL_INTERFACE("56A868B3-0AD4-11CE-B03A-0020AF0BA770")
241 IBasicAudio : public IDispatch
242 {
243 public:
244 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Volume(
245 /* [in] */ long plVolume) = 0;
246
247 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Volume(
248 /* [retval][out] */ long __RPC_FAR *plVolume) = 0;
249
250 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Balance(
251 /* [in] */ long plBalance) = 0;
252
253 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Balance(
254 /* [retval][out] */ long __RPC_FAR *plBalance) = 0;
255
256 };
257
258 MIDL_INTERFACE("56A868B4-0AD4-11CE-B03A-0020AF0BA770")
259 IVideoWindow : public IDispatch
260 {
261 public:
262 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Caption(
263 /* [in] */ BSTR strCaption) = 0;
264
265 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Caption(
266 /* [retval][out] */ BSTR __RPC_FAR *strCaption) = 0;
267
268 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_WindowStyle(
269 /* [in] */ long WindowStyle) = 0;
270
271 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_WindowStyle(
272 /* [retval][out] */ long __RPC_FAR *WindowStyle) = 0;
273
274 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_WindowStyleEx(
275 /* [in] */ long WindowStyleEx) = 0;
276
277 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_WindowStyleEx(
278 /* [retval][out] */ long __RPC_FAR *WindowStyleEx) = 0;
279
280 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_AutoShow(
281 /* [in] */ long AutoShow) = 0;
282
283 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AutoShow(
284 /* [retval][out] */ long __RPC_FAR *AutoShow) = 0;
285
286 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_WindowState(
287 /* [in] */ long WindowState) = 0;
288
289 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_WindowState(
290 /* [retval][out] */ long __RPC_FAR *WindowState) = 0;
291
292 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BackgroundPalette(
293 /* [in] */ long pBackgroundPalette) = 0;
294
295 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BackgroundPalette(
296 /* [retval][out] */ long __RPC_FAR *pBackgroundPalette) = 0;
297
298 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Visible(
299 /* [in] */ long pVisible) = 0;
300
301 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Visible(
302 /* [retval][out] */ long __RPC_FAR *pVisible) = 0;
303
304 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Left(
305 /* [in] */ long pLeft) = 0;
306
307 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Left(
308 /* [retval][out] */ long __RPC_FAR *pLeft) = 0;
309
310 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Width(
311 /* [in] */ long pWidth) = 0;
312
313 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Width(
314 /* [retval][out] */ long __RPC_FAR *pWidth) = 0;
315
316 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Top(
317 /* [in] */ long pTop) = 0;
318
319 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Top(
320 /* [retval][out] */ long __RPC_FAR *pTop) = 0;
321
322 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Height(
323 /* [in] */ long pHeight) = 0;
324
325 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Height(
326 /* [retval][out] */ long __RPC_FAR *pHeight) = 0;
327
328 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Owner(
329 /* [in] */ LONG_PTR Owner) = 0;
330
331 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Owner(
332 /* [retval][out] */ LONG_PTR __RPC_FAR *Owner) = 0;
333
334 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MessageDrain(
335 /* [in] */ LONG_PTR Drain) = 0;
336
337 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MessageDrain(
338 /* [retval][out] */ LONG_PTR __RPC_FAR *Drain) = 0;
339
340 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BorderColor(
341 /* [retval][out] */ long __RPC_FAR *Color) = 0;
342
343 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BorderColor(
344 /* [in] */ long Color) = 0;
345
346 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_FullScreenMode(
347 /* [retval][out] */ long __RPC_FAR *FullScreenMode) = 0;
348
349 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_FullScreenMode(
350 /* [in] */ long FullScreenMode) = 0;
351
352 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetWindowForeground(
353 /* [in] */ long Focus) = 0;
354
355 virtual /* [id] */ HRESULT STDMETHODCALLTYPE NotifyOwnerMessage(
356 /* [in] */ LONG_PTR hwnd,
357 /* [in] */ long uMsg,
358 /* [in] */ LONG_PTR wParam,
359 /* [in] */ LONG_PTR lParam) = 0;
360
361 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetWindowPosition(
362 /* [in] */ long Left,
363 /* [in] */ long Top,
364 /* [in] */ long Width,
365 /* [in] */ long Height) = 0;
366
367 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetWindowPosition(
368 /* [out] */ long __RPC_FAR *pLeft,
369 /* [out] */ long __RPC_FAR *pTop,
370 /* [out] */ long __RPC_FAR *pWidth,
371 /* [out] */ long __RPC_FAR *pHeight) = 0;
372
373 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetMinIdealImageSize(
374 /* [out] */ long __RPC_FAR *pWidth,
375 /* [out] */ long __RPC_FAR *pHeight) = 0;
376
377 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetMaxIdealImageSize(
378 /* [out] */ long __RPC_FAR *pWidth,
379 /* [out] */ long __RPC_FAR *pHeight) = 0;
380
381 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetRestorePosition(
382 /* [out] */ long __RPC_FAR *pLeft,
383 /* [out] */ long __RPC_FAR *pTop,
384 /* [out] */ long __RPC_FAR *pWidth,
385 /* [out] */ long __RPC_FAR *pHeight) = 0;
386
387 virtual /* [id] */ HRESULT STDMETHODCALLTYPE HideCursor(
388 /* [in] */ long HideCursor) = 0;
389
390 virtual /* [id] */ HRESULT STDMETHODCALLTYPE IsCursorHidden(
391 /* [out] */ long __RPC_FAR *CursorHidden) = 0;
392
393 };
394
395 MIDL_INTERFACE("56A868B5-0AD4-11CE-B03A-0020AF0BA770")
396 IBasicVideo : public IDispatch
397 {
398 public:
399 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AvgTimePerFrame(
400 /* [retval][out] */ double __RPC_FAR *pAvgTimePerFrame) = 0;
401
402 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitRate(
403 /* [retval][out] */ long __RPC_FAR *pBitRate) = 0;
404
405 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitErrorRate(
406 /* [retval][out] */ long __RPC_FAR *pBitErrorRate) = 0;
407
408 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_VideoWidth(
409 /* [retval][out] */ long __RPC_FAR *pVideoWidth) = 0;
410
411 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_VideoHeight(
412 /* [retval][out] */ long __RPC_FAR *pVideoHeight) = 0;
413
414 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SourceLeft(
415 /* [in] */ long pSourceLeft) = 0;
416
417 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SourceLeft(
418 /* [retval][out] */ long __RPC_FAR *pSourceLeft) = 0;
419
420 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SourceWidth(
421 /* [in] */ long pSourceWidth) = 0;
422
423 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SourceWidth(
424 /* [retval][out] */ long __RPC_FAR *pSourceWidth) = 0;
425
426 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SourceTop(
427 /* [in] */ long pSourceTop) = 0;
428
429 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SourceTop(
430 /* [retval][out] */ long __RPC_FAR *pSourceTop) = 0;
431
432 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SourceHeight(
433 /* [in] */ long pSourceHeight) = 0;
434
435 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SourceHeight(
436 /* [retval][out] */ long __RPC_FAR *pSourceHeight) = 0;
437
438 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DestinationLeft(
439 /* [in] */ long pDestinationLeft) = 0;
440
441 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DestinationLeft(
442 /* [retval][out] */ long __RPC_FAR *pDestinationLeft) = 0;
443
444 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DestinationWidth(
445 /* [in] */ long pDestinationWidth) = 0;
446
447 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DestinationWidth(
448 /* [retval][out] */ long __RPC_FAR *pDestinationWidth) = 0;
449
450 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DestinationTop(
451 /* [in] */ long pDestinationTop) = 0;
452
453 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DestinationTop(
454 /* [retval][out] */ long __RPC_FAR *pDestinationTop) = 0;
455
456 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DestinationHeight(
457 /* [in] */ long pDestinationHeight) = 0;
458
459 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DestinationHeight(
460 /* [retval][out] */ long __RPC_FAR *pDestinationHeight) = 0;
461
462 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetSourcePosition(
463 /* [in] */ long Left,
464 /* [in] */ long Top,
465 /* [in] */ long Width,
466 /* [in] */ long Height) = 0;
467
468 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetSourcePosition(
469 /* [out] */ long __RPC_FAR *pLeft,
470 /* [out] */ long __RPC_FAR *pTop,
471 /* [out] */ long __RPC_FAR *pWidth,
472 /* [out] */ long __RPC_FAR *pHeight) = 0;
473
474 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetDefaultSourcePosition( void) = 0;
475
476 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetDestinationPosition(
477 /* [in] */ long Left,
478 /* [in] */ long Top,
479 /* [in] */ long Width,
480 /* [in] */ long Height) = 0;
481
482 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetDestinationPosition(
483 /* [out] */ long __RPC_FAR *pLeft,
484 /* [out] */ long __RPC_FAR *pTop,
485 /* [out] */ long __RPC_FAR *pWidth,
486 /* [out] */ long __RPC_FAR *pHeight) = 0;
487
488 virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetDefaultDestinationPosition( void) = 0;
489
490 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetVideoSize(
491 /* [out] */ long __RPC_FAR *pWidth,
492 /* [out] */ long __RPC_FAR *pHeight) = 0;
493
494 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetVideoPaletteEntries(
495 /* [in] */ long StartIndex,
496 /* [in] */ long Entries,
497 /* [out] */ long __RPC_FAR *pRetrieved,
498 /* [out] */ long __RPC_FAR *pPalette) = 0;
499
500 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetCurrentImage(
501 /* [out][in] */ long __RPC_FAR *pBufferSize,
502 /* [out] */ long __RPC_FAR *pDIBImage) = 0;
503
504 virtual /* [id] */ HRESULT STDMETHODCALLTYPE IsUsingDefaultSource( void) = 0;
505
506 virtual /* [id] */ HRESULT STDMETHODCALLTYPE IsUsingDefaultDestination( void) = 0;
507
508 };
509
510 MIDL_INTERFACE("329BB360-F6EA-11D1-9038-00A0C9697298")
511 IBasicVideo2 : public IBasicVideo
512 {
513 public:
514 virtual HRESULT __stdcall GetPreferredAspectRatio(
515 /* [out] */ long __RPC_FAR *plAspectX,
516 /* [out] */ long __RPC_FAR *plAspectY) = 0;
517
518 };
519
520 MIDL_INTERFACE("56A868B8-0AD4-11CE-B03A-0020AF0BA770")
521 IDeferredCommand : public IUnknown
522 {
523 public:
524 virtual HRESULT __stdcall Cancel( void) = 0;
525
526 virtual HRESULT __stdcall Confidence(
527 /* [out] */ long __RPC_FAR *pConfidence) = 0;
528
529 virtual HRESULT __stdcall Postpone(
530 /* [in] */ double newtime) = 0;
531
532 virtual HRESULT __stdcall GetHResult(
533 /* [out] */ HRESULT __RPC_FAR *phrResult) = 0;
534
535 };
536
537 MIDL_INTERFACE("56A868B7-0AD4-11CE-B03A-0020AF0BA770")
538 IQueueCommand : public IUnknown
539 {
540 public:
541 virtual HRESULT __stdcall InvokeAtStreamTime(
542 /* [out] */ IDeferredCommand __RPC_FAR *__RPC_FAR *pCmd,
543 /* [in] */ double time,
544 /* [in] */ GUID __RPC_FAR *iid,
545 /* [in] */ long dispidMethod,
546 /* [in] */ short wFlags,
547 /* [in] */ long cArgs,
548 /* [in] */ VARIANT __RPC_FAR *pDispParams,
549 /* [out][in] */ VARIANT __RPC_FAR *pvarResult,
550 /* [out] */ short __RPC_FAR *puArgErr) = 0;
551
552 virtual HRESULT __stdcall InvokeAtPresentationTime(
553 /* [out] */ IDeferredCommand __RPC_FAR *__RPC_FAR *pCmd,
554 /* [in] */ double time,
555 /* [in] */ GUID __RPC_FAR *iid,
556 /* [in] */ long dispidMethod,
557 /* [in] */ short wFlags,
558 /* [in] */ long cArgs,
559 /* [in] */ VARIANT __RPC_FAR *pDispParams,
560 /* [out][in] */ VARIANT __RPC_FAR *pvarResult,
561 /* [out] */ short __RPC_FAR *puArgErr) = 0;
562
563 };
564
565 MIDL_INTERFACE("56A868BA-0AD4-11CE-B03A-0020AF0BA770")
566 IFilterInfo : public IDispatch
567 {
568 public:
569 virtual /* [id] */ HRESULT STDMETHODCALLTYPE FindPin(
570 /* [in] */ BSTR strPinID,
571 /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
572
573 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Name(
574 /* [retval][out] */ BSTR __RPC_FAR *strName) = 0;
575
576 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_VendorInfo(
577 /* [retval][out] */ BSTR __RPC_FAR *strVendorInfo) = 0;
578
579 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Filter(
580 /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppUnk) = 0;
581
582 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Pins(
583 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
584
585 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_IsFileSource(
586 /* [retval][out] */ long __RPC_FAR *pbIsSource) = 0;
587
588 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Filename(
589 /* [retval][out] */ BSTR __RPC_FAR *pstrFilename) = 0;
590
591 virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Filename(
592 /* [in] */ BSTR pstrFilename) = 0;
593
594 };
595
596 MIDL_INTERFACE("56A868BB-0AD4-11CE-B03A-0020AF0BA770")
597 IRegFilterInfo : public IDispatch
598 {
599 public:
600 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Name(
601 /* [retval][out] */ BSTR __RPC_FAR *strName) = 0;
602
603 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Filter(
604 /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
605
606 };
607
608 MIDL_INTERFACE("56A868BC-0AD4-11CE-B03A-0020AF0BA770")
609 IMediaTypeInfo : public IDispatch
610 {
611 public:
612 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Type(
613 /* [retval][out] */ BSTR __RPC_FAR *strType) = 0;
614
615 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Subtype(
616 /* [retval][out] */ BSTR __RPC_FAR *strType) = 0;
617
618 };
619
620 MIDL_INTERFACE("56A868BD-0AD4-11CE-B03A-0020AF0BA770")
621 IPinInfo : public IDispatch
622 {
623 public:
624 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Pin(
625 /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppUnk) = 0;
626
627 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectedTo(
628 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
629
630 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectionMediaType(
631 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
632
633 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_FilterInfo(
634 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
635
636 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Name(
637 /* [retval][out] */ BSTR __RPC_FAR *ppUnk) = 0;
638
639 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Direction(
640 /* [retval][out] */ long __RPC_FAR *ppDirection) = 0;
641
642 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_PinID(
643 /* [retval][out] */ BSTR __RPC_FAR *strPinID) = 0;
644
645 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MediaTypes(
646 /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppUnk) = 0;
647
648 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Connect(
649 /* [in] */ IUnknown __RPC_FAR *pPin) = 0;
650
651 virtual /* [id] */ HRESULT STDMETHODCALLTYPE ConnectDirect(
652 /* [in] */ IUnknown __RPC_FAR *pPin) = 0;
653
654 virtual /* [id] */ HRESULT STDMETHODCALLTYPE ConnectWithType(
655 /* [in] */ IUnknown __RPC_FAR *pPin,
656 /* [in] */ IDispatch __RPC_FAR *pMediaType) = 0;
657
658 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Disconnect( void) = 0;
659
660 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Render( void) = 0;
661
662 };
663
664 MIDL_INTERFACE("BC9BCF80-DCD2-11D2-ABF6-00A0C905F375")
665 IAMStats : public IDispatch
666 {
667 public:
668 virtual /* [id] */ HRESULT STDMETHODCALLTYPE Reset( void) = 0;
669
670 virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Count(
671 /* [retval][out] */ long __RPC_FAR *plCount) = 0;
672
673 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetValueByIndex(
674 /* [in] */ long lIndex,
675 /* [out] */ BSTR __RPC_FAR *szName,
676 /* [out] */ long __RPC_FAR *lCount,
677 /* [out] */ double __RPC_FAR *dLast,
678 /* [out] */ double __RPC_FAR *dAverage,
679 /* [out] */ double __RPC_FAR *dStdDev,
680 /* [out] */ double __RPC_FAR *dMin,
681 /* [out] */ double __RPC_FAR *dMax) = 0;
682
683 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetValueByName(
684 /* [in] */ BSTR szName,
685 /* [out] */ long __RPC_FAR *lIndex,
686 /* [out] */ long __RPC_FAR *lCount,
687 /* [out] */ double __RPC_FAR *dLast,
688 /* [out] */ double __RPC_FAR *dAverage,
689 /* [out] */ double __RPC_FAR *dStdDev,
690 /* [out] */ double __RPC_FAR *dMin,
691 /* [out] */ double __RPC_FAR *dMax) = 0;
692
693 virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetIndex(
694 /* [in] */ BSTR szName,
695 /* [in] */ long lCreate,
696 /* [out] */ long __RPC_FAR *plIndex) = 0;
697
698 virtual /* [id] */ HRESULT STDMETHODCALLTYPE AddValue(
699 /* [in] */ long lIndex,
700 /* [in] */ double dValue) = 0;
701
702 };
703
704 //------------------------------------------------------------------
705 // wxAMMediaBackend (Active Movie)
706 //------------------------------------------------------------------
707 class WXDLLIMPEXP_MEDIA wxAMMediaBackend : public wxMediaBackend
708 {
709 public:
710 wxAMMediaBackend();
711
712 virtual ~wxAMMediaBackend();
713
714 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
715 wxWindowID id,
716 const wxPoint& pos,
717 const wxSize& size,
718 long style,
719 const wxValidator& validator,
720 const wxString& name);
721
722 virtual bool Play();
723 virtual bool Pause();
724 virtual bool Stop();
725
726 virtual bool Load(const wxString& fileName);
727 virtual bool Load(const wxURI& location);
728
729 virtual wxMediaState GetState();
730
731 virtual bool SetPosition(wxLongLong where);
732 virtual wxLongLong GetPosition();
733 virtual wxLongLong GetDuration();
734
735 virtual void Move(int x, int y, int w, int h);
736 wxSize GetVideoSize() const;
737
738 virtual double GetPlaybackRate();
739 virtual bool SetPlaybackRate(double);
740
741 virtual double GetVolume();
742 virtual bool SetVolume(double);
743
744 void Cleanup();
745
746 bool m_bVideo;
747
748 static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg,
749 WPARAM wParam, LPARAM lParam);
750
751 LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg,
752 WPARAM wParam, LPARAM lParam);
753
754 wxControl* m_ctrl;
755
756 IBasicAudio* m_pBA;
757 IBasicVideo* m_pBV;
758 IMediaControl* m_pMC;
759 IMediaEventEx* m_pME;
760 IMediaPosition* m_pMS;
761 IVideoWindow* m_pVW;
762
763 HWND m_hNotifyWnd;
764 wxSize m_bestSize;
765
766 DECLARE_DYNAMIC_CLASS(wxAMMediaBackend);
767 };
768
769 #endif //wxUSE_DIRECTSHOW
770
771 //---------------------------------------------------------------------------
772 //
773 // wxMCIMediaBackend
774 //
775 //---------------------------------------------------------------------------
776
777 //---------------------------------------------------------------------------
778 // MCI Includes
779 //---------------------------------------------------------------------------
780 #include <mmsystem.h>
781
782 class WXDLLIMPEXP_MEDIA wxMCIMediaBackend : public wxMediaBackend
783 {
784 public:
785
786 wxMCIMediaBackend();
787 ~wxMCIMediaBackend();
788
789 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
790 wxWindowID id,
791 const wxPoint& pos,
792 const wxSize& size,
793 long style,
794 const wxValidator& validator,
795 const wxString& name);
796
797 virtual bool Play();
798 virtual bool Pause();
799 virtual bool Stop();
800
801 virtual bool Load(const wxString& fileName);
802 virtual bool Load(const wxURI& location);
803
804 virtual wxMediaState GetState();
805
806 virtual bool SetPosition(wxLongLong where);
807 virtual wxLongLong GetPosition();
808 virtual wxLongLong GetDuration();
809
810 virtual void Move(int x, int y, int w, int h);
811 wxSize GetVideoSize() const;
812
813 virtual double GetPlaybackRate();
814 virtual bool SetPlaybackRate(double dRate);
815
816 virtual double GetVolume();
817 virtual bool SetVolume(double);
818
819 static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg,
820 WPARAM wParam, LPARAM lParam);
821
822 LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg,
823 WPARAM wParam, LPARAM lParam);
824
825 MCIDEVICEID m_hDev; //Our MCI Device ID/Handler
826 wxControl* m_ctrl; //Parent control
827 HWND m_hNotifyWnd; //Window to use for MCI events
828 bool m_bVideo; //Whether or not we have video
829
830 DECLARE_DYNAMIC_CLASS(wxMCIMediaBackend)
831 };
832
833 //---------------------------------------------------------------------------
834 //
835 // wxQTMediaBackend
836 //
837 //---------------------------------------------------------------------------
838
839 //---------------------------------------------------------------------------
840 // QT Compilation Guard
841 //---------------------------------------------------------------------------
842 #if wxUSE_QUICKTIME
843
844 //---------------------------------------------------------------------------
845 // QT Includes
846 //---------------------------------------------------------------------------
847 //#include <qtml.h> //Windoze QT include
848 //#include <QuickTimeComponents.h> //Standard QT stuff
849 #include "wx/dynlib.h"
850
851 //---------------------------------------------------------------------------
852 // QT Types
853 //---------------------------------------------------------------------------
854 typedef struct MovieRecord* Movie;
855 typedef wxInt16 OSErr;
856 typedef wxInt32 OSStatus;
857 #define noErr 0
858 #define fsRdPerm 1
859 typedef unsigned char Str255[256];
860 #define StringPtr unsigned char*
861 #define newMovieActive 1
862 #define Ptr char*
863 #define Handle Ptr*
864 #define Fixed long
865 #define OSType unsigned long
866 #define CGrafPtr struct GrafPort *
867 #define TimeScale long
868 #define TimeBase struct TimeBaseRecord *
869
870 struct FSSpec {
871 short vRefNum;
872 long parID;
873 Str255 name; /*Str63 on mac, Str255 on msw */
874 };
875
876 struct Rect {
877 short top;
878 short left;
879 short bottom;
880 short right;
881 };
882
883 struct wide {
884 wxInt32 hi;
885 wxUint32 lo;
886 };
887
888 struct TimeRecord {
889 wide value; /* units */
890 TimeScale scale; /* units per second */
891 TimeBase base;
892 };
893
894 //---------------------------------------------------------------------------
895 // QT Library
896 //---------------------------------------------------------------------------
897 #define wxDL_METHOD_DEFINE( rettype, name, args, shortargs, defret ) \
898 typedef rettype (* name ## Type) args ; \
899 name ## Type pfn_ ## name; \
900 rettype name args \
901 { if (m_ok) return pfn_ ## name shortargs ; return defret; }
902
903 #define wxDL_VOIDMETHOD_DEFINE( name, args, shortargs ) \
904 typedef void (* name ## Type) args ; \
905 name ## Type pfn_ ## name; \
906 void name args \
907 { if (m_ok) pfn_ ## name shortargs ; }
908
909 #define wxDL_METHOD_LOAD( lib, name, success ) \
910 pfn_ ## name = (name ## Type) lib.GetSymbol( wxT(#name), &success ); \
911 if (!success) return false;
912
913 //Class that utilizes Robert Roeblings Dynamic Library Macros
914 class wxQuickTimeLibrary
915 {
916 public:
917 ~wxQuickTimeLibrary()
918 {
919 if(m_dll.IsLoaded())
920 m_dll.Unload();
921 }
922
923 bool Initialize();
924 bool IsOk() const {return m_ok;}
925
926 protected:
927 wxDynamicLibrary m_dll;
928 bool m_ok;
929
930 public:
931 wxDL_VOIDMETHOD_DEFINE( StartMovie, (Movie m), (m) );
932 wxDL_VOIDMETHOD_DEFINE( StopMovie, (Movie m), (m) );
933 wxDL_METHOD_DEFINE( bool, IsMovieDone, (Movie m), (m), false);
934 wxDL_VOIDMETHOD_DEFINE( GoToBeginningOfMovie, (Movie m), (m) );
935 wxDL_METHOD_DEFINE( OSErr, GetMoviesError, (), (), -1);
936 wxDL_METHOD_DEFINE( OSErr, EnterMovies, (), (), -1);
937 wxDL_VOIDMETHOD_DEFINE( ExitMovies, (), () );
938 wxDL_METHOD_DEFINE( OSErr, InitializeQTML, (long flags), (flags), -1);
939 wxDL_VOIDMETHOD_DEFINE( TerminateQTML, (), () );
940
941 wxDL_METHOD_DEFINE( OSErr, NativePathNameToFSSpec,
942 (char* inName, FSSpec* outFile, long flags),
943 (inName, outFile, flags), -1);
944
945 wxDL_METHOD_DEFINE( OSErr, OpenMovieFile,
946 (const FSSpec * fileSpec, short * resRefNum, wxInt8 permission),
947 (fileSpec, resRefNum, permission), -1 );
948
949 wxDL_METHOD_DEFINE( OSErr, CloseMovieFile,
950 (short resRefNum), (resRefNum), -1);
951
952 wxDL_METHOD_DEFINE( OSErr, NewMovieFromFile,
953 (Movie * theMovie, short resRefNum, short * resId,
954 StringPtr resName, short newMovieFlags,
955 bool * dataRefWasChanged),
956 (theMovie, resRefNum, resId, resName, newMovieFlags,
957 dataRefWasChanged), -1);
958
959 wxDL_VOIDMETHOD_DEFINE( SetMovieRate, (Movie m, Fixed rate), (m, rate) );
960 wxDL_METHOD_DEFINE( Fixed, GetMovieRate, (Movie m), (m), 0);
961 wxDL_VOIDMETHOD_DEFINE( MoviesTask, (Movie m, long maxms), (m, maxms) );
962 wxDL_VOIDMETHOD_DEFINE( BlockMove,
963 (const char* p1, const char* p2, long s), (p1,p2,s) );
964 wxDL_METHOD_DEFINE( Handle, NewHandleClear, (long s), (s), NULL );
965
966 wxDL_METHOD_DEFINE( OSErr, NewMovieFromDataRef,
967 (Movie * m, short flags, short * id,
968 Handle dataRef, OSType dataRefType),
969 (m,flags,id,dataRef,dataRefType), -1 );
970
971 wxDL_VOIDMETHOD_DEFINE( DisposeHandle, (Handle h), (h) );
972 wxDL_VOIDMETHOD_DEFINE( GetMovieNaturalBoundsRect, (Movie m, Rect* r), (m,r) );
973 wxDL_METHOD_DEFINE( void*, GetMovieIndTrackType,
974 (Movie m, long index, OSType type, long flags),
975 (m,index,type,flags), NULL );
976 wxDL_VOIDMETHOD_DEFINE( CreatePortAssociation,
977 (void* hWnd, void* junk, long morejunk), (hWnd, junk, morejunk) );
978 wxDL_METHOD_DEFINE(void*, GetNativeWindowPort, (void* hWnd), (hWnd), NULL);
979 wxDL_VOIDMETHOD_DEFINE(SetMovieGWorld, (Movie m, CGrafPtr port, void* whatever),
980 (m, port, whatever) );
981 wxDL_VOIDMETHOD_DEFINE(DisposeMovie, (Movie m), (m) );
982 wxDL_VOIDMETHOD_DEFINE(SetMovieBox, (Movie m, Rect* r), (m,r));
983 wxDL_VOIDMETHOD_DEFINE(SetMovieTimeScale, (Movie m, long s), (m,s));
984 wxDL_METHOD_DEFINE(long, GetMovieDuration, (Movie m), (m), 0);
985 wxDL_METHOD_DEFINE(TimeBase, GetMovieTimeBase, (Movie m), (m), 0);
986 wxDL_METHOD_DEFINE(TimeScale, GetMovieTimeScale, (Movie m), (m), 0);
987 wxDL_METHOD_DEFINE(long, GetMovieTime, (Movie m, void* cruft), (m,cruft), 0);
988 wxDL_VOIDMETHOD_DEFINE(SetMovieTime, (Movie m, TimeRecord* tr), (m,tr) );
989 wxDL_METHOD_DEFINE(short, GetMovieVolume, (Movie m), (m), 0);
990 wxDL_VOIDMETHOD_DEFINE(SetMovieVolume, (Movie m, short sVolume), (m,sVolume) );
991 };
992
993 bool wxQuickTimeLibrary::Initialize()
994 {
995 m_ok = false;
996
997 if(!m_dll.Load(wxT("qtmlClient.dll")))
998 return false;
999
1000 bool bOk;
1001
1002 wxDL_METHOD_LOAD( m_dll, StartMovie, bOk );
1003 wxDL_METHOD_LOAD( m_dll, StopMovie, bOk );
1004 wxDL_METHOD_LOAD( m_dll, IsMovieDone, bOk );
1005 wxDL_METHOD_LOAD( m_dll, GoToBeginningOfMovie, bOk );
1006 wxDL_METHOD_LOAD( m_dll, GetMoviesError, bOk );
1007 wxDL_METHOD_LOAD( m_dll, EnterMovies, bOk );
1008 wxDL_METHOD_LOAD( m_dll, ExitMovies, bOk );
1009 wxDL_METHOD_LOAD( m_dll, InitializeQTML, bOk );
1010 wxDL_METHOD_LOAD( m_dll, TerminateQTML, bOk );
1011 wxDL_METHOD_LOAD( m_dll, NativePathNameToFSSpec, bOk );
1012 wxDL_METHOD_LOAD( m_dll, OpenMovieFile, bOk );
1013 wxDL_METHOD_LOAD( m_dll, CloseMovieFile, bOk );
1014 wxDL_METHOD_LOAD( m_dll, NewMovieFromFile, bOk );
1015 wxDL_METHOD_LOAD( m_dll, GetMovieRate, bOk );
1016 wxDL_METHOD_LOAD( m_dll, SetMovieRate, bOk );
1017 wxDL_METHOD_LOAD( m_dll, MoviesTask, bOk );
1018 wxDL_METHOD_LOAD( m_dll, BlockMove, bOk );
1019 wxDL_METHOD_LOAD( m_dll, NewHandleClear, bOk );
1020 wxDL_METHOD_LOAD( m_dll, NewMovieFromDataRef, bOk );
1021 wxDL_METHOD_LOAD( m_dll, DisposeHandle, bOk );
1022 wxDL_METHOD_LOAD( m_dll, GetMovieNaturalBoundsRect, bOk );
1023 wxDL_METHOD_LOAD( m_dll, GetMovieIndTrackType, bOk );
1024 wxDL_METHOD_LOAD( m_dll, CreatePortAssociation, bOk );
1025 wxDL_METHOD_LOAD( m_dll, GetNativeWindowPort, bOk );
1026 wxDL_METHOD_LOAD( m_dll, SetMovieGWorld, bOk );
1027 wxDL_METHOD_LOAD( m_dll, DisposeMovie, bOk );
1028 wxDL_METHOD_LOAD( m_dll, SetMovieBox, bOk );
1029 wxDL_METHOD_LOAD( m_dll, SetMovieTimeScale, bOk );
1030 wxDL_METHOD_LOAD( m_dll, GetMovieDuration, bOk );
1031 wxDL_METHOD_LOAD( m_dll, GetMovieTimeBase, bOk );
1032 wxDL_METHOD_LOAD( m_dll, GetMovieTimeScale, bOk );
1033 wxDL_METHOD_LOAD( m_dll, GetMovieTime, bOk );
1034 wxDL_METHOD_LOAD( m_dll, SetMovieTime, bOk );
1035 wxDL_METHOD_LOAD( m_dll, GetMovieVolume, bOk );
1036 wxDL_METHOD_LOAD( m_dll, SetMovieVolume, bOk );
1037
1038 m_ok = true;
1039
1040 return true;
1041 }
1042
1043 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackend
1044 {
1045 public:
1046
1047 wxQTMediaBackend();
1048 ~wxQTMediaBackend();
1049
1050 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
1051 wxWindowID id,
1052 const wxPoint& pos,
1053 const wxSize& size,
1054 long style,
1055 const wxValidator& validator,
1056 const wxString& name);
1057
1058 virtual bool Play();
1059 virtual bool Pause();
1060 virtual bool Stop();
1061
1062 virtual bool Load(const wxString& fileName);
1063 virtual bool Load(const wxURI& location);
1064
1065 virtual wxMediaState GetState();
1066
1067 virtual bool SetPosition(wxLongLong where);
1068 virtual wxLongLong GetPosition();
1069 virtual wxLongLong GetDuration();
1070
1071 virtual void Move(int x, int y, int w, int h);
1072 wxSize GetVideoSize() const;
1073
1074 virtual double GetPlaybackRate();
1075 virtual bool SetPlaybackRate(double dRate);
1076
1077 virtual double GetVolume();
1078 virtual bool SetVolume(double);
1079
1080 void Cleanup();
1081 void FinishLoad();
1082
1083 wxSize m_bestSize; //Original movie size
1084 Movie m_movie; //QT Movie handle/instance
1085 wxControl* m_ctrl; //Parent control
1086 bool m_bVideo; //Whether or not we have video
1087 class _wxQTTimer* m_timer; //Timer for streaming the movie
1088 wxQuickTimeLibrary m_lib;
1089
1090
1091 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend);
1092 };
1093
1094 //---------------------------------------------------------------------------
1095 // End QT Compilation Guard
1096 //---------------------------------------------------------------------------
1097 #endif //wxUSE_QUICKTIME
1098
1099 //===========================================================================
1100 // IMPLEMENTATION
1101 //===========================================================================
1102
1103 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1104 //
1105 // wxAMMediaBackend
1106 //
1107 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1108
1109 //---------------------------------------------------------------------------
1110 // Only use if user wants it -
1111 //---------------------------------------------------------------------------
1112 #if wxUSE_DIRECTSHOW
1113
1114 IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend, wxMediaBackend);
1115
1116 // Numerical value for when the graph reaches the stop position
1117 #define WM_GRAPHNOTIFY WM_USER+13
1118
1119 //---------------------------------------------------------------------------
1120 // Usual debugging macros
1121 //---------------------------------------------------------------------------
1122 #ifdef __WXDEBUG__
1123 #define wxAMVERIFY(x) \
1124 { \
1125 HRESULT hrdsv = (x); \
1126 if ( FAILED(hrdsv) ) \
1127 { \
1128 /*TCHAR szError[MAX_ERROR_TEXT_LEN];*/ \
1129 /*if( AMGetErrorText(hrdsv, szError, MAX_ERROR_TEXT_LEN) == 0)*/ \
1130 /*{*/ \
1131 /*wxFAIL_MSG( wxString::Format(wxT("DirectShow error \"%s\" ")*/\
1132 /*wxT("occured at line %i in ")*/ \
1133 /*wxT("mediactrl.cpp"),*/ \
1134 /*szError, __LINE__) );*/ \
1135 /*}*/ \
1136 /*else*/ \
1137 wxFAIL_MSG( wxString::Format(wxT("Unknown error (%i) ") \
1138 wxT("occured at") \
1139 wxT(" line %i in mediactrl.cpp."), \
1140 (int)hrdsv, __LINE__) ); \
1141 } \
1142 }
1143 #define wxVERIFY(x) wxASSERT((x))
1144 #else
1145 #define wxAMVERIFY(x) (x)
1146 #define wxVERIFY(x) (x)
1147 #endif
1148
1149 //---------------------------------------------------------------------------
1150 // Standard macros for ease of use
1151 //---------------------------------------------------------------------------
1152 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
1153
1154 //---------------------------------------------------------------------------
1155 // wxAMMediaBackend Constructor
1156 //
1157 // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet
1158 //---------------------------------------------------------------------------
1159 wxAMMediaBackend::wxAMMediaBackend() : m_hNotifyWnd(NULL)
1160 {
1161 }
1162
1163 //---------------------------------------------------------------------------
1164 // wxAMMediaBackend Destructor
1165 //
1166 // Cleans up everything
1167 //---------------------------------------------------------------------------
1168 wxAMMediaBackend::~wxAMMediaBackend()
1169 {
1170 if (m_hNotifyWnd)
1171 Cleanup();
1172 }
1173
1174 //---------------------------------------------------------------------------
1175 // wxAMMediaBackend::CreateControl
1176 //
1177 // ActiveMovie does not really have any native control to speak of,
1178 // so we just create a normal control.
1179 //
1180 // We also check to see if ActiveMovie is installed
1181 //---------------------------------------------------------------------------
1182 bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
1183 wxWindowID id,
1184 const wxPoint& pos,
1185 const wxSize& size,
1186 long style,
1187 const wxValidator& validator,
1188 const wxString& name)
1189 {
1190 //create our filter graph - the beuty of COM is that it loads
1191 //quartz.dll for us :)
1192 HRESULT hr = CoCreateInstance(CLSID_FilgraphManager, NULL, CLSCTX_INPROC_SERVER,
1193 IID_IMediaControl, (void**)&m_pMC);
1194
1195 //directshow not installed?
1196 if ( FAILED(hr) )
1197 return false;
1198
1199 //release the filter graph - we don't need it yet
1200 m_pMC->Release();
1201 m_pMC = NULL;
1202
1203 //
1204 // Create window
1205 // By default wxWindow(s) is created with a border -
1206 // so we need to get rid of those, and create with
1207 // wxCLIP_CHILDREN, so that if the driver/backend
1208 // is a child window, it refereshes properly
1209 //
1210 if ( !ctrl->wxControl::Create(parent, id, pos, size,
1211 (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
1212 validator, name) )
1213 return false;
1214
1215 m_ctrl = ctrl;
1216 return true;
1217 }
1218
1219
1220 //---------------------------------------------------------------------------
1221 // wxAMMediaBackend::Load (file version)
1222 //
1223 // Creates an Active Movie filter graph from a file or url
1224 //---------------------------------------------------------------------------
1225 bool wxAMMediaBackend::Load(const wxString& fileName)
1226 {
1227 //if previously loaded cleanup
1228 if(m_hNotifyWnd)
1229 Cleanup();
1230
1231 //We already checked for success in CreateControl
1232 CoCreateInstance(CLSID_FilgraphManager, NULL, CLSCTX_INPROC_SERVER,
1233 IID_IMediaControl, (void**)&m_pMC);
1234
1235 //load the graph & render
1236 if( FAILED(m_pMC->RenderFile(wxBasicString(fileName).Get())) )
1237 return false;
1238
1239 //get the interfaces, all of them
1240 wxAMVERIFY( m_pMC->QueryInterface(IID_IMediaEventEx, (void**)&m_pME) );
1241 wxAMVERIFY( m_pMC->QueryInterface(IID_IMediaPosition, (void**)&m_pMS) );
1242 wxAMVERIFY( m_pMC->QueryInterface(IID_IVideoWindow, (void**)&m_pVW) );
1243 wxAMVERIFY( m_pMC->QueryInterface(IID_IBasicAudio, (void**)&m_pBA) );
1244 wxAMVERIFY( m_pMC->QueryInterface(IID_IBasicVideo, (void**)&m_pBV) );
1245
1246 //We could tell if the media has audio or not by
1247 //something like
1248 //-----
1249 //long lVolume;
1250 //pBA->get_Volume(&lVolume) == E_NOTIMPL
1251 //-----
1252 //here...
1253
1254 //
1255 //Obtain the _actual_ size of the movie & remember it
1256 //
1257 long nX,
1258 nY;
1259
1260 m_bestSize.x = m_bestSize.y = 0;
1261
1262 m_bVideo = SUCCEEDED( m_pVW->GetWindowPosition( &nX,
1263 &nY,
1264 (long*)&m_bestSize.x,
1265 (long*)&m_bestSize.y) );
1266
1267 //
1268 //If we have video in the media - set it up so that
1269 //its a child window of the control, its visible,
1270 //and that the control is the owner of the video window
1271 //
1272 if (m_bVideo)
1273 {
1274 wxAMVERIFY( m_pVW->put_Owner((LONG_PTR)m_ctrl->GetHandle()) );
1275 wxAMVERIFY( m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS) );
1276 wxAMVERIFY( m_pVW->put_Visible(-1) ); //OATRUE == -1
1277 }
1278
1279 //
1280 // Create a hidden window and register to handle
1281 // directshow events for this graph
1282 // Note that wxCanvasClassName is already registered
1283 // and used by all wxWindows and normal wxControls
1284 //
1285 m_hNotifyWnd = ::CreateWindow
1286 (
1287 wxCanvasClassName,
1288 NULL,
1289 0, 0, 0, 0,
1290 0,
1291 (HWND) NULL,
1292 (HMENU)NULL,
1293 wxGetInstance(),
1294 (LPVOID) NULL
1295 );
1296
1297 if(!m_hNotifyWnd)
1298 {
1299 wxLogSysError( wxT("Could not create hidden needed for ")
1300 wxT("registering for DirectShow events!") );
1301
1302 return false;
1303 }
1304
1305 #if defined(_WIN32)
1306 ::SetWindowLong(m_hNotifyWnd, GWL_WNDPROC,
1307 (LONG)wxAMMediaBackend::NotifyWndProc);
1308 #else
1309 ::SetWindowLongPtr(m_hNotifyWnd, GWLP_WNDPROC,
1310 (LONG_PTR)wxAMMediaBackend::NotifyWndProc);
1311 #endif
1312
1313 ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA,
1314 (LONG) this);
1315
1316 wxAMVERIFY( m_pME->SetNotifyWindow((LONG_PTR)m_hNotifyWnd,
1317 WM_GRAPHNOTIFY, 0) );
1318
1319 //
1320 // Force the parent window of this control to recalculate
1321 // the size of this if sizers are being used
1322 // and render the results immediately
1323 //
1324 m_ctrl->InvalidateBestSize();
1325 m_ctrl->GetParent()->Layout();
1326 m_ctrl->GetParent()->Refresh();
1327 m_ctrl->GetParent()->Update();
1328
1329 return true;
1330 }
1331
1332 //---------------------------------------------------------------------------
1333 // wxAMMediaBackend::Load (URL Version)
1334 //
1335 // Loads media from a URL. Interestingly enough DirectShow
1336 // appears (?) to escape the URL for us, at least on normal
1337 // files
1338 //---------------------------------------------------------------------------
1339 bool wxAMMediaBackend::Load(const wxURI& location)
1340 {
1341 return Load(location.BuildUnescapedURI());
1342 }
1343
1344 //---------------------------------------------------------------------------
1345 // wxAMMediaBackend::Play
1346 //
1347 // Plays the stream. If it is non-seekable, it will restart it.
1348 //---------------------------------------------------------------------------
1349 bool wxAMMediaBackend::Play()
1350 {
1351 return SUCCEEDED( m_pMC->Run() );
1352 }
1353
1354 //---------------------------------------------------------------------------
1355 // wxAMMediaBackend::Pause
1356 //
1357 // Pauses the stream.
1358 //---------------------------------------------------------------------------
1359 bool wxAMMediaBackend::Pause()
1360 {
1361 return SUCCEEDED( m_pMC->Pause() );
1362 }
1363
1364 //---------------------------------------------------------------------------
1365 // wxAMMediaBackend::Stop
1366 //
1367 // Stops the stream.
1368 //---------------------------------------------------------------------------
1369 bool wxAMMediaBackend::Stop()
1370 {
1371 bool bOK = SUCCEEDED( m_pMC->Stop() );
1372
1373 //We don't care if it can't get to the beginning in directshow -
1374 //it could be a non-seeking filter (wince midi) in which case playing
1375 //starts all over again
1376 SetPosition(0);
1377 return bOK;
1378 }
1379
1380 //---------------------------------------------------------------------------
1381 // wxAMMediaBackend::SetPosition
1382 //
1383 // 1) Translates the current position's time to directshow time,
1384 // which is in a scale of 1 second (in a double)
1385 // 2) Sets the play position of the IMediaSeeking interface -
1386 // passing NULL as the stop position means to keep the old
1387 // stop position
1388 //---------------------------------------------------------------------------
1389 bool wxAMMediaBackend::SetPosition(wxLongLong where)
1390 {
1391 return SUCCEEDED( m_pMS->put_CurrentPosition(
1392 ((LONGLONG)where.GetValue()) / 1000
1393 )
1394 );
1395 }
1396
1397 //---------------------------------------------------------------------------
1398 // wxAMMediaBackend::GetPosition
1399 //
1400 // 1) Obtains the current play and stop positions from IMediaSeeking
1401 // 2) Returns the play position translated to our time base
1402 //---------------------------------------------------------------------------
1403 wxLongLong wxAMMediaBackend::GetPosition()
1404 {
1405 double outCur;
1406 wxAMVERIFY( m_pMS->get_CurrentPosition(&outCur) );
1407
1408 //h,m,s,milli - outdur is in 1 second (double)
1409 return (outCur*1000);
1410 }
1411
1412 //---------------------------------------------------------------------------
1413 // wxAMMediaBackend::SetVolume
1414 //
1415 // Sets the volume through the IBasicAudio interface -
1416 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
1417 // -100 per decibel.
1418 //---------------------------------------------------------------------------
1419 bool wxAMMediaBackend::SetVolume(double dVolume)
1420 {
1421 return SUCCEEDED(m_pBA->put_Volume( (long) ((dVolume-1.0) * 10000.0) ));
1422 }
1423
1424 //---------------------------------------------------------------------------
1425 // wxAMMediaBackend::GetVolume
1426 //
1427 // Gets the volume through the IBasicAudio interface -
1428 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
1429 // -100 per decibel.
1430 //---------------------------------------------------------------------------
1431 double wxAMMediaBackend::GetVolume()
1432 {
1433 long lVolume;
1434 if ( SUCCEEDED(m_pBA->get_Volume(&lVolume)) )
1435 return (((double)(lVolume + 10000)) / 10000.0);
1436 return 0.0;
1437 }
1438
1439 //---------------------------------------------------------------------------
1440 // wxAMMediaBackend::GetDuration
1441 //
1442 // 1) Obtains the duration of the media from the IMediaSeeking interface
1443 // 2) Converts that value to our time base, and returns it
1444 //---------------------------------------------------------------------------
1445 wxLongLong wxAMMediaBackend::GetDuration()
1446 {
1447 double outDuration;
1448 wxAMVERIFY( m_pMS->get_Duration(&outDuration) );
1449
1450 //h,m,s,milli - outdur is in 1 second (double)
1451 return (outDuration*1000);
1452 }
1453
1454 //---------------------------------------------------------------------------
1455 // wxAMMediaBackend::GetState
1456 //
1457 // Obtains the state from the IMediaControl interface.
1458 // Note that it's enumeration values for stopping/playing
1459 // etc. are the same as ours, so we just do a straight cast.
1460 // TODO: MS recommends against INFINITE here for
1461 // IMediaControl::GetState- do it in stages
1462 //---------------------------------------------------------------------------
1463 wxMediaState wxAMMediaBackend::GetState()
1464 {
1465 HRESULT hr;
1466 long theState; //OAFilterState
1467 hr = m_pMC->GetState(INFINITE, &theState);
1468
1469 wxASSERT( SUCCEEDED(hr) );
1470
1471 //MSW state is the same as ours
1472 //State_Stopped = 0,
1473 //State_Paused = State_Stopped + 1,
1474 //State_Running = State_Paused + 1
1475
1476 return (wxMediaState) theState;
1477 }
1478
1479 //---------------------------------------------------------------------------
1480 // wxAMMediaBackend::GetPlaybackRate
1481 //
1482 // Pretty simple way of obtaining the playback rate from
1483 // the IMediaSeeking interface
1484 //---------------------------------------------------------------------------
1485 double wxAMMediaBackend::GetPlaybackRate()
1486 {
1487 double dRate;
1488 wxAMVERIFY( m_pMS->get_Rate(&dRate) );
1489 return dRate;
1490 }
1491
1492 //---------------------------------------------------------------------------
1493 // wxAMMediaBackend::SetPlaybackRate
1494 //
1495 // Sets the playback rate of the media - DirectShow is pretty good
1496 // about this, actually
1497 //---------------------------------------------------------------------------
1498 bool wxAMMediaBackend::SetPlaybackRate(double dRate)
1499 {
1500 return SUCCEEDED( m_pMS->put_Rate(dRate) );
1501 }
1502
1503 //---------------------------------------------------------------------------
1504 // wxAMMediaBackend::NotifyWndProc
1505 //
1506 // Here we check to see if DirectShow tells us we've reached the stop
1507 // position in our stream - if it has, it may not actually stop
1508 // the stream - which we need to do...
1509 //---------------------------------------------------------------------------
1510 LRESULT CALLBACK wxAMMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg,
1511 WPARAM wParam,
1512 LPARAM lParam)
1513 {
1514 wxAMMediaBackend* backend = (wxAMMediaBackend*)
1515 ::GetWindowLong(hWnd, GWL_USERDATA);
1516
1517 return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam);
1518 }
1519
1520 LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg,
1521 WPARAM wParam,
1522 LPARAM lParam)
1523 {
1524 if (nMsg == WM_GRAPHNOTIFY)
1525 {
1526 LONG evCode,
1527 evParam1,
1528 evParam2;
1529
1530 //
1531 // DirectShow keeps a list of queued events, and we need
1532 // to go through them one by one, stopping at (Hopefully only one)
1533 // EC_COMPLETE message
1534 //
1535 while(SUCCEEDED(m_pME->GetEvent(&evCode, (LONG_PTR *) &evParam1,
1536 (LONG_PTR *) &evParam2, 0)
1537 )
1538 )
1539 {
1540 // Cleanup memory that GetEvent allocated
1541 wxAMVERIFY( m_pME->FreeEventParams(evCode, evParam1, evParam2) );
1542
1543 // If this is the end of the clip, notify handler
1544 if(1 == evCode) //EC_COMPLETE
1545 {
1546 //send the event to our child
1547 wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
1548 m_ctrl->ProcessEvent(theEvent);
1549
1550 //if the user didn't veto it, stop the stream
1551 if (theEvent.IsAllowed())
1552 {
1553 //Interestingly enough, DirectShow does not actually stop
1554 //the filters - even when it reaches the end!
1555 wxVERIFY( Stop() );
1556
1557 //send the event to our child
1558 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
1559 m_ctrl->GetId());
1560 m_ctrl->ProcessEvent(theEvent);
1561 }
1562 }
1563 }
1564 }
1565 return DefWindowProc(hWnd, nMsg, wParam, lParam);
1566 }
1567
1568 //---------------------------------------------------------------------------
1569 // wxAMMediaBackend::Cleanup
1570 //
1571 // 1) Hide/disowns the video window (MS says bad things will happen if
1572 // you don't)
1573 // 2) Releases all the directshow interfaces we use
1574 // TODO: Maybe there's a way to redirect the IMediaControl each time
1575 // we load, rather then creating and destroying the interfaces
1576 // each time?
1577 //---------------------------------------------------------------------------
1578 void wxAMMediaBackend::Cleanup()
1579 {
1580 // Hide then disown the window
1581 if(m_pVW)
1582 {
1583 m_pVW->put_Visible(0); //OSFALSE == 0
1584 m_pVW->put_Owner(NULL);
1585 }
1586
1587 // Release and zero DirectShow interfaces
1588 SAFE_RELEASE(m_pME);
1589 SAFE_RELEASE(m_pMS);
1590 SAFE_RELEASE(m_pBA);
1591 SAFE_RELEASE(m_pBV);
1592 SAFE_RELEASE(m_pVW);
1593 SAFE_RELEASE(m_pMC);
1594
1595 // Get rid of our hidden Window
1596 DestroyWindow(m_hNotifyWnd);
1597 m_hNotifyWnd = NULL;
1598 }
1599
1600
1601 //---------------------------------------------------------------------------
1602 // wxAMMediaBackend::GetVideoSize
1603 //
1604 // Obtains the cached original video size
1605 //---------------------------------------------------------------------------
1606 wxSize wxAMMediaBackend::GetVideoSize() const
1607 {
1608 return m_bestSize;
1609 }
1610
1611 //---------------------------------------------------------------------------
1612 // wxAMMediaBackend::Move
1613 //
1614 // Resizes the IVideoWindow to the size of the control window
1615 //---------------------------------------------------------------------------
1616 void wxAMMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), int w, int h)
1617 {
1618 if(m_hNotifyWnd && m_bVideo)
1619 {
1620 wxAMVERIFY( m_pVW->SetWindowPosition(0, 0, w, h) );
1621 }
1622 }
1623
1624 //---------------------------------------------------------------------------
1625 // End of wxAMMediaBackend
1626 //---------------------------------------------------------------------------
1627 #endif //wxUSE_DIRECTSHOW
1628
1629 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1630 //
1631 // wxMCIMediaBackend
1632 //
1633 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1634
1635
1636 IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend, wxMediaBackend);
1637
1638 //---------------------------------------------------------------------------
1639 // Usual debugging macros for MCI returns
1640 //---------------------------------------------------------------------------
1641
1642 #ifdef __WXDEBUG__
1643 #define wxMCIVERIFY(arg) \
1644 { \
1645 DWORD nRet; \
1646 if ( (nRet = (arg)) != 0) \
1647 { \
1648 TCHAR sz[5000]; \
1649 mciGetErrorString(nRet, sz, 5000); \
1650 wxFAIL_MSG(wxString::Format(_T("MCI Error:%s"), sz)); \
1651 } \
1652 }
1653 #else
1654 #define wxMCIVERIFY(arg) (arg);
1655 #endif
1656
1657 //---------------------------------------------------------------------------
1658 // Simulation for <digitalv.h>
1659 //
1660 // Mingw and possibly other compilers don't have the digitalv.h header
1661 // that is needed to have some essential features of mci work with
1662 // windows - so we provide the declarations for the types we use here
1663 //---------------------------------------------------------------------------
1664
1665 typedef struct {
1666 DWORD_PTR dwCallback;
1667 #ifdef MCI_USE_OFFEXT
1668 POINT ptOffset;
1669 POINT ptExtent;
1670 #else
1671 RECT rc;
1672 #endif
1673 } MCI_DGV_RECT_PARMS;
1674
1675 typedef struct {
1676 DWORD_PTR dwCallback;
1677 HWND hWnd;
1678 #ifndef _WIN32
1679 WORD wReserved1;
1680 #endif
1681 UINT nCmdShow;
1682 #ifndef _WIN32
1683 WORD wReserved2;
1684 #endif
1685 wxChar* lpstrText;
1686 } MCI_DGV_WINDOW_PARMS;
1687
1688 typedef struct {
1689 DWORD_PTR dwCallback;
1690 DWORD dwTimeFormat;
1691 DWORD dwAudio;
1692 DWORD dwFileFormat;
1693 DWORD dwSpeed;
1694 } MCI_DGV_SET_PARMS;
1695
1696 typedef struct {
1697 DWORD_PTR dwCallback;
1698 DWORD dwItem;
1699 DWORD dwValue;
1700 DWORD dwOver;
1701 wxChar* lpstrAlgorithm;
1702 wxChar* lpstrQuality;
1703 } MCI_DGV_SETAUDIO_PARMS;
1704
1705 //---------------------------------------------------------------------------
1706 // wxMCIMediaBackend Constructor
1707 //
1708 // Here we don't need to do much except say we don't have any video :)
1709 //---------------------------------------------------------------------------
1710 wxMCIMediaBackend::wxMCIMediaBackend() : m_hNotifyWnd(NULL), m_bVideo(false)
1711 {
1712 }
1713
1714 //---------------------------------------------------------------------------
1715 // wxMCIMediaBackend Destructor
1716 //
1717 // We close the mci device - note that there may not be an mci device here,
1718 // or it may fail - but we don't really care, since we're destructing
1719 //---------------------------------------------------------------------------
1720 wxMCIMediaBackend::~wxMCIMediaBackend()
1721 {
1722 if(m_hNotifyWnd)
1723 {
1724 mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
1725 DestroyWindow(m_hNotifyWnd);
1726 m_hNotifyWnd = NULL;
1727 }
1728 }
1729
1730 //---------------------------------------------------------------------------
1731 // wxMCIMediaBackend::Create
1732 //
1733 // Here we just tell wxMediaCtrl that mci does exist (which it does, on all
1734 // msw systems, at least in some form dating back to win16 days)
1735 //---------------------------------------------------------------------------
1736 bool wxMCIMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
1737 wxWindowID id,
1738 const wxPoint& pos,
1739 const wxSize& size,
1740 long style,
1741 const wxValidator& validator,
1742 const wxString& name)
1743 {
1744 //
1745 // Create window
1746 // By default wxWindow(s) is created with a border -
1747 // so we need to get rid of those, and create with
1748 // wxCLIP_CHILDREN, so that if the driver/backend
1749 // is a child window, it refereshes properly
1750 //
1751 if ( !ctrl->wxControl::Create(parent, id, pos, size,
1752 (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
1753 validator, name) )
1754 return false;
1755
1756 m_ctrl = ctrl;
1757 return true;
1758 }
1759
1760 //---------------------------------------------------------------------------
1761 // wxMCIMediaBackend::Load (file version)
1762 //
1763 // Here we have MCI load a file and device, set the time format to our
1764 // default (milliseconds), and set the video (if any) to play in the control
1765 //---------------------------------------------------------------------------
1766 bool wxMCIMediaBackend::Load(const wxString& fileName)
1767 {
1768 //
1769 //if the user already called load close the previous MCI device
1770 //
1771 if(m_hNotifyWnd)
1772 {
1773 mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
1774 DestroyWindow(m_hNotifyWnd);
1775 m_hNotifyWnd = NULL;
1776 }
1777
1778 //
1779 //Opens a file and has MCI select a device. Normally you'd put
1780 //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you
1781 //omit this it tells MCI to select the device instead. This is
1782 //good because we have no reliable way of "enumerating" the devices
1783 //in MCI
1784 //
1785 MCI_OPEN_PARMS openParms;
1786 openParms.lpstrElementName = (wxChar*) fileName.c_str();
1787
1788 if ( mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT,
1789 (DWORD)(LPVOID)&openParms) != 0)
1790 return false;
1791
1792 m_hDev = openParms.wDeviceID;
1793
1794 //
1795 //Now set the time format for the device to milliseconds
1796 //
1797 MCI_SET_PARMS setParms;
1798 setParms.dwCallback = 0;
1799 setParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
1800
1801 if (mciSendCommand(m_hDev, MCI_SET, MCI_SET_TIME_FORMAT,
1802 (DWORD)(LPVOID)&setParms) != 0)
1803 return false;
1804
1805 //
1806 //Now tell the MCI device to display the video in our wxMediaCtrl
1807 //
1808 MCI_DGV_WINDOW_PARMS windowParms;
1809 windowParms.hWnd = (HWND)m_ctrl->GetHandle();
1810
1811 m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW,
1812 0x00010000L, //MCI_DGV_WINDOW_HWND
1813 (DWORD)(LPVOID)&windowParms) == 0);
1814
1815 //
1816 // Create a hidden window and register to handle
1817 // MCI events
1818 // Note that wxCanvasClassName is already registered
1819 // and used by all wxWindows and normal wxControls
1820 //
1821 m_hNotifyWnd = ::CreateWindow
1822 (
1823 wxCanvasClassName,
1824 NULL,
1825 0, 0, 0, 0,
1826 0,
1827 (HWND) NULL,
1828 (HMENU)NULL,
1829 wxGetInstance(),
1830 (LPVOID) NULL
1831 );
1832
1833 if(!m_hNotifyWnd)
1834 {
1835 wxLogSysError( wxT("Could not create hidden needed for ")
1836 wxT("registering for DirectShow events!") );
1837
1838 return false;
1839 }
1840
1841 #if defined(_WIN32)
1842 ::SetWindowLong(m_hNotifyWnd, GWL_WNDPROC,
1843 (LONG)wxMCIMediaBackend::NotifyWndProc);
1844 #else
1845 ::SetWindowLongPtr(m_hNotifyWnd, GWLP_WNDPROC,
1846 (LONG_PTR)wxMCIMediaBackend::NotifyWndProc);
1847 #endif
1848
1849 ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA,
1850 (LONG) this);
1851
1852 //
1853 //Here, if the parent of the control has a sizer - we
1854 //tell it to recalculate the size of this control since
1855 //the user opened a seperate media file
1856 //
1857 m_ctrl->InvalidateBestSize();
1858 m_ctrl->GetParent()->Layout();
1859 m_ctrl->GetParent()->Refresh();
1860 m_ctrl->GetParent()->Update();
1861
1862 return true;
1863 }
1864
1865 //---------------------------------------------------------------------------
1866 // wxMCIMediaBackend::Load (URL version)
1867 //
1868 // MCI doesn't support URLs directly (?)
1869 //
1870 // TODO: Use wxURL/wxFileSystem and mmioInstallProc
1871 //---------------------------------------------------------------------------
1872 bool wxMCIMediaBackend::Load(const wxURI& WXUNUSED(location))
1873 {
1874 return false;
1875 }
1876
1877 //---------------------------------------------------------------------------
1878 // wxMCIMediaBackend::Play
1879 //
1880 // Plays/Resumes the MCI device... a couple notes:
1881 // 1) Certain drivers will crash and burn if we don't pass them an
1882 // MCI_PLAY_PARMS, despite the documentation that says otherwise...
1883 // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing
1884 // and will resume from a stopped state also, so there's no need to
1885 // call both, for example
1886 //---------------------------------------------------------------------------
1887 bool wxMCIMediaBackend::Play()
1888 {
1889 MCI_PLAY_PARMS playParms;
1890 playParms.dwCallback = (DWORD)m_hNotifyWnd;
1891
1892 bool bOK = ( mciSendCommand(m_hDev, MCI_PLAY, MCI_NOTIFY,
1893 (DWORD)(LPVOID)&playParms) == 0 );
1894
1895 if(bOK)
1896 m_ctrl->Show(m_bVideo);
1897
1898 return bOK;
1899 }
1900
1901 //---------------------------------------------------------------------------
1902 // wxMCIMediaBackend::Pause
1903 //
1904 // Pauses the MCI device - nothing special
1905 //---------------------------------------------------------------------------
1906 bool wxMCIMediaBackend::Pause()
1907 {
1908 return (mciSendCommand(m_hDev, MCI_PAUSE, MCI_WAIT, 0) == 0);
1909 }
1910
1911 //---------------------------------------------------------------------------
1912 // wxMCIMediaBackend::Stop
1913 //
1914 // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline
1915 //---------------------------------------------------------------------------
1916 bool wxMCIMediaBackend::Stop()
1917 {
1918 return (mciSendCommand(m_hDev, MCI_STOP, MCI_WAIT, 0) == 0) &&
1919 (mciSendCommand(m_hDev, MCI_SEEK, MCI_SEEK_TO_START, 0) == 0);
1920 }
1921
1922 //---------------------------------------------------------------------------
1923 // wxMCIMediaBackend::GetState
1924 //
1925 // Here we get the state and convert it to a wxMediaState -
1926 // since we use direct comparisons with MCI_MODE_PLAY and
1927 // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call
1928 // fails or not
1929 //---------------------------------------------------------------------------
1930 wxMediaState wxMCIMediaBackend::GetState()
1931 {
1932 MCI_STATUS_PARMS statusParms;
1933 statusParms.dwItem = MCI_STATUS_MODE;
1934
1935 mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
1936 (DWORD)(LPVOID)&statusParms);
1937
1938 if(statusParms.dwReturn == MCI_MODE_PAUSE)
1939 return wxMEDIASTATE_PAUSED;
1940 else if(statusParms.dwReturn == MCI_MODE_PLAY)
1941 return wxMEDIASTATE_PLAYING;
1942 else
1943 return wxMEDIASTATE_STOPPED;
1944 }
1945
1946 //---------------------------------------------------------------------------
1947 // wxMCIMediaBackend::SetPosition
1948 //
1949 // Here we set the position of the device in the stream.
1950 // Note that MCI actually stops the device after you seek it if the
1951 // device is playing/paused, so we need to play the file after
1952 // MCI seeks like normal APIs would
1953 //---------------------------------------------------------------------------
1954 bool wxMCIMediaBackend::SetPosition(wxLongLong where)
1955 {
1956 MCI_SEEK_PARMS seekParms;
1957 seekParms.dwCallback = 0;
1958 #if wxUSE_LONGLONG_NATIVE && !wxUSE_LONGLONG_WX
1959 seekParms.dwTo = (DWORD)where.GetValue();
1960 #else /* wxUSE_LONGLONG_WX */
1961 /* no way to return it in one piece */
1962 wxASSERT( where.GetHi()==0 );
1963 seekParms.dwTo = (DWORD)where.GetLo();
1964 #endif /* wxUSE_LONGLONG_* */
1965
1966 //device was playing?
1967 bool bReplay = GetState() == wxMEDIASTATE_PLAYING;
1968
1969 if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO,
1970 (DWORD)(LPVOID)&seekParms) != 0)
1971 return false;
1972
1973 //If the device was playing, resume it
1974 if (bReplay)
1975 return Play();
1976 else
1977 return true;
1978 }
1979
1980 //---------------------------------------------------------------------------
1981 // wxMCIMediaBackend::GetPosition
1982 //
1983 // Gets the position of the device in the stream using the current
1984 // time format... nothing special here...
1985 //---------------------------------------------------------------------------
1986 wxLongLong wxMCIMediaBackend::GetPosition()
1987 {
1988 MCI_STATUS_PARMS statusParms;
1989 statusParms.dwItem = MCI_STATUS_POSITION;
1990
1991 if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
1992 (DWORD)(LPSTR)&statusParms) != 0)
1993 return 0;
1994
1995 return statusParms.dwReturn;
1996 }
1997
1998 //---------------------------------------------------------------------------
1999 // wxMCIMediaBackend::GetVolume
2000 //
2001 // Gets the volume of the current media via the MCI_DGV_STATUS_VOLUME
2002 // message. Value ranges from 0 (minimum) to 1000 (maximum volume).
2003 //---------------------------------------------------------------------------
2004 double wxMCIMediaBackend::GetVolume()
2005 {
2006 MCI_STATUS_PARMS statusParms;
2007 statusParms.dwCallback = NULL;
2008 statusParms.dwItem = 0x4019; //MCI_DGV_STATUS_VOLUME
2009
2010 if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2011 (DWORD)(LPSTR)&statusParms) != 0)
2012 return 0;
2013
2014 return ((double)statusParms.dwReturn) / 1000.0;
2015 }
2016
2017 //---------------------------------------------------------------------------
2018 // wxMCIMediaBackend::SetVolume
2019 //
2020 // Sets the volume of the current media via the MCI_DGV_SETAUDIO_VOLUME
2021 // message. Value ranges from 0 (minimum) to 1000 (maximum volume).
2022 //---------------------------------------------------------------------------
2023 bool wxMCIMediaBackend::SetVolume(double dVolume)
2024 {
2025 MCI_DGV_SETAUDIO_PARMS audioParms;
2026 audioParms.dwCallback = NULL;
2027 audioParms.dwItem = 0x4002; //MCI_DGV_SETAUDIO_VOLUME
2028 audioParms.dwValue = (DWORD) (dVolume * 1000.0);
2029 audioParms.dwOver = 0;
2030 audioParms.lpstrAlgorithm = NULL;
2031 audioParms.lpstrQuality = NULL;
2032
2033 if (mciSendCommand(m_hDev, 0x0873, //MCI_SETAUDIO
2034 0x00800000L | 0x01000000L, //MCI_DGV_SETAUDIO+(_ITEM | _VALUE)
2035 (DWORD)(LPSTR)&audioParms) != 0)
2036 return false;
2037 return true;
2038 }
2039
2040 //---------------------------------------------------------------------------
2041 // wxMCIMediaBackend::GetDuration
2042 //
2043 // Gets the duration of the stream... nothing special
2044 //---------------------------------------------------------------------------
2045 wxLongLong wxMCIMediaBackend::GetDuration()
2046 {
2047 MCI_STATUS_PARMS statusParms;
2048 statusParms.dwItem = MCI_STATUS_LENGTH;
2049
2050 if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2051 (DWORD)(LPSTR)&statusParms) != 0)
2052 return 0;
2053
2054 return statusParms.dwReturn;
2055 }
2056
2057 //---------------------------------------------------------------------------
2058 // wxMCIMediaBackend::Move
2059 //
2060 // Moves the window to a location
2061 //---------------------------------------------------------------------------
2062 void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y),
2063 int w, int h)
2064 {
2065 if (m_hNotifyWnd && m_bVideo)
2066 {
2067 MCI_DGV_RECT_PARMS putParms; //ifdefed MCI_DGV_PUT_PARMS
2068 putParms.rc.top = 0;
2069 putParms.rc.bottom = 0;
2070 putParms.rc.right = w;
2071 putParms.rc.bottom = h;
2072
2073 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_PUT,
2074 0x00040000L, //MCI_DGV_PUT_DESTINATION
2075 (DWORD)(LPSTR)&putParms) );
2076 }
2077 }
2078
2079 //---------------------------------------------------------------------------
2080 // wxMCIMediaBackend::GetVideoSize
2081 //
2082 // Gets the original size of the movie for sizers
2083 //---------------------------------------------------------------------------
2084 wxSize wxMCIMediaBackend::GetVideoSize() const
2085 {
2086 if(m_bVideo)
2087 {
2088 MCI_DGV_RECT_PARMS whereParms; //ifdefed MCI_DGV_WHERE_PARMS
2089
2090 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_WHERE,
2091 0x00020000L, //MCI_DGV_WHERE_SOURCE
2092 (DWORD)(LPSTR)&whereParms) );
2093
2094 return wxSize(whereParms.rc.right, whereParms.rc.bottom);
2095 }
2096 return wxSize(0,0);
2097 }
2098
2099 //---------------------------------------------------------------------------
2100 // wxMCIMediaBackend::GetPlaybackRate
2101 //
2102 // TODO
2103 //---------------------------------------------------------------------------
2104 double wxMCIMediaBackend::GetPlaybackRate()
2105 {
2106 return 1.0;
2107 }
2108
2109 //---------------------------------------------------------------------------
2110 // wxMCIMediaBackend::SetPlaybackRate
2111 //
2112 // TODO
2113 //---------------------------------------------------------------------------
2114 bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate))
2115 {
2116 /*
2117 MCI_WAVE_SET_SAMPLESPERSEC
2118 MCI_DGV_SET_PARMS setParms;
2119 setParms.dwSpeed = (DWORD) (dRate * 1000.0);
2120
2121 return (mciSendCommand(m_hDev, MCI_SET,
2122 0x00020000L, //MCI_DGV_SET_SPEED
2123 (DWORD)(LPSTR)&setParms) == 0);
2124 */
2125 return false;
2126 }
2127
2128 //---------------------------------------------------------------------------
2129 // [static] wxMCIMediaBackend::MSWWindowProc
2130 //
2131 // Here we process a message when MCI reaches the stopping point
2132 // in the stream
2133 //---------------------------------------------------------------------------
2134 LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg,
2135 WPARAM wParam,
2136 LPARAM lParam)
2137 {
2138 wxMCIMediaBackend* backend = (wxMCIMediaBackend*)
2139 ::GetWindowLong(hWnd, GWL_USERDATA);
2140 wxASSERT(backend);
2141
2142 return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam);
2143 }
2144
2145 LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg,
2146 WPARAM wParam,
2147 LPARAM lParam)
2148 {
2149 if(nMsg == MM_MCINOTIFY)
2150 {
2151 wxASSERT(lParam == (LPARAM) m_hDev);
2152 if(wParam == MCI_NOTIFY_SUCCESSFUL && lParam == (LPARAM)m_hDev)
2153 {
2154 wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
2155 m_ctrl->ProcessEvent(theEvent);
2156
2157 if(theEvent.IsAllowed())
2158 {
2159 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_SEEK,
2160 MCI_SEEK_TO_START, 0) );
2161
2162 //send the event to our child
2163 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
2164 m_ctrl->GetId());
2165 m_ctrl->ProcessEvent(theEvent);
2166 }
2167 }
2168 }
2169 return DefWindowProc(hWnd, nMsg, wParam, lParam);
2170 }
2171 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2172 //
2173 // wxQTMediaBackend
2174 //
2175 // TODO: Use a less cludgy way to pause/get state/set state
2176 // TODO: Dynamically load from qtml.dll
2177 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2178
2179 #if wxUSE_QUICKTIME
2180
2181 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend);
2182
2183 //Time between timer calls
2184 #define MOVIE_DELAY 100
2185
2186 #include "wx/timer.h"
2187
2188 // --------------------------------------------------------------------------
2189 // wxQTTimer - Handle Asyncronous Playing
2190 // --------------------------------------------------------------------------
2191 class _wxQTTimer : public wxTimer
2192 {
2193 public:
2194 _wxQTTimer(Movie movie, wxQTMediaBackend* parent, wxQuickTimeLibrary* pLib) :
2195 m_movie(movie), m_bPaused(false), m_parent(parent), m_pLib(pLib)
2196 {
2197 }
2198
2199 ~_wxQTTimer()
2200 {
2201 }
2202
2203 bool GetPaused() {return m_bPaused;}
2204 void SetPaused(bool bPaused) {m_bPaused = bPaused;}
2205
2206 //-----------------------------------------------------------------------
2207 // _wxQTTimer::Notify
2208 //
2209 // 1) Checks to see if the movie is done, and if not continues
2210 // streaming the movie
2211 // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
2212 // the movie.
2213 //-----------------------------------------------------------------------
2214 void Notify()
2215 {
2216 if (!m_bPaused)
2217 {
2218 if(!m_pLib->IsMovieDone(m_movie))
2219 m_pLib->MoviesTask(m_movie, MOVIE_DELAY);
2220 else
2221 {
2222 wxMediaEvent theEvent(wxEVT_MEDIA_STOP,
2223 m_parent->m_ctrl->GetId());
2224 m_parent->m_ctrl->ProcessEvent(theEvent);
2225
2226 if(theEvent.IsAllowed())
2227 {
2228 Stop();
2229 m_parent->Stop();
2230 wxASSERT(m_pLib->GetMoviesError() == noErr);
2231
2232 //send the event to our child
2233 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
2234 m_parent->m_ctrl->GetId());
2235 m_parent->m_ctrl->ProcessEvent(theEvent);
2236 }
2237 }
2238 }
2239 }
2240
2241 protected:
2242 Movie m_movie; //Our movie instance
2243 bool m_bPaused; //Whether we are paused or not
2244 wxQTMediaBackend* m_parent; //Backend pointer
2245 wxQuickTimeLibrary* m_pLib; //Interfaces
2246 };
2247
2248 //---------------------------------------------------------------------------
2249 // wxQTMediaBackend Destructor
2250 //
2251 // Sets m_timer to NULL signifying we havn't loaded anything yet
2252 //---------------------------------------------------------------------------
2253 wxQTMediaBackend::wxQTMediaBackend() : m_timer(NULL)
2254 {
2255 }
2256
2257 //---------------------------------------------------------------------------
2258 // wxQTMediaBackend Destructor
2259 //
2260 // 1) Cleans up the QuickTime movie instance
2261 // 2) Decrements the QuickTime reference counter - if this reaches
2262 // 0, QuickTime shuts down
2263 // 3) Decrements the QuickTime Windows Media Layer reference counter -
2264 // if this reaches 0, QuickTime shuts down the Windows Media Layer
2265 //---------------------------------------------------------------------------
2266 wxQTMediaBackend::~wxQTMediaBackend()
2267 {
2268 if(m_timer)
2269 Cleanup();
2270
2271 if(m_lib.IsOk())
2272 {
2273 //Note that ExitMovies() is not neccessary, but
2274 //the docs are fuzzy on whether or not TerminateQTML is
2275 m_lib.ExitMovies();
2276 m_lib.TerminateQTML();
2277 }
2278 }
2279
2280 //---------------------------------------------------------------------------
2281 // wxQTMediaBackend::CreateControl
2282 //
2283 // 1) Intializes QuickTime
2284 // 2) Creates the control window
2285 //---------------------------------------------------------------------------
2286 bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
2287 wxWindowID id,
2288 const wxPoint& pos,
2289 const wxSize& size,
2290 long style,
2291 const wxValidator& validator,
2292 const wxString& name)
2293 {
2294 if(!m_lib.Initialize())
2295 return false;
2296
2297 int nError;
2298 if ((nError = m_lib.InitializeQTML(0)) != noErr) //-2093 no dll
2299 {
2300 wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
2301 return false;
2302 }
2303 m_lib.EnterMovies();
2304
2305 //
2306 // Create window
2307 // By default wxWindow(s) is created with a border -
2308 // so we need to get rid of those
2309 //
2310 // Since we don't have a child window like most other
2311 // backends, we don't need wxCLIP_CHILDREN
2312 //
2313 if ( !ctrl->wxControl::Create(parent, id, pos, size,
2314 (style & ~wxBORDER_MASK) | wxBORDER_NONE,
2315 validator, name) )
2316 return false;
2317
2318 m_ctrl = ctrl;
2319 return true;
2320 }
2321
2322 //---------------------------------------------------------------------------
2323 // wxQTMediaBackend::Load (file version)
2324 //
2325 // 1) Get an FSSpec from the Windows path name
2326 // 2) Open the movie
2327 // 3) Obtain the movie instance from the movie resource
2328 // 4)
2329 //---------------------------------------------------------------------------
2330 bool wxQTMediaBackend::Load(const wxString& fileName)
2331 {
2332 if(m_timer)
2333 Cleanup();
2334
2335 OSErr err = noErr;
2336 short movieResFile;
2337 FSSpec sfFile;
2338
2339 if (m_lib.NativePathNameToFSSpec ((char*) (const char*) fileName.mb_str(),
2340 &sfFile, 0) != noErr)
2341 return false;
2342
2343 if (m_lib.OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
2344 return false;
2345
2346 short movieResID = 0;
2347 Str255 movieName;
2348
2349 err = m_lib.NewMovieFromFile (
2350 &m_movie,
2351 movieResFile,
2352 &movieResID,
2353 movieName,
2354 newMovieActive,
2355 NULL); //wasChanged
2356
2357 m_lib.CloseMovieFile (movieResFile);
2358
2359 if (err != noErr)
2360 return false;
2361
2362 FinishLoad();
2363
2364 return m_lib.GetMoviesError() == noErr;
2365 }
2366
2367 //---------------------------------------------------------------------------
2368 // wxQTMediaBackend::Move
2369 //
2370 // TODO
2371 //---------------------------------------------------------------------------
2372 bool wxQTMediaBackend::Load(const wxURI& location)
2373 {
2374 if(m_timer)
2375 Cleanup();
2376
2377 wxString theURI = location.BuildURI();
2378
2379 OSErr err = noErr;
2380
2381 Handle theHandle = m_lib.NewHandleClear(theURI.length() + 1);
2382 wxASSERT(theHandle);
2383
2384 m_lib.BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1);
2385
2386 //create the movie from the handle that refers to the URI
2387 err = m_lib.NewMovieFromDataRef(&m_movie, newMovieActive,
2388 NULL, theHandle,
2389 'url'); //URLDataHandlerSubType
2390
2391 m_lib.DisposeHandle(theHandle);
2392
2393 if (err != noErr)
2394 return false;
2395
2396 //preroll movie for streaming
2397 //TODO:Async this?
2398 /*
2399 TimeValue timeNow;
2400 Fixed playRate;
2401 timeNow = GetMovieTime(m_movie, NULL);
2402 playRate = GetMoviePreferredRate(m_movie);
2403 PrePrerollMovie(m_movie, timeNow, playRate, NULL, NULL);
2404 PrerollMovie(m_movie, timeNow, playRate);
2405 m_lib.SetMovieRate(m_movie, playRate);
2406 */
2407
2408 FinishLoad();
2409
2410 return m_lib.GetMoviesError() == noErr;
2411 }
2412
2413 //---------------------------------------------------------------------------
2414 // wxQTMediaBackend::Move
2415 //
2416 // TODO
2417 //---------------------------------------------------------------------------
2418 void wxQTMediaBackend::FinishLoad()
2419 {
2420 m_timer = new _wxQTTimer(m_movie, (wxQTMediaBackend*) this, &m_lib);
2421 wxASSERT(m_timer);
2422
2423 //get the real size of the movie
2424 Rect outRect;
2425 m_lib.GetMovieNaturalBoundsRect (m_movie, &outRect);
2426 wxASSERT(m_lib.GetMoviesError() == noErr);
2427
2428 m_bestSize.x = outRect.right - outRect.left;
2429 m_bestSize.y = outRect.bottom - outRect.top;
2430
2431 //reparent movie/*AudioMediaCharacteristic*/
2432 if(m_lib.GetMovieIndTrackType(m_movie, 1,
2433 'eyes', //VisualMediaCharacteristic,
2434 (1 << 1) //movieTrackCharacteristic
2435 | (1 << 2) //movieTrackEnabledOnly
2436 ) != NULL)
2437 {
2438 m_lib.CreatePortAssociation(m_ctrl->GetHWND(), NULL, 0L);
2439
2440 m_lib.SetMovieGWorld(m_movie,
2441 (CGrafPtr) m_lib.GetNativeWindowPort(m_ctrl->GetHWND()),
2442 NULL);
2443 }
2444
2445 //we want millisecond precision
2446 m_lib.SetMovieTimeScale(m_movie, 1000);
2447 wxASSERT(m_lib.GetMoviesError() == noErr);
2448
2449 //
2450 //Here, if the parent of the control has a sizer - we
2451 //tell it to recalculate the size of this control since
2452 //the user opened a seperate media file
2453 //
2454 m_ctrl->InvalidateBestSize();
2455 m_ctrl->GetParent()->Layout();
2456 m_ctrl->GetParent()->Refresh();
2457 m_ctrl->GetParent()->Update();
2458 }
2459
2460 //---------------------------------------------------------------------------
2461 // wxQTMediaBackend::Move
2462 //
2463 // TODO
2464 //---------------------------------------------------------------------------
2465 bool wxQTMediaBackend::Play()
2466 {
2467 m_lib.StartMovie(m_movie);
2468 m_timer->SetPaused(false);
2469 m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
2470 return m_lib.GetMoviesError() == noErr;
2471 }
2472
2473 //---------------------------------------------------------------------------
2474 // wxQTMediaBackend::Move
2475 //
2476 // TODO
2477 //---------------------------------------------------------------------------
2478 bool wxQTMediaBackend::Pause()
2479 {
2480 m_lib.StopMovie(m_movie);
2481 m_timer->SetPaused(true);
2482 m_timer->Stop();
2483 return m_lib.GetMoviesError() == noErr;
2484 }
2485
2486 //---------------------------------------------------------------------------
2487 // wxQTMediaBackend::Move
2488 //
2489 // TODO
2490 //---------------------------------------------------------------------------
2491 bool wxQTMediaBackend::Stop()
2492 {
2493 m_timer->SetPaused(false);
2494 m_timer->Stop();
2495
2496 m_lib.StopMovie(m_movie);
2497 if(m_lib.GetMoviesError() != noErr)
2498 return false;
2499
2500 m_lib.GoToBeginningOfMovie(m_movie);
2501 return m_lib.GetMoviesError() == noErr;
2502 }
2503
2504 //---------------------------------------------------------------------------
2505 // wxQTMediaBackend::Move
2506 //
2507 // TODO
2508 //---------------------------------------------------------------------------
2509 double wxQTMediaBackend::GetPlaybackRate()
2510 {
2511 return ( ((double)m_lib.GetMovieRate(m_movie)) / 0x10000);
2512 }
2513
2514 //---------------------------------------------------------------------------
2515 // wxQTMediaBackend::Move
2516 //
2517 // TODO
2518 //---------------------------------------------------------------------------
2519 bool wxQTMediaBackend::SetPlaybackRate(double dRate)
2520 {
2521 m_lib.SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
2522 return m_lib.GetMoviesError() == noErr;
2523 }
2524
2525 //---------------------------------------------------------------------------
2526 // wxQTMediaBackend::Move
2527 //
2528 // TODO
2529 //---------------------------------------------------------------------------
2530 bool wxQTMediaBackend::SetPosition(wxLongLong where)
2531 {
2532 TimeRecord theTimeRecord;
2533 memset(&theTimeRecord, 0, sizeof(TimeRecord));
2534 theTimeRecord.value.lo = where.GetValue();
2535 theTimeRecord.scale = m_lib.GetMovieTimeScale(m_movie);
2536 theTimeRecord.base = m_lib.GetMovieTimeBase(m_movie);
2537 m_lib.SetMovieTime(m_movie, &theTimeRecord);
2538
2539 if (m_lib.GetMoviesError() != noErr)
2540 return false;
2541
2542 return true;
2543 }
2544
2545 //---------------------------------------------------------------------------
2546 // wxQTMediaBackend::GetPosition
2547 //
2548 // 1) Calls GetMovieTime to get the position we are in in the movie
2549 // in milliseconds (we called
2550 //---------------------------------------------------------------------------
2551 wxLongLong wxQTMediaBackend::GetPosition()
2552 {
2553 return m_lib.GetMovieTime(m_movie, NULL);
2554 }
2555
2556 //---------------------------------------------------------------------------
2557 // wxQTMediaBackend::GetVolume
2558 //
2559 // Gets the volume through GetMovieVolume - which returns a 16 bit short -
2560 //
2561 // +--------+--------+
2562 // + (1) + (2) +
2563 // +--------+--------+
2564 //
2565 // (1) first 8 bits are value before decimal
2566 // (2) second 8 bits are value after decimal
2567 //
2568 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
2569 // 1 (full gain and sound)
2570 //---------------------------------------------------------------------------
2571 double wxQTMediaBackend::GetVolume()
2572 {
2573 short sVolume = m_lib.GetMovieVolume(m_movie);
2574
2575 if(sVolume & (128 << 8)) //negative - no sound
2576 return 0.0;
2577
2578 return (sVolume & (127 << 8)) ? 1.0 : ((double)(sVolume & 255)) / 255.0;
2579 }
2580
2581 //---------------------------------------------------------------------------
2582 // wxQTMediaBackend::SetVolume
2583 //
2584 // Sets the volume through SetMovieVolume - which takes a 16 bit short -
2585 //
2586 // +--------+--------+
2587 // + (1) + (2) +
2588 // +--------+--------+
2589 //
2590 // (1) first 8 bits are value before decimal
2591 // (2) second 8 bits are value after decimal
2592 //
2593 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
2594 // 1 (full gain and sound)
2595 //---------------------------------------------------------------------------
2596 bool wxQTMediaBackend::SetVolume(double dVolume)
2597 {
2598 short sVolume = (dVolume >= .9999 ? 1 << 8 :
2599 (short) (dVolume * 255));
2600 m_lib.SetMovieVolume(m_movie, sVolume);
2601 return true;
2602 }
2603
2604 //---------------------------------------------------------------------------
2605 // wxQTMediaBackend::Move
2606 //
2607 // TODO
2608 //---------------------------------------------------------------------------
2609 wxLongLong wxQTMediaBackend::GetDuration()
2610 {
2611 return m_lib.GetMovieDuration(m_movie);
2612 }
2613
2614 //---------------------------------------------------------------------------
2615 // wxQTMediaBackend::Move
2616 //
2617 // TODO
2618 //---------------------------------------------------------------------------
2619 wxMediaState wxQTMediaBackend::GetState()
2620 {
2621 if ( !m_timer || (m_timer->IsRunning() == false &&
2622 m_timer->GetPaused() == false) )
2623 return wxMEDIASTATE_STOPPED;
2624
2625 if( m_timer->IsRunning() == true )
2626 return wxMEDIASTATE_PLAYING;
2627 else
2628 return wxMEDIASTATE_PAUSED;
2629 }
2630
2631 //---------------------------------------------------------------------------
2632 // wxQTMediaBackend::Move
2633 //
2634 // TODO
2635 //---------------------------------------------------------------------------
2636 void wxQTMediaBackend::Cleanup()
2637 {
2638 delete m_timer;
2639 m_timer = NULL;
2640
2641 m_lib.StopMovie(m_movie);
2642 m_lib.DisposeMovie(m_movie);
2643 }
2644
2645 //---------------------------------------------------------------------------
2646 // wxQTMediaBackend::Move
2647 //
2648 // TODO
2649 //---------------------------------------------------------------------------
2650 wxSize wxQTMediaBackend::GetVideoSize() const
2651 {
2652 return m_bestSize;
2653 }
2654
2655 //---------------------------------------------------------------------------
2656 // wxQTMediaBackend::Move
2657 //
2658 // TODO
2659 //---------------------------------------------------------------------------
2660 void wxQTMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), int w, int h)
2661 {
2662 if(m_timer)
2663 {
2664 Rect theRect = {0, 0, h, w};
2665
2666 m_lib.SetMovieBox(m_movie, &theRect);
2667 wxASSERT(m_lib.GetMoviesError() == noErr);
2668 }
2669 }
2670
2671 //---------------------------------------------------------------------------
2672 // End QT Compilation Guard
2673 //---------------------------------------------------------------------------
2674 #endif //wxUSE_QUICKTIME
2675
2676 //in source file that contains stuff you don't directly use
2677 #include <wx/html/forcelnk.h>
2678 FORCE_LINK_ME(basewxmediabackends);
2679
2680 //---------------------------------------------------------------------------
2681 // End wxMediaCtrl Compilation Guard and this file
2682 //---------------------------------------------------------------------------
2683 #endif //wxUSE_MEDIACTRL
2684
2685
wxWidgets (Impactor)