]> git.saurik.com Git - wxWidgets.git/blob - src/msw/mediactrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Warning fix and source cleaning.
[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 // DirectShow includes
68 //---------------------------------------------------------------------------
69 #include <dshow.h>
70
71 class WXDLLIMPEXP_MEDIA wxAMMediaBackend : public wxMediaBackend
72 {
73 public:
74 wxAMMediaBackend();
75
76 virtual ~wxAMMediaBackend();
77
78 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
79 wxWindowID id,
80 const wxPoint& pos,
81 const wxSize& size,
82 long style,
83 const wxValidator& validator,
84 const wxString& name);
85
86 virtual bool Play();
87 virtual bool Pause();
88 virtual bool Stop();
89
90 virtual bool Load(const wxString& fileName);
91 virtual bool Load(const wxURI& location);
92
93 virtual wxMediaState GetState();
94
95 virtual bool SetPosition(wxLongLong where);
96 virtual wxLongLong GetPosition();
97 virtual wxLongLong GetDuration();
98
99 virtual void Move(int x, int y, int w, int h);
100 wxSize GetVideoSize() const;
101
102 virtual double GetPlaybackRate();
103 virtual bool SetPlaybackRate(double);
104
105 void Cleanup();
106
107 bool m_bVideo;
108
109 static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg,
110 WPARAM wParam, LPARAM lParam);
111
112 LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg,
113 WPARAM wParam, LPARAM lParam);
114
115 wxControl* m_ctrl;
116
117 IGraphBuilder* m_pGB;
118 IMediaControl* m_pMC;
119 IMediaEventEx* m_pME;
120 IVideoWindow* m_pVW;
121 IBasicAudio* m_pBA;
122 IBasicVideo* m_pBV;
123 IMediaSeeking* m_pMS;
124
125 HWND m_hNotifyWnd;
126 wxSize m_bestSize;
127
128 DECLARE_DYNAMIC_CLASS(wxAMMediaBackend);
129 };
130
131 #endif //wxUSE_DIRECTSHOW
132
133 //---------------------------------------------------------------------------
134 //
135 // wxMCIMediaBackend
136 //
137 //---------------------------------------------------------------------------
138
139 //---------------------------------------------------------------------------
140 // MCI Includes
141 //---------------------------------------------------------------------------
142 #include <mmsystem.h>
143
144 class WXDLLIMPEXP_MEDIA wxMCIMediaBackend : public wxMediaBackend
145 {
146 public:
147
148 wxMCIMediaBackend();
149 ~wxMCIMediaBackend();
150
151 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
152 wxWindowID id,
153 const wxPoint& pos,
154 const wxSize& size,
155 long style,
156 const wxValidator& validator,
157 const wxString& name);
158
159 virtual bool Play();
160 virtual bool Pause();
161 virtual bool Stop();
162
163 virtual bool Load(const wxString& fileName);
164 virtual bool Load(const wxURI& location);
165
166 virtual wxMediaState GetState();
167
168 virtual bool SetPosition(wxLongLong where);
169 virtual wxLongLong GetPosition();
170 virtual wxLongLong GetDuration();
171
172 virtual void Move(int x, int y, int w, int h);
173 wxSize GetVideoSize() const;
174
175 virtual double GetPlaybackRate();
176 virtual bool SetPlaybackRate(double dRate);
177
178 static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg,
179 WPARAM wParam, LPARAM lParam);
180
181 LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg,
182 WPARAM wParam, LPARAM lParam);
183
184 MCIDEVICEID m_hDev; //Our MCI Device ID/Handler
185 wxControl* m_ctrl; //Parent control
186 HWND m_hNotifyWnd; //Window to use for MCI events
187 bool m_bVideo; //Whether or not we have video
188
189 DECLARE_DYNAMIC_CLASS(wxMCIMediaBackend);
190 };
191
192 //---------------------------------------------------------------------------
193 //
194 // wxQTMediaBackend
195 //
196 //---------------------------------------------------------------------------
197
198 //---------------------------------------------------------------------------
199 // QT Compilation Guard
200 //---------------------------------------------------------------------------
201 #if wxUSE_QUICKTIME
202
203 //---------------------------------------------------------------------------
204 // QT Includes
205 //---------------------------------------------------------------------------
206 #include <qtml.h> //Windoze QT include
207 #include <QuickTimeComponents.h> //Standard QT stuff
208
209 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackend
210 {
211 public:
212
213 wxQTMediaBackend();
214 ~wxQTMediaBackend();
215
216 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
217 wxWindowID id,
218 const wxPoint& pos,
219 const wxSize& size,
220 long style,
221 const wxValidator& validator,
222 const wxString& name);
223
224 virtual bool Play();
225 virtual bool Pause();
226 virtual bool Stop();
227
228 virtual bool Load(const wxString& fileName);
229 virtual bool Load(const wxURI& location);
230
231 virtual wxMediaState GetState();
232
233 virtual bool SetPosition(wxLongLong where);
234 virtual wxLongLong GetPosition();
235 virtual wxLongLong GetDuration();
236
237 virtual void Move(int x, int y, int w, int h);
238 wxSize GetVideoSize() const;
239
240 virtual double GetPlaybackRate();
241 virtual bool SetPlaybackRate(double dRate);
242
243 void Cleanup();
244 void FinishLoad();
245
246 wxSize m_bestSize; //Original movie size
247 struct MovieRecord* m_movie; //QT Movie handle/instance
248 wxControl* m_ctrl; //Parent control
249 bool m_bVideo; //Whether or not we have video
250 class _wxQTTimer* m_timer; //Timer for streaming the movie
251
252 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend);
253 };
254
255 //---------------------------------------------------------------------------
256 // End QT Compilation Guard
257 //---------------------------------------------------------------------------
258 #endif //wxUSE_QUICKTIME
259
260 //===========================================================================
261 // IMPLEMENTATION
262 //===========================================================================
263
264 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
265 //
266 // wxAMMediaBackend
267 //
268 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
269
270 //---------------------------------------------------------------------------
271 // Only use if user wants it -
272 //---------------------------------------------------------------------------
273 #if wxUSE_DIRECTSHOW
274
275 IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend, wxMediaBackend);
276
277 // Numerical value for when the graph reaches the stop position
278 #define WM_GRAPHNOTIFY WM_USER+13
279
280 //---------------------------------------------------------------------------
281 // Usual debugging macros
282 //---------------------------------------------------------------------------
283 #ifdef __WXDEBUG__
284 #define wxAMVERIFY(x) \
285 { \
286 HRESULT hrdsv = (x); \
287 if ( FAILED(hrdsv) ) \
288 { \
289 /*TCHAR szError[MAX_ERROR_TEXT_LEN];*/ \
290 /*if( AMGetErrorText(hrdsv, szError, MAX_ERROR_TEXT_LEN) == 0)*/ \
291 /*{*/ \
292 /*wxFAIL_MSG( wxString::Format(wxT("DirectShow error \"%s\" ")*/\
293 /*wxT("occured at line %i in ")*/ \
294 /*wxT("mediactrl.cpp"),*/ \
295 /*szError, __LINE__) );*/ \
296 /*}*/ \
297 /*else*/ \
298 wxFAIL_MSG( wxString::Format(wxT("Unknown error (%i) ") \
299 wxT("occured at") \
300 wxT(" line %i in mediactrl.cpp."), \
301 (int)hrdsv, __LINE__) ); \
302 } \
303 }
304 #define wxVERIFY(x) wxASSERT((x))
305 #else
306 #define wxAMVERIFY(x) (x)
307 #define wxVERIFY(x) (x)
308 #endif
309
310 //---------------------------------------------------------------------------
311 // Standard macros for ease of use
312 //---------------------------------------------------------------------------
313 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
314
315 //---------------------------------------------------------------------------
316 // wxAMMediaBackend Constructor
317 //
318 // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet
319 //---------------------------------------------------------------------------
320 wxAMMediaBackend::wxAMMediaBackend() : m_hNotifyWnd(NULL)
321 {
322 }
323
324 //---------------------------------------------------------------------------
325 // wxAMMediaBackend Destructor
326 //
327 // Cleans up everything
328 //---------------------------------------------------------------------------
329 wxAMMediaBackend::~wxAMMediaBackend()
330 {
331 if (m_hNotifyWnd)
332 Cleanup();
333 }
334
335 //---------------------------------------------------------------------------
336 // wxAMMediaBackend::CreateControl
337 //
338 // ActiveMovie does not really have any native control to speak of,
339 // so we just create a normal control.
340 //
341 // We also check to see if ActiveMovie is installed
342 //---------------------------------------------------------------------------
343 bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
344 wxWindowID id,
345 const wxPoint& pos,
346 const wxSize& size,
347 long style,
348 const wxValidator& validator,
349 const wxString& name)
350 {
351 //create our filter graph
352 HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
353 IID_IGraphBuilder, (void**)&m_pGB);
354
355 //directshow not installed?
356 if ( FAILED(hr) )
357 return false;
358
359 //release the filter graph - we don't need it yet
360 m_pGB->Release();
361 m_pGB = NULL;
362
363 //
364 // Create window
365 // By default wxWindow(s) is created with a border -
366 // so we need to get rid of those, and create with
367 // wxCLIP_CHILDREN, so that if the driver/backend
368 // is a child window, it refereshes properly
369 //
370 if ( !ctrl->wxControl::Create(parent, id, pos, size,
371 (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
372 validator, name) )
373 return false;
374
375 m_ctrl = ctrl;
376 return true;
377 }
378
379
380 //---------------------------------------------------------------------------
381 // wxAMMediaBackend::Load (file version)
382 //
383 // Creates an Active Movie filter graph from a file or url
384 //---------------------------------------------------------------------------
385 bool wxAMMediaBackend::Load(const wxString& fileName)
386 {
387 if(m_hNotifyWnd)
388 Cleanup();
389
390 CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
391 IID_IGraphBuilder, (void**)&m_pGB);
392
393 //load the graph & render
394 if( FAILED(m_pGB->RenderFile(fileName.wc_str(wxConvLocal), NULL)) )
395 return false;
396
397 //get the interfaces, all of them
398 wxAMVERIFY( m_pGB->QueryInterface(IID_IMediaControl, (void**)&m_pMC) );
399 wxAMVERIFY( m_pGB->QueryInterface(IID_IMediaEventEx, (void**)&m_pME) );
400 wxAMVERIFY( m_pGB->QueryInterface(IID_IMediaSeeking, (void**)&m_pMS) );
401 wxAMVERIFY( m_pGB->QueryInterface(IID_IVideoWindow, (void**)&m_pVW) );
402 wxAMVERIFY( m_pGB->QueryInterface(IID_IBasicAudio, (void**)&m_pBA) );
403 wxAMVERIFY( m_pGB->QueryInterface(IID_IBasicVideo, (void**)&m_pBV) );
404
405 //We could tell if the media has audio or not by
406 //something like
407 //-----
408 //long lVolume;
409 //pBA->get_Volume(&lVolume) == E_NOTIMPL
410 //-----
411 //here...
412
413 //
414 //Obtain the _actual_ size of the movie & remember it
415 //
416 long nX,
417 nY;
418
419 m_bestSize.x = m_bestSize.y = 0;
420
421 m_bVideo = SUCCEEDED( m_pVW->GetWindowPosition( &nX,
422 &nY,
423 (long*)&m_bestSize.x,
424 (long*)&m_bestSize.y) );
425
426 //
427 //If we have video in the media - set it up so that
428 //its a child window of the control, its visible,
429 //and that the control is the owner of the video window
430 //
431 if (m_bVideo)
432 {
433 wxAMVERIFY( m_pVW->put_Owner((OAHWND)m_ctrl->GetHandle()) );
434 wxAMVERIFY( m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS) );
435 wxAMVERIFY( m_pVW->put_Visible(OATRUE) ); //OATRUE == -1
436 }
437
438 //
439 // Create a hidden window and register to handle
440 // directshow events for this graph
441 // Note that wxCanvasClassName is already registered
442 // and used by all wxWindows and normal wxControls
443 //
444 m_hNotifyWnd = ::CreateWindow
445 (
446 wxCanvasClassName,
447 NULL,
448 0, 0, 0, 0,
449 0,
450 (HWND) NULL,
451 (HMENU)NULL,
452 wxGetInstance(),
453 (LPVOID) NULL
454 );
455
456 if(!m_hNotifyWnd)
457 {
458 wxLogSysError( wxT("Could not create hidden needed for ")
459 wxT("registering for DirectShow events!") );
460
461 return false;
462 }
463
464 ::SetWindowLongPtr(m_hNotifyWnd, GWLP_WNDPROC,
465 (LONG_PTR)wxAMMediaBackend::NotifyWndProc);
466
467 ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA,
468 (LONG) this);
469
470 wxAMVERIFY( m_pME->SetNotifyWindow((OAHWND)m_hNotifyWnd,
471 WM_GRAPHNOTIFY, 0) );
472
473 //
474 //set the time format
475 //
476 wxAMVERIFY( m_pMS->SetTimeFormat(&TIME_FORMAT_MEDIA_TIME) );
477
478 //
479 // Force the parent window of this control to recalculate
480 // the size of this if sizers are being used
481 // and render the results immediately
482 //
483 m_ctrl->InvalidateBestSize();
484 m_ctrl->GetParent()->Layout();
485 m_ctrl->GetParent()->Refresh();
486 m_ctrl->GetParent()->Update();
487
488 return true;
489 }
490
491 //---------------------------------------------------------------------------
492 // wxAMMediaBackend::Load (URL Version)
493 //
494 // Loads media from a URL. Interestingly enough DirectShow
495 // appears (?) to escape the URL for us, at least on normal
496 // files
497 //---------------------------------------------------------------------------
498 bool wxAMMediaBackend::Load(const wxURI& location)
499 {
500 return Load(location.BuildUnescapedURI());
501 }
502
503 //---------------------------------------------------------------------------
504 // wxAMMediaBackend::Play
505 //
506 // Plays the stream. If it is non-seekable, it will restart it.
507 //---------------------------------------------------------------------------
508 bool wxAMMediaBackend::Play()
509 {
510 return SUCCEEDED( m_pMC->Run() );
511 }
512
513 //---------------------------------------------------------------------------
514 // wxAMMediaBackend::Pause
515 //
516 // Pauses the stream.
517 //---------------------------------------------------------------------------
518 bool wxAMMediaBackend::Pause()
519 {
520 return SUCCEEDED( m_pMC->Pause() );
521 }
522
523 //---------------------------------------------------------------------------
524 // wxAMMediaBackend::Stop
525 //
526 // Stops the stream.
527 //---------------------------------------------------------------------------
528 bool wxAMMediaBackend::Stop()
529 {
530 bool bOK = SUCCEEDED( m_pMC->Stop() );
531
532 //We don't care if it can't get to the beginning in directshow -
533 //it could be a non-seeking filter (wince midi) in which case playing
534 //starts all over again
535 SetPosition(0);
536 return bOK;
537 }
538
539 //---------------------------------------------------------------------------
540 // wxAMMediaBackend::SetPosition
541 //
542 // 1) Translates the current position's time to directshow time,
543 // which is in a scale of 100 nanoseconds
544 // 2) Sets the play position of the IMediaSeeking interface -
545 // passing NULL as the stop position means to keep the old
546 // stop position
547 //---------------------------------------------------------------------------
548 bool wxAMMediaBackend::SetPosition(wxLongLong where)
549 {
550 LONGLONG pos = ((LONGLONG)where.GetValue()) * 10000;
551
552 return SUCCEEDED( m_pMS->SetPositions(
553 &pos,
554 AM_SEEKING_AbsolutePositioning,
555 NULL,
556 AM_SEEKING_NoPositioning
557 ) );
558 }
559
560 //---------------------------------------------------------------------------
561 // wxAMMediaBackend::GetPosition
562 //
563 // 1) Obtains the current play and stop positions from IMediaSeeking
564 // 2) Returns the play position translated to our time base
565 //---------------------------------------------------------------------------
566 wxLongLong wxAMMediaBackend::GetPosition()
567 {
568 LONGLONG outCur, outStop;
569 wxAMVERIFY( m_pMS->GetPositions(&outCur, &outStop) );
570
571 //h,m,s,milli - outdur is in 100 nanos
572 return outCur/10000;
573 }
574
575 //---------------------------------------------------------------------------
576 // wxAMMediaBackend::GetDuration
577 //
578 // 1) Obtains the duration of the media from the IMediaSeeking interface
579 // 2) Converts that value to our time base, and returns it
580 //---------------------------------------------------------------------------
581 wxLongLong wxAMMediaBackend::GetDuration()
582 {
583 LONGLONG outDuration;
584 wxAMVERIFY( m_pMS->GetDuration(&outDuration) );
585
586 //h,m,s,milli - outdur is in 100 nanos
587 return outDuration/10000;
588 }
589
590 //---------------------------------------------------------------------------
591 // wxAMMediaBackend::GetState
592 //
593 // Obtains the state from the IMediaControl interface.
594 // Note that it's enumeration values for stopping/playing
595 // etc. are the same as ours, so we just do a straight cast.
596 // TODO: MS recommends against INFINITE here for
597 // IMediaControl::GetState- do it in stages
598 //---------------------------------------------------------------------------
599 wxMediaState wxAMMediaBackend::GetState()
600 {
601 HRESULT hr;
602 OAFilterState theState;
603 hr = m_pMC->GetState(INFINITE, &theState);
604
605 wxASSERT( SUCCEEDED(hr) );
606
607 //MSW state is the same as ours
608 //State_Stopped = 0,
609 //State_Paused = State_Stopped + 1,
610 //State_Running = State_Paused + 1
611
612 return (wxMediaState) theState;
613 }
614
615 //---------------------------------------------------------------------------
616 // wxAMMediaBackend::GetPlaybackRate
617 //
618 // Pretty simple way of obtaining the playback rate from
619 // the IMediaSeeking interface
620 //---------------------------------------------------------------------------
621 double wxAMMediaBackend::GetPlaybackRate()
622 {
623 double dRate;
624 wxAMVERIFY( m_pMS->GetRate(&dRate) );
625 return dRate;
626 }
627
628 //---------------------------------------------------------------------------
629 // wxAMMediaBackend::SetPlaybackRate
630 //
631 // Sets the playback rate of the media - DirectShow is pretty good
632 // about this, actually
633 //---------------------------------------------------------------------------
634 bool wxAMMediaBackend::SetPlaybackRate(double dRate)
635 {
636 return SUCCEEDED( m_pMS->SetRate(dRate) );
637 }
638
639 //---------------------------------------------------------------------------
640 // wxAMMediaBackend::NotifyWndProc
641 //
642 // Here we check to see if DirectShow tells us we've reached the stop
643 // position in our stream - if it has, it may not actually stop
644 // the stream - which we need to do...
645 //---------------------------------------------------------------------------
646 LRESULT CALLBACK wxAMMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg,
647 WPARAM wParam,
648 LPARAM lParam)
649 {
650 wxAMMediaBackend* backend = (wxAMMediaBackend*)
651 ::GetWindowLong(hWnd, GWL_USERDATA);
652
653 return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam);
654 }
655
656 LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg,
657 WPARAM wParam,
658 LPARAM lParam)
659 {
660 if (nMsg == WM_GRAPHNOTIFY)
661 {
662 LONG evCode,
663 evParam1,
664 evParam2;
665
666 //
667 // DirectShow keeps a list of queued events, and we need
668 // to go through them one by one, stopping at (Hopefully only one)
669 // EC_COMPLETE message
670 //
671 while(SUCCEEDED(m_pME->GetEvent(&evCode, (LONG_PTR *) &evParam1,
672 (LONG_PTR *) &evParam2, 0)
673 )
674 )
675 {
676 // Cleanup memory that GetEvent allocated
677 wxAMVERIFY( m_pME->FreeEventParams(evCode, evParam1, evParam2) );
678
679 // If this is the end of the clip, notify handler
680 if(EC_COMPLETE == evCode)
681 {
682 //send the event to our child
683 wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
684 m_ctrl->ProcessEvent(theEvent);
685
686 //if the user didn't veto it, stop the stream
687 if (theEvent.IsAllowed())
688 {
689 //Interestingly enough, DirectShow does not actually stop
690 //the filters - even when it reaches the end!
691 wxVERIFY( Stop() );
692
693 //send the event to our child
694 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
695 m_ctrl->GetId());
696 m_ctrl->ProcessEvent(theEvent);
697 }
698 }
699 }
700 }
701 return DefWindowProc(hWnd, nMsg, wParam, lParam);
702 }
703
704 //---------------------------------------------------------------------------
705 // wxAMMediaBackend::Cleanup
706 //
707 // 1) Hide/disowns the video window (MS says bad things will happen if
708 // you don't)
709 // 2) Releases all the directshow interfaces we use
710 // TODO: Maybe there's a way to redirect the IGraphBuilder each time
711 // we load, rather then creating and destroying the interfaces
712 // each time?
713 //---------------------------------------------------------------------------
714 void wxAMMediaBackend::Cleanup()
715 {
716 // Hide then disown the window
717 if(m_pVW)
718 {
719 m_pVW->put_Visible(OAFALSE); //OSFALSE == 0
720 m_pVW->put_Owner(NULL);
721 }
722
723 // Release and zero DirectShow interfaces
724 SAFE_RELEASE(m_pME);
725 SAFE_RELEASE(m_pMS);
726 SAFE_RELEASE(m_pMC);
727 SAFE_RELEASE(m_pBA);
728 SAFE_RELEASE(m_pBV);
729 SAFE_RELEASE(m_pVW);
730 SAFE_RELEASE(m_pGB);
731
732 // Get rid of our hidden Window
733 DestroyWindow(m_hNotifyWnd);
734 m_hNotifyWnd = NULL;
735 }
736
737
738 //---------------------------------------------------------------------------
739 // wxAMMediaBackend::GetVideoSize
740 //
741 // Obtains the cached original video size
742 //---------------------------------------------------------------------------
743 wxSize wxAMMediaBackend::GetVideoSize() const
744 {
745 return m_bestSize;
746 }
747
748 //---------------------------------------------------------------------------
749 // wxAMMediaBackend::Move
750 //
751 // Resizes the IVideoWindow to the size of the control window
752 //---------------------------------------------------------------------------
753 void wxAMMediaBackend::Move(int x, int y, int w, int h)
754 {
755 if(m_hNotifyWnd && m_bVideo)
756 {
757 wxAMVERIFY( m_pVW->SetWindowPosition(0, 0, w, h) );
758 }
759 }
760
761 //---------------------------------------------------------------------------
762 // End of wxAMMediaBackend
763 //---------------------------------------------------------------------------
764 #endif //wxUSE_DIRECTSHOW
765
766 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
767 //
768 // wxMCIMediaBackend
769 //
770 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
771
772
773 IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend, wxMediaBackend);
774
775 //---------------------------------------------------------------------------
776 // Usual debugging macros for MCI returns
777 //---------------------------------------------------------------------------
778
779 #ifdef __WXDEBUG__
780 #define wxMCIVERIFY(arg) \
781 { \
782 DWORD nRet; \
783 if ( (nRet = (arg)) != 0) \
784 { \
785 TCHAR sz[5000]; \
786 mciGetErrorString(nRet, sz, 5000); \
787 wxFAIL_MSG(wxString::Format(_T("MCI Error:%s"), sz)); \
788 } \
789 }
790 #else
791 #define wxMCIVERIFY(arg) (arg);
792 #endif
793
794 //---------------------------------------------------------------------------
795 // Simulation for <digitalv.h>
796 //
797 // Mingw and possibly other compilers don't have the digitalv.h header
798 // that is needed to have some essential features of mci work with
799 // windows - so we provide the declarations for the types we use here
800 //---------------------------------------------------------------------------
801
802 typedef struct {
803 DWORD_PTR dwCallback;
804 #ifdef MCI_USE_OFFEXT
805 POINT ptOffset;
806 POINT ptExtent;
807 #else
808 RECT rc;
809 #endif
810 } MCI_DGV_RECT_PARMS;
811
812 typedef struct {
813 DWORD_PTR dwCallback;
814 HWND hWnd;
815 #ifndef _WIN32
816 WORD wReserved1;
817 #endif
818 UINT nCmdShow;
819 #ifndef _WIN32
820 WORD wReserved2;
821 #endif
822 wxChar* lpstrText;
823 } MCI_DGV_WINDOW_PARMS;
824
825 typedef struct {
826 DWORD_PTR dwCallback;
827 DWORD dwTimeFormat;
828 DWORD dwAudio;
829 DWORD dwFileFormat;
830 DWORD dwSpeed;
831 } MCI_DGV_SET_PARMS;
832
833 //---------------------------------------------------------------------------
834 // wxMCIMediaBackend Constructor
835 //
836 // Here we don't need to do much except say we don't have any video :)
837 //---------------------------------------------------------------------------
838 wxMCIMediaBackend::wxMCIMediaBackend() : m_hNotifyWnd(NULL), m_bVideo(false)
839 {
840 }
841
842 //---------------------------------------------------------------------------
843 // wxMCIMediaBackend Destructor
844 //
845 // We close the mci device - note that there may not be an mci device here,
846 // or it may fail - but we don't really care, since we're destructing
847 //---------------------------------------------------------------------------
848 wxMCIMediaBackend::~wxMCIMediaBackend()
849 {
850 if(m_hNotifyWnd)
851 {
852 mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
853 DestroyWindow(m_hNotifyWnd);
854 m_hNotifyWnd = NULL;
855 }
856 }
857
858 //---------------------------------------------------------------------------
859 // wxMCIMediaBackend::Create
860 //
861 // Here we just tell wxMediaCtrl that mci does exist (which it does, on all
862 // msw systems, at least in some form dating back to win16 days)
863 //---------------------------------------------------------------------------
864 bool wxMCIMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
865 wxWindowID id,
866 const wxPoint& pos,
867 const wxSize& size,
868 long style,
869 const wxValidator& validator,
870 const wxString& name)
871 {
872 //
873 // Create window
874 // By default wxWindow(s) is created with a border -
875 // so we need to get rid of those, and create with
876 // wxCLIP_CHILDREN, so that if the driver/backend
877 // is a child window, it refereshes properly
878 //
879 if ( !ctrl->wxControl::Create(parent, id, pos, size,
880 (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
881 validator, name) )
882 return false;
883
884 m_ctrl = ctrl;
885 return true;
886 }
887
888 //---------------------------------------------------------------------------
889 // wxMCIMediaBackend::Load (file version)
890 //
891 // Here we have MCI load a file and device, set the time format to our
892 // default (milliseconds), and set the video (if any) to play in the control
893 //---------------------------------------------------------------------------
894 bool wxMCIMediaBackend::Load(const wxString& fileName)
895 {
896 //
897 //if the user already called load close the previous MCI device
898 //
899 if(m_hNotifyWnd)
900 {
901 mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
902 DestroyWindow(m_hNotifyWnd);
903 m_hNotifyWnd = NULL;
904 }
905
906 //
907 //Opens a file and has MCI select a device. Normally you'd put
908 //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you
909 //omit this it tells MCI to select the device instead. This is
910 //good because we have no reliable way of "enumerating" the devices
911 //in MCI
912 //
913 MCI_OPEN_PARMS openParms;
914 openParms.lpstrElementName = (wxChar*) fileName.c_str();
915
916 if ( mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT,
917 (DWORD)(LPVOID)&openParms) != 0)
918 return false;
919
920 m_hDev = openParms.wDeviceID;
921
922 //
923 //Now set the time format for the device to milliseconds
924 //
925 MCI_SET_PARMS setParms;
926 setParms.dwCallback = 0;
927 setParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
928
929 if (mciSendCommand(m_hDev, MCI_SET, MCI_SET_TIME_FORMAT,
930 (DWORD)(LPVOID)&setParms) != 0)
931 return false;
932
933 //
934 //Now tell the MCI device to display the video in our wxMediaCtrl
935 //
936 MCI_DGV_WINDOW_PARMS windowParms;
937 windowParms.hWnd = (HWND)m_ctrl->GetHandle();
938
939 m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW,
940 0x00010000L, //MCI_DGV_WINDOW_HWND
941 (DWORD)(LPVOID)&windowParms) == 0);
942
943 //
944 // Create a hidden window and register to handle
945 // MCI events
946 // Note that wxCanvasClassName is already registered
947 // and used by all wxWindows and normal wxControls
948 //
949 m_hNotifyWnd = ::CreateWindow
950 (
951 wxCanvasClassName,
952 NULL,
953 0, 0, 0, 0,
954 0,
955 (HWND) NULL,
956 (HMENU)NULL,
957 wxGetInstance(),
958 (LPVOID) NULL
959 );
960
961 if(!m_hNotifyWnd)
962 {
963 wxLogSysError( wxT("Could not create hidden needed for ")
964 wxT("registering for DirectShow events!") );
965
966 return false;
967 }
968
969 ::SetWindowLong(m_hNotifyWnd, GWL_WNDPROC,
970 (LONG)wxMCIMediaBackend::NotifyWndProc);
971
972 ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA,
973 (LONG) this);
974
975 m_ctrl->Show(false);
976
977 //
978 //Here, if the parent of the control has a sizer - we
979 //tell it to recalculate the size of this control since
980 //the user opened a seperate media file
981 //
982 m_ctrl->InvalidateBestSize();
983 m_ctrl->GetParent()->Layout();
984 m_ctrl->GetParent()->Refresh();
985 m_ctrl->GetParent()->Update();
986
987 return true;
988 }
989
990 //---------------------------------------------------------------------------
991 // wxMCIMediaBackend::Load (URL version)
992 //
993 // MCI doesn't support URLs directly (?)
994 //
995 // TODO: Use wxURL/wxFileSystem and mmioInstallProc
996 //---------------------------------------------------------------------------
997 bool wxMCIMediaBackend::Load(const wxURI& WXUNUSED(location))
998 {
999 return false;
1000 }
1001
1002 //---------------------------------------------------------------------------
1003 // wxMCIMediaBackend::Play
1004 //
1005 // Plays/Resumes the MCI device... a couple notes:
1006 // 1) Certain drivers will crash and burn if we don't pass them an
1007 // MCI_PLAY_PARMS, despite the documentation that says otherwise...
1008 // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing
1009 // and will resume from a stopped state also, so there's no need to
1010 // call both, for example
1011 //---------------------------------------------------------------------------
1012 bool wxMCIMediaBackend::Play()
1013 {
1014 MCI_PLAY_PARMS playParms;
1015 playParms.dwCallback = (DWORD)m_hNotifyWnd;
1016
1017 bool bOK = ( mciSendCommand(m_hDev, MCI_PLAY, MCI_NOTIFY,
1018 (DWORD)(LPVOID)&playParms) == 0 );
1019
1020 if(bOK)
1021 m_ctrl->Show(m_bVideo);
1022
1023 return bOK;
1024 }
1025
1026 //---------------------------------------------------------------------------
1027 // wxMCIMediaBackend::Pause
1028 //
1029 // Pauses the MCI device - nothing special
1030 //---------------------------------------------------------------------------
1031 bool wxMCIMediaBackend::Pause()
1032 {
1033 return (mciSendCommand(m_hDev, MCI_PAUSE, MCI_WAIT, 0) == 0);
1034 }
1035
1036 //---------------------------------------------------------------------------
1037 // wxMCIMediaBackend::Stop
1038 //
1039 // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline
1040 //---------------------------------------------------------------------------
1041 bool wxMCIMediaBackend::Stop()
1042 {
1043 return (mciSendCommand(m_hDev, MCI_STOP, MCI_WAIT, 0) == 0) &&
1044 (mciSendCommand(m_hDev, MCI_SEEK, MCI_SEEK_TO_START, 0) == 0);
1045 }
1046
1047 //---------------------------------------------------------------------------
1048 // wxMCIMediaBackend::GetState
1049 //
1050 // Here we get the state and convert it to a wxMediaState -
1051 // since we use direct comparisons with MCI_MODE_PLAY and
1052 // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call
1053 // fails or not
1054 //---------------------------------------------------------------------------
1055 wxMediaState wxMCIMediaBackend::GetState()
1056 {
1057 MCI_STATUS_PARMS statusParms;
1058 statusParms.dwItem = MCI_STATUS_MODE;
1059
1060 mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
1061 (DWORD)(LPVOID)&statusParms);
1062
1063 if(statusParms.dwReturn == MCI_MODE_PAUSE)
1064 return wxMEDIASTATE_PAUSED;
1065 else if(statusParms.dwReturn == MCI_MODE_PLAY)
1066 return wxMEDIASTATE_PLAYING;
1067 else
1068 return wxMEDIASTATE_STOPPED;
1069 }
1070
1071 //---------------------------------------------------------------------------
1072 // wxMCIMediaBackend::SetPosition
1073 //
1074 // Here we set the position of the device in the stream.
1075 // Note that MCI actually stops the device after you seek it if the
1076 // device is playing/paused, so we need to play the file after
1077 // MCI seeks like normal APIs would
1078 //---------------------------------------------------------------------------
1079 bool wxMCIMediaBackend::SetPosition(wxLongLong where)
1080 {
1081 MCI_SEEK_PARMS seekParms;
1082 seekParms.dwCallback = 0;
1083 #if wxUSE_LONGLONG_NATIVE && !wxUSE_LONGLONG_WX
1084 seekParms.dwTo = (DWORD)where.GetValue();
1085 #else /* wxUSE_LONGLONG_WX */
1086 /* no way to return it in one piece */
1087 wxASSERT( where.GetHi()==0 );
1088 seekParms.dwTo = (DWORD)where.GetLo();
1089 #endif /* wxUSE_LONGLONG_* */
1090
1091 //device was playing?
1092 bool bReplay = GetState() == wxMEDIASTATE_PLAYING;
1093
1094 if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO,
1095 (DWORD)(LPVOID)&seekParms) != 0)
1096 return false;
1097
1098 //If the device was playing, resume it
1099 if (bReplay)
1100 return Play();
1101 else
1102 return true;
1103 }
1104
1105 //---------------------------------------------------------------------------
1106 // wxMCIMediaBackend::GetPosition
1107 //
1108 // Gets the position of the device in the stream using the current
1109 // time format... nothing special here...
1110 //---------------------------------------------------------------------------
1111 wxLongLong wxMCIMediaBackend::GetPosition()
1112 {
1113 MCI_STATUS_PARMS statusParms;
1114 statusParms.dwItem = MCI_STATUS_POSITION;
1115
1116 if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
1117 (DWORD)(LPSTR)&statusParms) != 0)
1118 return 0;
1119
1120 return statusParms.dwReturn;
1121 }
1122
1123 //---------------------------------------------------------------------------
1124 // wxMCIMediaBackend::GetDuration
1125 //
1126 // Gets the duration of the stream... nothing special
1127 //---------------------------------------------------------------------------
1128 wxLongLong wxMCIMediaBackend::GetDuration()
1129 {
1130 MCI_STATUS_PARMS statusParms;
1131 statusParms.dwItem = MCI_STATUS_LENGTH;
1132
1133 if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
1134 (DWORD)(LPSTR)&statusParms) != 0)
1135 return 0;
1136
1137 return statusParms.dwReturn;
1138 }
1139
1140 //---------------------------------------------------------------------------
1141 // wxMCIMediaBackend::Move
1142 //
1143 // Moves the window to a location
1144 //---------------------------------------------------------------------------
1145 void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y),
1146 int w, int h)
1147 {
1148 if (m_hNotifyWnd && m_bVideo)
1149 {
1150 MCI_DGV_RECT_PARMS putParms; //ifdefed MCI_DGV_PUT_PARMS
1151 putParms.rc.top = 0;
1152 putParms.rc.bottom = 0;
1153 putParms.rc.right = w;
1154 putParms.rc.bottom = h;
1155
1156 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_PUT,
1157 0x00040000L, //MCI_DGV_PUT_DESTINATION
1158 (DWORD)(LPSTR)&putParms) );
1159 }
1160 }
1161
1162 //---------------------------------------------------------------------------
1163 // wxMCIMediaBackend::GetVideoSize
1164 //
1165 // Gets the original size of the movie for sizers
1166 //---------------------------------------------------------------------------
1167 wxSize wxMCIMediaBackend::GetVideoSize() const
1168 {
1169 if(m_bVideo)
1170 {
1171 MCI_DGV_RECT_PARMS whereParms; //ifdefed MCI_DGV_WHERE_PARMS
1172
1173 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_WHERE,
1174 0x00020000L, //MCI_DGV_WHERE_SOURCE
1175 (DWORD)(LPSTR)&whereParms) );
1176
1177 return wxSize(whereParms.rc.right, whereParms.rc.bottom);
1178 }
1179 return wxSize(0,0);
1180 }
1181
1182 //---------------------------------------------------------------------------
1183 // wxMCIMediaBackend::GetPlaybackRate
1184 //
1185 // TODO
1186 //---------------------------------------------------------------------------
1187 double wxMCIMediaBackend::GetPlaybackRate()
1188 {
1189 return 1.0;
1190 }
1191
1192 //---------------------------------------------------------------------------
1193 // wxMCIMediaBackend::SetPlaybackRate
1194 //
1195 // TODO
1196 //---------------------------------------------------------------------------
1197 bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate))
1198 {
1199 /*
1200 MCI_WAVE_SET_SAMPLESPERSEC
1201 MCI_DGV_SET_PARMS setParms;
1202 setParms.dwSpeed = (DWORD) (dRate * 1000.0);
1203
1204 return (mciSendCommand(m_hDev, MCI_SET,
1205 0x00020000L, //MCI_DGV_SET_SPEED
1206 (DWORD)(LPSTR)&setParms) == 0);
1207 */
1208 return false;
1209 }
1210
1211 //---------------------------------------------------------------------------
1212 // [static] wxMCIMediaBackend::MSWWindowProc
1213 //
1214 // Here we process a message when MCI reaches the stopping point
1215 // in the stream
1216 //---------------------------------------------------------------------------
1217 LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg,
1218 WPARAM wParam,
1219 LPARAM lParam)
1220 {
1221 wxMCIMediaBackend* backend = (wxMCIMediaBackend*)
1222 ::GetWindowLong(hWnd, GWL_USERDATA);
1223 wxASSERT(backend);
1224
1225 return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam);
1226 }
1227
1228 LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg,
1229 WPARAM wParam,
1230 LPARAM lParam)
1231 {
1232 if(nMsg == MM_MCINOTIFY)
1233 {
1234 wxASSERT(lParam == (LPARAM) m_hDev);
1235 if(wParam == MCI_NOTIFY_SUCCESSFUL && lParam == (LPARAM)m_hDev)
1236 {
1237 wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
1238 m_ctrl->ProcessEvent(theEvent);
1239
1240 if(theEvent.IsAllowed())
1241 {
1242 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_SEEK,
1243 MCI_SEEK_TO_START, 0) );
1244
1245 //send the event to our child
1246 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
1247 m_ctrl->GetId());
1248 m_ctrl->ProcessEvent(theEvent);
1249 }
1250 }
1251 }
1252 return DefWindowProc(hWnd, nMsg, wParam, lParam);
1253 }
1254 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1255 //
1256 // wxQTMediaBackend
1257 //
1258 // TODO: Use a less cludgy way to pause/get state/set state
1259 // TODO: Dynamically load from qtml.dll
1260 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1261
1262 #if wxUSE_QUICKTIME
1263
1264 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend);
1265
1266 //Time between timer calls
1267 #define MOVIE_DELAY 100
1268
1269 #include "wx/timer.h"
1270
1271 // --------------------------------------------------------------------------
1272 // wxQTTimer - Handle Asyncronous Playing
1273 // --------------------------------------------------------------------------
1274 class _wxQTTimer : public wxTimer
1275 {
1276 public:
1277 _wxQTTimer(Movie movie, wxQTMediaBackend* parent) :
1278 m_movie(movie), m_bPaused(false), m_parent(parent)
1279 {
1280 }
1281
1282 ~_wxQTTimer()
1283 {
1284 }
1285
1286 bool GetPaused() {return m_bPaused;}
1287 void SetPaused(bool bPaused) {m_bPaused = bPaused;}
1288
1289 //-----------------------------------------------------------------------
1290 // _wxQTTimer::Notify
1291 //
1292 // 1) Checks to see if the movie is done, and if not continues
1293 // streaming the movie
1294 // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
1295 // the movie.
1296 //-----------------------------------------------------------------------
1297 void Notify()
1298 {
1299 if (!m_bPaused)
1300 {
1301 if(!IsMovieDone(m_movie))
1302 MoviesTask(m_movie, MOVIE_DELAY);
1303 else
1304 {
1305 wxMediaEvent theEvent(wxEVT_MEDIA_STOP,
1306 m_parent->m_ctrl->GetId());
1307 m_parent->m_ctrl->ProcessEvent(theEvent);
1308
1309 if(theEvent.IsAllowed())
1310 {
1311 Stop();
1312 m_parent->Stop();
1313 wxASSERT(::GetMoviesError() == noErr);
1314
1315 //send the event to our child
1316 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
1317 m_parent->m_ctrl->GetId());
1318 m_parent->m_ctrl->ProcessEvent(theEvent);
1319 }
1320 }
1321 }
1322 }
1323
1324 protected:
1325 Movie m_movie; //Our movie instance
1326 bool m_bPaused; //Whether we are paused or not
1327 wxQTMediaBackend* m_parent; //Backend pointer
1328 };
1329
1330 //---------------------------------------------------------------------------
1331 // wxQTMediaBackend Destructor
1332 //
1333 // Sets m_timer to NULL signifying we havn't loaded anything yet
1334 //---------------------------------------------------------------------------
1335 wxQTMediaBackend::wxQTMediaBackend() : m_timer(NULL)
1336 {
1337 }
1338
1339 //---------------------------------------------------------------------------
1340 // wxQTMediaBackend Destructor
1341 //
1342 // 1) Cleans up the QuickTime movie instance
1343 // 2) Decrements the QuickTime reference counter - if this reaches
1344 // 0, QuickTime shuts down
1345 // 3) Decrements the QuickTime Windows Media Layer reference counter -
1346 // if this reaches 0, QuickTime shuts down the Windows Media Layer
1347 //---------------------------------------------------------------------------
1348 wxQTMediaBackend::~wxQTMediaBackend()
1349 {
1350 if(m_timer)
1351 Cleanup();
1352
1353 //Note that ExitMovies() is not neccessary, but
1354 //the docs are fuzzy on whether or not TerminateQTML is
1355 ExitMovies();
1356 TerminateQTML();
1357 }
1358
1359 //---------------------------------------------------------------------------
1360 // wxQTMediaBackend::CreateControl
1361 //
1362 // 1) Intializes QuickTime
1363 // 2) Creates the control window
1364 //---------------------------------------------------------------------------
1365 bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
1366 wxWindowID id,
1367 const wxPoint& pos,
1368 const wxSize& size,
1369 long style,
1370 const wxValidator& validator,
1371 const wxString& name)
1372 {
1373 int nError;
1374 if ((nError = InitializeQTML(0)) != noErr) //-2093 no dll
1375 {
1376 wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
1377 return false;
1378 }
1379 EnterMovies();
1380
1381 //
1382 // Create window
1383 // By default wxWindow(s) is created with a border -
1384 // so we need to get rid of those
1385 //
1386 // Since we don't have a child window like most other
1387 // backends, we don't need wxCLIP_CHILDREN
1388 //
1389 if ( !ctrl->wxControl::Create(parent, id, pos, size,
1390 (style & ~wxBORDER_MASK) | wxBORDER_NONE,
1391 validator, name) )
1392 return false;
1393
1394 m_ctrl = ctrl;
1395 return true;
1396 }
1397
1398 //---------------------------------------------------------------------------
1399 // wxQTMediaBackend::Load (file version)
1400 //
1401 // 1) Get an FSSpec from the Windows path name
1402 // 2) Open the movie
1403 // 3) Obtain the movie instance from the movie resource
1404 // 4)
1405 //---------------------------------------------------------------------------
1406 bool wxQTMediaBackend::Load(const wxString& fileName)
1407 {
1408 if(m_timer)
1409 Cleanup();
1410
1411 OSErr err = noErr;
1412 short movieResFile;
1413 FSSpec sfFile;
1414
1415 if (NativePathNameToFSSpec ((char*) (const char*) fileName.mb_str(),
1416 &sfFile, 0) != noErr)
1417 return false;
1418
1419 if (OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
1420 return false;
1421
1422 short movieResID = 0;
1423 Str255 movieName;
1424
1425 err = NewMovieFromFile (
1426 &m_movie,
1427 movieResFile,
1428 &movieResID,
1429 movieName,
1430 newMovieActive,
1431 NULL); //wasChanged
1432
1433 CloseMovieFile (movieResFile);
1434
1435 if (err != noErr)
1436 return false;
1437
1438 FinishLoad();
1439
1440 return ::GetMoviesError() == noErr;
1441 }
1442
1443 //---------------------------------------------------------------------------
1444 // wxQTMediaBackend::Move
1445 //
1446 // TODO
1447 //---------------------------------------------------------------------------
1448 bool wxQTMediaBackend::Load(const wxURI& location)
1449 {
1450 if(m_timer)
1451 Cleanup();
1452
1453 wxString theURI = location.BuildURI();
1454
1455 OSErr err = noErr;
1456
1457 Handle theHandle = NewHandleClear(theURI.length() + 1);
1458 wxASSERT(theHandle);
1459
1460 BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1);
1461
1462 //create the movie from the handle that refers to the URI
1463 err = NewMovieFromDataRef(&m_movie, newMovieActive,
1464 NULL, theHandle,
1465 URLDataHandlerSubType);
1466
1467 DisposeHandle(theHandle);
1468
1469 if (err != noErr)
1470 return false;
1471
1472 //preroll movie for streaming
1473 //TODO:Async this?
1474 TimeValue timeNow;
1475 Fixed playRate;
1476 timeNow = GetMovieTime(m_movie, NULL);
1477 playRate = GetMoviePreferredRate(m_movie);
1478 PrePrerollMovie(m_movie, timeNow, playRate, NULL, NULL);
1479 PrerollMovie(m_movie, timeNow, playRate);
1480 SetMovieRate(m_movie, playRate);
1481
1482 FinishLoad();
1483
1484 return ::GetMoviesError() == noErr;
1485 }
1486
1487 //---------------------------------------------------------------------------
1488 // wxQTMediaBackend::Move
1489 //
1490 // TODO
1491 //---------------------------------------------------------------------------
1492 void wxQTMediaBackend::FinishLoad()
1493 {
1494 m_timer = new _wxQTTimer(m_movie, (wxQTMediaBackend*) this);
1495 wxASSERT(m_timer);
1496
1497 //get the real size of the movie
1498 Rect outRect;
1499 ::GetMovieNaturalBoundsRect (m_movie, &outRect);
1500 wxASSERT(::GetMoviesError() == noErr);
1501
1502 m_bestSize.x = outRect.right - outRect.left;
1503 m_bestSize.y = outRect.bottom - outRect.top;
1504
1505 //reparent movie/*AudioMediaCharacteristic*/
1506 if(GetMovieIndTrackType(m_movie, 1,
1507 VisualMediaCharacteristic,
1508 movieTrackCharacteristic |
1509 movieTrackEnabledOnly) != NULL)
1510 {
1511 CreatePortAssociation(m_ctrl->GetHWND(), NULL, 0L);
1512
1513 SetMovieGWorld(m_movie,
1514 (CGrafPtr) GetNativeWindowPort(m_ctrl->GetHWND()),
1515 nil);
1516 }
1517
1518 //we want millisecond precision
1519 ::SetMovieTimeScale(m_movie, 1000);
1520 wxASSERT(::GetMoviesError() == noErr);
1521
1522 //
1523 //Here, if the parent of the control has a sizer - we
1524 //tell it to recalculate the size of this control since
1525 //the user opened a seperate media file
1526 //
1527 m_ctrl->InvalidateBestSize();
1528 m_ctrl->GetParent()->Layout();
1529 m_ctrl->GetParent()->Refresh();
1530 m_ctrl->GetParent()->Update();
1531 }
1532
1533 //---------------------------------------------------------------------------
1534 // wxQTMediaBackend::Move
1535 //
1536 // TODO
1537 //---------------------------------------------------------------------------
1538 bool wxQTMediaBackend::Play()
1539 {
1540 ::StartMovie(m_movie);
1541 m_timer->SetPaused(false);
1542 m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
1543 return ::GetMoviesError() == noErr;
1544 }
1545
1546 //---------------------------------------------------------------------------
1547 // wxQTMediaBackend::Move
1548 //
1549 // TODO
1550 //---------------------------------------------------------------------------
1551 bool wxQTMediaBackend::Pause()
1552 {
1553 ::StopMovie(m_movie);
1554 m_timer->SetPaused(true);
1555 m_timer->Stop();
1556 return ::GetMoviesError() == noErr;
1557 }
1558
1559 //---------------------------------------------------------------------------
1560 // wxQTMediaBackend::Move
1561 //
1562 // TODO
1563 //---------------------------------------------------------------------------
1564 bool wxQTMediaBackend::Stop()
1565 {
1566 m_timer->SetPaused(false);
1567 m_timer->Stop();
1568
1569 ::StopMovie(m_movie);
1570 if(::GetMoviesError() != noErr)
1571 return false;
1572
1573 ::GoToBeginningOfMovie(m_movie);
1574 return ::GetMoviesError() == noErr;
1575 }
1576
1577 //---------------------------------------------------------------------------
1578 // wxQTMediaBackend::Move
1579 //
1580 // TODO
1581 //---------------------------------------------------------------------------
1582 double wxQTMediaBackend::GetPlaybackRate()
1583 {
1584 return ( ((double)::GetMovieRate(m_movie)) / 0x10000);
1585 }
1586
1587 //---------------------------------------------------------------------------
1588 // wxQTMediaBackend::Move
1589 //
1590 // TODO
1591 //---------------------------------------------------------------------------
1592 bool wxQTMediaBackend::SetPlaybackRate(double dRate)
1593 {
1594 ::SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
1595 return ::GetMoviesError() == noErr;
1596 }
1597
1598 //---------------------------------------------------------------------------
1599 // wxQTMediaBackend::Move
1600 //
1601 // TODO
1602 //---------------------------------------------------------------------------
1603 bool wxQTMediaBackend::SetPosition(wxLongLong where)
1604 {
1605 TimeRecord theTimeRecord;
1606 memset(&theTimeRecord, 0, sizeof(TimeRecord));
1607 theTimeRecord.value.lo = where.GetValue();
1608 theTimeRecord.scale = ::GetMovieTimeScale(m_movie);
1609 theTimeRecord.base = ::GetMovieTimeBase(m_movie);
1610 ::SetMovieTime(m_movie, &theTimeRecord);
1611
1612 if (::GetMoviesError() != noErr)
1613 return false;
1614
1615 return true;
1616 }
1617
1618 //---------------------------------------------------------------------------
1619 // wxQTMediaBackend::GetPosition
1620 //
1621 // 1) Calls GetMovieTime to get the position we are in in the movie
1622 // in milliseconds (we called
1623 //---------------------------------------------------------------------------
1624 wxLongLong wxQTMediaBackend::GetPosition()
1625 {
1626 return ::GetMovieTime(m_movie, NULL);
1627 }
1628
1629 //---------------------------------------------------------------------------
1630 // wxQTMediaBackend::Move
1631 //
1632 // TODO
1633 //---------------------------------------------------------------------------
1634 wxLongLong wxQTMediaBackend::GetDuration()
1635 {
1636 return ::GetMovieDuration(m_movie);
1637 }
1638
1639 //---------------------------------------------------------------------------
1640 // wxQTMediaBackend::Move
1641 //
1642 // TODO
1643 //---------------------------------------------------------------------------
1644 wxMediaState wxQTMediaBackend::GetState()
1645 {
1646 if ( !m_timer || (m_timer->IsRunning() == false &&
1647 m_timer->GetPaused() == false) )
1648 return wxMEDIASTATE_STOPPED;
1649
1650 if( m_timer->IsRunning() == true )
1651 return wxMEDIASTATE_PLAYING;
1652 else
1653 return wxMEDIASTATE_PAUSED;
1654 }
1655
1656 //---------------------------------------------------------------------------
1657 // wxQTMediaBackend::Move
1658 //
1659 // TODO
1660 //---------------------------------------------------------------------------
1661 void wxQTMediaBackend::Cleanup()
1662 {
1663 delete m_timer;
1664 m_timer = NULL;
1665
1666 StopMovie(m_movie);
1667 DisposeMovie(m_movie);
1668 }
1669
1670 //---------------------------------------------------------------------------
1671 // wxQTMediaBackend::Move
1672 //
1673 // TODO
1674 //---------------------------------------------------------------------------
1675 wxSize wxQTMediaBackend::GetVideoSize() const
1676 {
1677 return m_bestSize;
1678 }
1679
1680 //---------------------------------------------------------------------------
1681 // wxQTMediaBackend::Move
1682 //
1683 // TODO
1684 //---------------------------------------------------------------------------
1685 void wxQTMediaBackend::Move(int x, int y, int w, int h)
1686 {
1687 if(m_timer)
1688 {
1689 Rect theRect = {0, 0, h, w};
1690
1691 ::SetMovieBox(m_movie, &theRect);
1692 wxASSERT(::GetMoviesError() == noErr);
1693 }
1694 }
1695
1696 //---------------------------------------------------------------------------
1697 // End QT Compilation Guard
1698 //---------------------------------------------------------------------------
1699 #endif //wxUSE_QUICKTIME
1700
1701 //in source file that contains stuff you don't directly use
1702 #include <wx/html/forcelnk.h>
1703 FORCE_LINK_ME(basewxmediabackends);
1704
1705 //---------------------------------------------------------------------------
1706 // End wxMediaCtrl Compilation Guard and this file
1707 //---------------------------------------------------------------------------
1708 #endif //wxUSE_MEDIACTRL
1709
1710
wxWidgets (Impactor)