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


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