]> git.saurik.com Git - wxWidgets.git/blame - src/osx/carbon/mediactrl.cpp
new file added
[wxWidgets.git] / src / osx / carbon / mediactrl.cpp
CommitLineData
489468fe 1/////////////////////////////////////////////////////////////////////////////
524c47aa 2// Name: src/osx/carbon/mediactrl.cpp
489468fe
SC
3// Purpose: Built-in Media Backends for Mac
4// Author: Ryan Norton <wxprojects@comcast.net>
5// Modified by:
6// Created: 11/07/04
7// RCS-ID: $Id$
8// Copyright: (c) 2004-2006 Ryan Norton
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13// OK, a casual overseer of this file may wonder why we don't use
14// either CreateMovieControl or HIMovieView...
15//
16// CreateMovieControl
17// 1) Need to dispose and create each time a new movie is loaded
18// 2) Not that many real advantages
19// 3) Progressively buggier in higher OSX versions
20// (see main.c of QTCarbonShell sample for details)
21// HIMovieView
22// 1) Crashes on destruction in ALL cases on quite a few systems!
23// (With the only real "alternative" is to simply not
24// dispose of it and let it leak...)
25// 2) Massive refreshing bugs with its movie controller between
26// movies
27//
28// At one point we had a complete implementation for CreateMovieControl
29// and on my (RN) local copy I had one for HIMovieView - but they
30// were simply deemed to be too buggy/unuseful. HIMovieView could
31// have been useful as well because it uses OpenGL contexts instead
32// of GWorlds. Perhaps someday when someone comes out with some
33// ingenious workarounds :).
34//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35
36// For compilers that support precompilation, includes "wx.h".
37#include "wx/wxprec.h"
38
39#if wxUSE_MEDIACTRL
40
41#include "wx/mediactrl.h"
42
43#ifndef WX_PRECOMP
44 #include "wx/log.h"
45 #include "wx/timer.h"
46#endif
47
b2680ced 48#if wxOSX_USE_CARBON
489468fe
SC
49#define USE_QUICKTIME 1
50#else
51#define USE_QUICKTIME 0
52#endif
53
54#if USE_QUICKTIME
55
524c47aa
SC
56#include "wx/osx/private.h"
57#include <QuickTime/QuickTimeComponents.h>
58
489468fe
SC
59//---------------------------------------------------------------------------
60// Height and Width of movie controller in the movie control (apple samples)
61//---------------------------------------------------------------------------
62#define wxMCWIDTH 320
63#define wxMCHEIGHT 16
64
65//===========================================================================
66// BACKEND DECLARATIONS
67//===========================================================================
68
69//---------------------------------------------------------------------------
70// wxQTMediaBackend
71//---------------------------------------------------------------------------
72
73class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
74{
75public:
76 wxQTMediaBackend();
77 virtual ~wxQTMediaBackend();
78
79 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
80 wxWindowID id,
81 const wxPoint& pos,
82 const wxSize& size,
83 long style,
84 const wxValidator& validator,
85 const wxString& name);
86
87 virtual bool Load(const wxString& fileName);
88 virtual bool Load(const wxURI& location);
8f2a8de6
VZ
89 virtual bool Load(const wxURI& location,
90 const wxURI& WXUNUSED(proxy))
91 {
92 return Load(location);
93 }
489468fe
SC
94
95 virtual bool Play();
96 virtual bool Pause();
97 virtual bool Stop();
98
99 virtual wxMediaState GetState();
100
101 virtual bool SetPosition(wxLongLong where);
102 virtual wxLongLong GetPosition();
103 virtual wxLongLong GetDuration();
104
105 virtual void Move(int x, int y, int w, int h);
106 wxSize GetVideoSize() const;
107
108 virtual double GetPlaybackRate();
109 virtual bool SetPlaybackRate(double dRate);
110
111 virtual double GetVolume();
112 virtual bool SetVolume(double);
113
114 void Cleanup();
115 void FinishLoad();
116
117 virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);
118
119 virtual wxLongLong GetDownloadProgress();
120 virtual wxLongLong GetDownloadTotal();
121
122 virtual void MacVisibilityChanged();
123
124 //
125 // ------ Implementation from now on --------
126 //
127 bool DoPause();
128 bool DoStop();
129
130 void DoLoadBestSize();
131 void DoSetControllerVisible(wxMediaCtrlPlayerControls flags);
132
133 wxLongLong GetDataSizeFromStart(TimeValue end);
134
135 Boolean IsQuickTime4Installed();
136 void DoNewMovieController();
137
138 static pascal void PPRMProc(
139 Movie theMovie, OSErr theErr, void* theRefCon);
140
141 //TODO: Last param actually long - does this work on 64bit machines?
142 static pascal Boolean MCFilterProc(MovieController theController,
143 short action, void *params, long refCon);
144
145 static pascal OSStatus WindowEventHandler(
146 EventHandlerCallRef inHandlerCallRef,
147 EventRef inEvent, void *inUserData );
148
149 wxSize m_bestSize; // Original movie size
150 Movie m_movie; // Movie instance
151 bool m_bPlaying; // Whether media is playing or not
152 class wxTimer* m_timer; // Timer for streaming the movie
153 MovieController m_mc; // MovieController instance
154 wxMediaCtrlPlayerControls m_interfaceflags; // Saved interface flags
155
156 // Event handlers and UPPs/Callbacks
157 EventHandlerRef m_windowEventHandler;
158 EventHandlerUPP m_windowUPP;
159
160 MoviePrePrerollCompleteUPP m_preprerollupp;
161 MCActionFilterWithRefConUPP m_mcactionupp;
162
163 GWorldPtr m_movieWorld; //Offscreen movie GWorld
164
165 friend class wxQTMediaEvtHandler;
166
167 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
168};
169
170// helper to hijack background erasing for the QT window
171class WXDLLIMPEXP_MEDIA wxQTMediaEvtHandler : public wxEvtHandler
172{
173public:
174 wxQTMediaEvtHandler(wxQTMediaBackend *qtb)
175 {
176 m_qtb = qtb;
177
178 qtb->m_ctrl->Connect(
179 qtb->m_ctrl->GetId(), wxEVT_ERASE_BACKGROUND,
180 wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground),
181 NULL, this);
182 }
183
184 void OnEraseBackground(wxEraseEvent& event);
185
186private:
187 wxQTMediaBackend *m_qtb;
188
c0c133e1 189 wxDECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler);
489468fe
SC
190};
191
192//===========================================================================
193// IMPLEMENTATION
194//===========================================================================
195
196
197//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
198//
199// wxQTMediaBackend
200//
201//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
202
203IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)
204
205//Time between timer calls - this is the Apple recommondation to the TCL
206//team I believe
207#define MOVIE_DELAY 20
208
209//---------------------------------------------------------------------------
210// wxQTMediaLoadTimer
211//
212// QT, esp. QT for Windows is very picky about how you go about
213// async loading. If you were to go through a Windows message loop
214// or a MoviesTask or both and then check the movie load state
215// it would still return 1000 (loading)... even (pre)prerolling doesn't
216// help. However, making a load timer like this works
217//---------------------------------------------------------------------------
218class wxQTMediaLoadTimer : public wxTimer
219{
220public:
221 wxQTMediaLoadTimer(wxQTMediaBackend* parent) :
222 m_parent(parent) {}
223
224 void Notify()
225 {
226 ::MCIdle(m_parent->m_mc);
227
228 // kMovieLoadStatePlayable is not enough on MAC:
229 // it plays, but IsMovieDone might return true (!)
230 // sure we need to wait until kMovieLoadStatePlaythroughOK
231 if (::GetMovieLoadState(m_parent->m_movie) >= 20000)
232 {
233 m_parent->FinishLoad();
234 delete this;
235 }
236 }
237
238protected:
239 wxQTMediaBackend *m_parent; // Backend pointer
240};
241
242// --------------------------------------------------------------------------
243// wxQTMediaPlayTimer - Handle Asyncronous Playing
244//
245// 1) Checks to see if the movie is done, and if not continues
246// streaming the movie
247// 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
248// the movie.
249// --------------------------------------------------------------------------
250class wxQTMediaPlayTimer : public wxTimer
251{
252public:
253 wxQTMediaPlayTimer(wxQTMediaBackend* parent) :
254 m_parent(parent) {}
255
256 void Notify()
257 {
258 //
259 // OK, a little explaining - basically originally
260 // we only called MoviesTask if the movie was actually
261 // playing (not paused or stopped)... this was before
262 // we realized MoviesTask actually handles repainting
263 // of the current frame - so if you were to resize
264 // or something it would previously not redraw that
265 // portion of the movie.
266 //
267 // So now we call MoviesTask always so that it repaints
268 // correctly.
269 //
270 ::MCIdle(m_parent->m_mc);
271
272 //
273 // Handle the stop event - if the movie has reached
274 // the end, notify our handler
275 //
276 if (::IsMovieDone(m_parent->m_movie))
277 {
278 if ( m_parent->SendStopEvent() )
279 {
280 m_parent->Stop();
281 wxASSERT(::GetMoviesError() == noErr);
282
283 m_parent->QueueFinishEvent();
284 }
285 }
286 }
287
288protected:
289 wxQTMediaBackend* m_parent; // Backend pointer
290};
291
292
293//---------------------------------------------------------------------------
294// wxQTMediaBackend Constructor
295//
296// Sets m_timer to NULL signifying we havn't loaded anything yet
297//---------------------------------------------------------------------------
298wxQTMediaBackend::wxQTMediaBackend()
299 : m_movie(NULL), m_bPlaying(false), m_timer(NULL)
300 , m_mc(NULL), m_interfaceflags(wxMEDIACTRLPLAYERCONTROLS_NONE)
301 , m_preprerollupp(NULL), m_movieWorld(NULL)
302{
303}
304
305//---------------------------------------------------------------------------
306// wxQTMediaBackend Destructor
307//
308// 1) Cleans up the QuickTime movie instance
309// 2) Decrements the QuickTime reference counter - if this reaches
310// 0, QuickTime shuts down
311// 3) Decrements the QuickTime Windows Media Layer reference counter -
312// if this reaches 0, QuickTime shuts down the Windows Media Layer
313//---------------------------------------------------------------------------
314wxQTMediaBackend::~wxQTMediaBackend()
315{
316 if (m_movie)
317 Cleanup();
318
319 // Cleanup for moviecontroller
320 if (m_mc)
321 {
322 // destroy wxQTMediaEvtHandler we pushed on it
323 m_ctrl->PopEventHandler(true);
324 RemoveEventHandler(m_windowEventHandler);
325 DisposeEventHandlerUPP(m_windowUPP);
326
327 // Dispose of the movie controller
328 ::DisposeMovieController(m_mc);
329 m_mc = NULL;
03647350 330
489468fe
SC
331 // Dispose of offscreen GWorld
332 ::DisposeGWorld(m_movieWorld);
333 }
334
335 // Note that ExitMovies() is not necessary...
336 ExitMovies();
337}
338
339//---------------------------------------------------------------------------
340// wxQTMediaBackend::CreateControl
341//
342// 1) Intializes QuickTime
343// 2) Creates the control window
344//---------------------------------------------------------------------------
345bool wxQTMediaBackend::CreateControl(
346 wxControl* ctrl,
347 wxWindow* parent,
348 wxWindowID id,
349 const wxPoint& pos,
350 const wxSize& size,
351 long style,
352 const wxValidator& validator,
353 const wxString& name)
354{
355 if (!IsQuickTime4Installed())
356 return false;
357
358 EnterMovies();
359
360 wxMediaCtrl* mediactrl = (wxMediaCtrl*)ctrl;
361
362 //
363 // Create window
364 // By default wxWindow(s) is created with a border -
365 // so we need to get rid of those
366 //
367 // Since we don't have a child window like most other
368 // backends, we don't need wxCLIP_CHILDREN
369 //
370 if ( !mediactrl->wxControl::Create(
371 parent, id, pos, size,
372 wxWindow::MacRemoveBordersFromStyle(style),
373 validator, name))
374 {
375 return false;
376 }
377
378#if wxUSE_VALIDATORS
379 mediactrl->SetValidator(validator);
380#endif
381
382 m_ctrl = mediactrl;
383 return true;
384}
385
386//---------------------------------------------------------------------------
387// wxQTMediaBackend::IsQuickTime4Installed
388//
389// Determines whether version 4 of QT is installed
390// (Pretty much for Classic only)
391//---------------------------------------------------------------------------
392Boolean wxQTMediaBackend::IsQuickTime4Installed()
393{
394 OSErr error;
395 long result;
396
397 error = Gestalt(gestaltQuickTime, &result);
398 return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
399}
400
401//---------------------------------------------------------------------------
402// wxQTMediaBackend::Load (file version)
403//
404// 1) Get an FSSpec from the Windows path name
405// 2) Open the movie
406// 3) Obtain the movie instance from the movie resource
407// 4) Close the movie resource
408// 5) Finish loading
409//---------------------------------------------------------------------------
410bool wxQTMediaBackend::Load(const wxString& fileName)
411{
412 if (m_movie)
413 Cleanup();
414
415 ::ClearMoviesStickyError(); // clear previous errors so
416 // GetMoviesStickyError is useful
417
418 OSErr err = noErr;
419 short movieResFile;
420 FSSpec sfFile;
421
422 wxMacFilename2FSSpec( fileName, &sfFile );
423 if (OpenMovieFile( &sfFile, &movieResFile, fsRdPerm ) != noErr)
424 return false;
425
426 short movieResID = 0;
427 Str255 movieName;
428
429 err = NewMovieFromFile(
430 &m_movie,
431 movieResFile,
432 &movieResID,
433 movieName,
434 newMovieActive,
435 NULL); // wasChanged
436
437 // Do not use ::GetMoviesStickyError() here because it returns -2009
03647350 438 // a.k.a. invalid track on valid mpegs
489468fe
SC
439 if (err == noErr && ::GetMoviesError() == noErr)
440 {
441 ::CloseMovieFile(movieResFile);
442
443 // Create movie controller/control
444 DoNewMovieController();
445
446 FinishLoad();
447 return true;
448 }
449
450 return false;
451}
452
453//---------------------------------------------------------------------------
454// wxQTMediaBackend::Load (URL Version)
455//
456// 1) Build an escaped URI from location
457// 2) Create a handle to store the URI string
458// 3) Put the URI string inside the handle
459// 4) Make a QuickTime URL data ref from the handle with the URI in it
460// 5) Clean up the URI string handle
461// 6) Do some prerolling
462// 7) Finish Loading
463//---------------------------------------------------------------------------
464bool wxQTMediaBackend::Load(const wxURI& location)
465{
466 if (m_movie)
467 Cleanup();
468
469 ::ClearMoviesStickyError(); // clear previous errors so
470 // GetMoviesStickyError is useful
471
472 wxString theURI = location.BuildURI();
473 OSErr err;
474
475 size_t len;
476 const char* theURIString;
477
478#if wxUSE_UNICODE
479 wxCharBuffer buf = wxConvLocal.cWC2MB(theURI.wc_str(), theURI.length(), &len);
480 theURIString = buf;
481#else
482 theURIString = theURI;
483 len = theURI.length();
484#endif
485
486 Handle theHandle = ::NewHandleClear(len + 1);
487 wxASSERT(theHandle);
488
489 ::BlockMoveData(theURIString, *theHandle, len + 1);
490
491 // create the movie from the handle that refers to the URI
492 err = ::NewMovieFromDataRef(
493 &m_movie,
494 newMovieActive | newMovieAsyncOK /* | newMovieIdleImportOK*/,
495 NULL, theHandle,
496 URLDataHandlerSubType);
497
498 ::DisposeHandle(theHandle);
499
500 if (err == noErr && ::GetMoviesStickyError() == noErr)
501 {
502 // Movie controller resets prerolling, so we must create first
503 DoNewMovieController();
504
505 long timeNow;
506 Fixed playRate;
507
508 timeNow = ::GetMovieTime(m_movie, NULL);
509 wxASSERT(::GetMoviesError() == noErr);
510
511 playRate = ::GetMoviePreferredRate(m_movie);
512 wxASSERT(::GetMoviesError() == noErr);
513
514 //
515 // Note that the callback here is optional,
516 // but without it PrePrerollMovie can be buggy
517 // (see Apple ml). Also, some may wonder
518 // why we need this at all - this is because
519 // Apple docs say QuickTime streamed movies
520 // require it if you don't use a Movie Controller,
521 // which we don't by default.
522 //
523 m_preprerollupp = wxQTMediaBackend::PPRMProc;
524 ::PrePrerollMovie( m_movie, timeNow, playRate,
525 m_preprerollupp, (void*)this);
526
527 return true;
528 }
529
530 return false;
531}
532
533//---------------------------------------------------------------------------
534// wxQTMediaBackend::DoNewMovieController
535//
536// Attaches movie to moviecontroller or creates moviecontroller
537// if not created yet
538//---------------------------------------------------------------------------
539void wxQTMediaBackend::DoNewMovieController()
540{
541 if (!m_mc)
542 {
543 // Get top level window ref for some mac functions
544 WindowRef wrTLW = (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
545
546 // MovieController not set up yet, so we need to create a new one.
547 // You have to pass a valid movie to NewMovieController, evidently
548 ::SetMovieGWorld(m_movie,
549 (CGrafPtr) GetWindowPort(wrTLW),
550 NULL);
551 wxASSERT(::GetMoviesError() == noErr);
552
553 Rect bounds = wxMacGetBoundsForControl(
554 m_ctrl,
555 m_ctrl->GetPosition(),
556 m_ctrl->GetSize());
557
558 m_mc = ::NewMovieController(
559 m_movie, &bounds,
560 mcTopLeftMovie | mcNotVisible /* | mcWithFrame */ );
561 wxASSERT(::GetMoviesError() == noErr);
562
563 ::MCDoAction(m_mc, 32, (void*)true); // mcActionSetKeysEnabled
564 wxASSERT(::GetMoviesError() == noErr);
565
566 // Setup a callback so we can tell when the user presses
567 // play on the player controls
568 m_mcactionupp = wxQTMediaBackend::MCFilterProc;
569 ::MCSetActionFilterWithRefCon( m_mc, m_mcactionupp, (long)this );
570 wxASSERT(::GetMoviesError() == noErr);
571
572 // Part of a suggestion from Greg Hazel to repaint movie when idle
573 m_ctrl->PushEventHandler(new wxQTMediaEvtHandler(this));
574
575 // Create offscreen GWorld for where to "show" when window is hidden
576 Rect worldRect;
577 worldRect.left = worldRect.top = 0;
578 worldRect.right = worldRect.bottom = 1;
579 ::NewGWorld(&m_movieWorld, 0, &worldRect, NULL, NULL, 0);
580
581 // Catch window messages:
582 // if we do not do this and if the user clicks the play
583 // button on the controller, for instance, nothing will happen...
584 EventTypeSpec theWindowEventTypes[] =
585 {
586 { kEventClassMouse, kEventMouseDown },
587 { kEventClassMouse, kEventMouseUp },
588 { kEventClassMouse, kEventMouseDragged },
589 { kEventClassKeyboard, kEventRawKeyDown },
590 { kEventClassKeyboard, kEventRawKeyRepeat },
591 { kEventClassKeyboard, kEventRawKeyUp },
592 { kEventClassWindow, kEventWindowUpdate },
593 { kEventClassWindow, kEventWindowActivated },
594 { kEventClassWindow, kEventWindowDeactivated }
595 };
596 m_windowUPP =
597 NewEventHandlerUPP( wxQTMediaBackend::WindowEventHandler );
598 InstallWindowEventHandler(
599 wrTLW,
600 m_windowUPP,
601 GetEventTypeCount( theWindowEventTypes ), theWindowEventTypes,
602 this,
603 &m_windowEventHandler );
604 }
605 else
606 {
607 // MovieController already created:
608 // Just change the movie in it and we're good to go
609 Point thePoint;
610 thePoint.h = thePoint.v = 0;
611 ::MCSetMovie(m_mc, m_movie,
612 (WindowRef)m_ctrl->MacGetTopLevelWindowRef(),
613 thePoint);
614 wxASSERT(::GetMoviesError() == noErr);
615 }
616}
617
618//---------------------------------------------------------------------------
619// wxQTMediaBackend::FinishLoad
620//
621// Performs operations after a movie ready to play/loaded.
622//---------------------------------------------------------------------------
623void wxQTMediaBackend::FinishLoad()
624{
625 // get the real size of the movie
626 DoLoadBestSize();
627
628 // show the player controls if the user wants to
629 if (m_interfaceflags)
630 DoSetControllerVisible(m_interfaceflags);
631
632 // we want millisecond precision
633 ::SetMovieTimeScale(m_movie, 1000);
634 wxASSERT(::GetMoviesError() == noErr);
635
636 // start movie progress timer
637 m_timer = new wxQTMediaPlayTimer(this);
638 wxASSERT(m_timer);
639 m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
640
641 // send loaded event and refresh size
642 NotifyMovieLoaded();
643}
644
645//---------------------------------------------------------------------------
646// wxQTMediaBackend::DoLoadBestSize
647//
648// Sets the best size of the control from the real size of the movie
649//---------------------------------------------------------------------------
650void wxQTMediaBackend::DoLoadBestSize()
651{
652 // get the real size of the movie
653 Rect outRect;
654 ::GetMovieNaturalBoundsRect(m_movie, &outRect);
655 wxASSERT(::GetMoviesError() == noErr);
656
657 // determine best size
658 m_bestSize.x = outRect.right - outRect.left;
659 m_bestSize.y = outRect.bottom - outRect.top;
660}
661
662//---------------------------------------------------------------------------
663// wxQTMediaBackend::Play
664//
665// Start the QT movie
666// (Apple recommends mcActionPrerollAndPlay but that's QT 4.1+)
667//---------------------------------------------------------------------------
668bool wxQTMediaBackend::Play()
669{
670 Fixed fixRate = (Fixed) (wxQTMediaBackend::GetPlaybackRate() * 0x10000);
671 if (!fixRate)
672 fixRate = ::GetMoviePreferredRate(m_movie);
673
674 wxASSERT(fixRate != 0);
675
676 if (!m_bPlaying)
677 ::MCDoAction( m_mc, 8 /* mcActionPlay */, (void*) fixRate);
678
679 bool result = (::GetMoviesError() == noErr);
680 if (result)
681 {
682 m_bPlaying = true;
683 QueuePlayEvent();
684 }
685
686 return result;
687}
688
689//---------------------------------------------------------------------------
690// wxQTMediaBackend::Pause
691//
692// Stop the movie
693//---------------------------------------------------------------------------
694bool wxQTMediaBackend::DoPause()
695{
696 // Stop the movie A.K.A. ::StopMovie(m_movie);
697 if (m_bPlaying)
698 {
699 ::MCDoAction( m_mc, 8 /*mcActionPlay*/, (void *) 0);
700 m_bPlaying = false;
701 return ::GetMoviesError() == noErr;
702 }
703
704 // already paused
705 return true;
706}
707
708bool wxQTMediaBackend::Pause()
709{
710 bool bSuccess = DoPause();
711 if (bSuccess)
712 this->QueuePauseEvent();
713
714 return bSuccess;
715}
716
717//---------------------------------------------------------------------------
718// wxQTMediaBackend::Stop
719//
720// 1) Stop the movie
721// 2) Seek to the beginning of the movie
722//---------------------------------------------------------------------------
723bool wxQTMediaBackend::DoStop()
724{
725 if (!wxQTMediaBackend::DoPause())
726 return false;
727
728 ::GoToBeginningOfMovie(m_movie);
729 return ::GetMoviesError() == noErr;
730}
731
732bool wxQTMediaBackend::Stop()
733{
734 bool bSuccess = DoStop();
735 if (bSuccess)
736 QueueStopEvent();
737
738 return bSuccess;
739}
740
741//---------------------------------------------------------------------------
742// wxQTMediaBackend::GetPlaybackRate
743//
744// 1) Get the movie playback rate from ::GetMovieRate
745//---------------------------------------------------------------------------
746double wxQTMediaBackend::GetPlaybackRate()
747{
748 return ( ((double)::GetMovieRate(m_movie)) / 0x10000);
749}
750
751//---------------------------------------------------------------------------
752// wxQTMediaBackend::SetPlaybackRate
753//
754// 1) Convert dRate to Fixed and Set the movie rate through SetMovieRate
755//---------------------------------------------------------------------------
756bool wxQTMediaBackend::SetPlaybackRate(double dRate)
757{
758 ::SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
759 return ::GetMoviesError() == noErr;
760}
761
762//---------------------------------------------------------------------------
763// wxQTMediaBackend::SetPosition
764//
765// 1) Create a time record struct (TimeRecord) with appropriate values
766// 2) Pass struct to SetMovieTime
767//---------------------------------------------------------------------------
768bool wxQTMediaBackend::SetPosition(wxLongLong where)
769{
770 TimeRecord theTimeRecord;
771 memset(&theTimeRecord, 0, sizeof(TimeRecord));
1f450872
SC
772 theTimeRecord.value.lo = where.GetLo();
773 theTimeRecord.value.hi = where.GetHi();
489468fe
SC
774 theTimeRecord.scale = ::GetMovieTimeScale(m_movie);
775 theTimeRecord.base = ::GetMovieTimeBase(m_movie);
776 ::SetMovieTime(m_movie, &theTimeRecord);
777
778 if (::GetMoviesError() != noErr)
779 return false;
780
781 return true;
782}
783
784//---------------------------------------------------------------------------
785// wxQTMediaBackend::GetPosition
786//
787// Calls GetMovieTime
788//---------------------------------------------------------------------------
789wxLongLong wxQTMediaBackend::GetPosition()
790{
791 return ::GetMovieTime(m_movie, NULL);
792}
793
794//---------------------------------------------------------------------------
795// wxQTMediaBackend::GetVolume
796//
797// Gets the volume through GetMovieVolume - which returns a 16 bit short -
798//
799// +--------+--------+
800// + (1) + (2) +
801// +--------+--------+
802//
803// (1) first 8 bits are value before decimal
804// (2) second 8 bits are value after decimal
805//
806// Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
807// 1 (full gain and sound)
808//---------------------------------------------------------------------------
809double wxQTMediaBackend::GetVolume()
810{
811 short sVolume = ::GetMovieVolume(m_movie);
812
813 if (sVolume & (128 << 8)) //negative - no sound
814 return 0.0;
815
816 return sVolume / 256.0;
817}
818
819//---------------------------------------------------------------------------
820// wxQTMediaBackend::SetVolume
821//
822// Sets the volume through SetMovieVolume - which takes a 16 bit short -
823//
824// +--------+--------+
825// + (1) + (2) +
826// +--------+--------+
827//
828// (1) first 8 bits are value before decimal
829// (2) second 8 bits are value after decimal
830//
831// Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
832// 1 (full gain and sound)
833//---------------------------------------------------------------------------
834bool wxQTMediaBackend::SetVolume(double dVolume)
835{
836 ::SetMovieVolume(m_movie, (short) (dVolume * 256));
837 return true;
838}
839
840//---------------------------------------------------------------------------
841// wxQTMediaBackend::GetDuration
842//
843// Calls GetMovieDuration
844//---------------------------------------------------------------------------
845wxLongLong wxQTMediaBackend::GetDuration()
846{
847 return ::GetMovieDuration(m_movie);
848}
849
850//---------------------------------------------------------------------------
851// wxQTMediaBackend::GetState
852//
853// Determines the current state - the timer keeps track of whether or not
854// we are paused or stopped (if the timer is running we are playing)
855//---------------------------------------------------------------------------
856wxMediaState wxQTMediaBackend::GetState()
857{
858 // Could use
859 // GetMovieActive/IsMovieDone/SetMovieActive
860 // combo if implemented that way
861 if (m_bPlaying)
862 return wxMEDIASTATE_PLAYING;
863 else if (!m_movie || wxQTMediaBackend::GetPosition() == 0)
864 return wxMEDIASTATE_STOPPED;
865 else
866 return wxMEDIASTATE_PAUSED;
867}
868
869//---------------------------------------------------------------------------
870// wxQTMediaBackend::Cleanup
871//
872// Diposes of the movie timer, Control if native, and stops and disposes
873// of the QT movie
874//---------------------------------------------------------------------------
875void wxQTMediaBackend::Cleanup()
876{
877 m_bPlaying = false;
5276b0a5 878 wxDELETE(m_timer);
489468fe
SC
879
880 // Stop the movie:
881 // Apple samples with CreateMovieControl typically
882 // install a event handler and do this on the dispose
883 // event, but we do it here for simplicity
884 // (It might keep playing for several seconds after
885 // control destruction if not)
886 wxQTMediaBackend::Pause();
887
888 // Dispose of control or remove movie from MovieController
889 Point thePoint;
890 thePoint.h = thePoint.v = 0;
891 ::MCSetVisible(m_mc, false);
892 ::MCSetMovie(m_mc, NULL, NULL, thePoint);
893
894 ::DisposeMovie(m_movie);
895 m_movie = NULL;
896}
897
898//---------------------------------------------------------------------------
899// wxQTMediaBackend::GetVideoSize
900//
901// Returns the actual size of the QT movie
902//---------------------------------------------------------------------------
903wxSize wxQTMediaBackend::GetVideoSize() const
904{
905 return m_bestSize;
906}
907
908//---------------------------------------------------------------------------
909// wxQTMediaBackend::Move
910//
911// Move the movie controller or movie control
912// (we need to actually move the movie control manually...)
913// Top 10 things to do with quicktime in March 93's issue
914// of DEVELOP - very useful
915// http:// www.mactech.com/articles/develop/issue_13/031-033_QuickTime_column.html
916// OLD NOTE: Calling MCSetControllerBoundsRect without detaching
917// supposively resulted in a crash back then. Current code even
918// with CFM classic runs fine. If there is ever a problem,
919// take out the if 0 lines below
920//---------------------------------------------------------------------------
921void wxQTMediaBackend::Move(int x, int y, int w, int h)
922{
923 if (m_timer)
924 {
925 m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
926 Rect theRect = {y, x, y + h, x + w};
927
928#if 0 // see note above
929 ::MCSetControllerAttached(m_mc, false);
930 wxASSERT(::GetMoviesError() == noErr);
931#endif
932
933 ::MCSetControllerBoundsRect(m_mc, &theRect);
934 wxASSERT(::GetMoviesError() == noErr);
935
936#if 0 // see note above
937 if (m_interfaceflags)
938 {
939 ::MCSetVisible(m_mc, true);
940 wxASSERT(::GetMoviesError() == noErr);
941 }
942#endif
943 }
944}
945
946//---------------------------------------------------------------------------
947// wxQTMediaBackend::DoSetControllerVisible
948//
949// Utility function that takes care of showing the moviecontroller
950// and showing/hiding the particular controls on it
951//---------------------------------------------------------------------------
952void wxQTMediaBackend::DoSetControllerVisible(
953 wxMediaCtrlPlayerControls flags)
954{
955 ::MCSetVisible(m_mc, true);
956
957 // Take care of subcontrols
958 if (::GetMoviesError() == noErr)
959 {
960 long mcFlags = 0;
961 ::MCDoAction(m_mc, 39/*mcActionGetFlags*/, (void*)&mcFlags);
962
963 if (::GetMoviesError() == noErr)
964 {
965 mcFlags |= ( //(1<<0)/*mcFlagSuppressMovieFrame*/ |
966 (1 << 3)/*mcFlagsUseWindowPalette*/
967 | ((flags & wxMEDIACTRLPLAYERCONTROLS_STEP)
968 ? 0 : (1 << 1)/*mcFlagSuppressStepButtons*/)
969 | ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)
970 ? 0 : (1 << 2)/*mcFlagSuppressSpeakerButton*/)
971 //if we take care of repainting ourselves
972 // | (1 << 4) /*mcFlagDontInvalidate*/
973 );
974
975 ::MCDoAction(m_mc, 38/*mcActionSetFlags*/, (void*)mcFlags);
976 }
977 }
978
979 // Adjust height and width of best size for movie controller
980 // if the user wants it shown
981 m_bestSize.x = m_bestSize.x > wxMCWIDTH ? m_bestSize.x : wxMCWIDTH;
982 m_bestSize.y += wxMCHEIGHT;
983}
984
985//---------------------------------------------------------------------------
986// wxQTMediaBackend::ShowPlayerControls
987//
988// Shows/Hides subcontrols on the media control
989//---------------------------------------------------------------------------
990bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
991{
992 if (!m_mc)
993 return false; // no movie controller...
994
995 bool bSizeChanged = false;
996
997 // if the controller is visible and we want to hide it do so
998 if (m_interfaceflags && !flags)
999 {
1000 bSizeChanged = true;
1001 DoLoadBestSize();
1002 ::MCSetVisible(m_mc, false);
1003 }
1004 else if (!m_interfaceflags && flags) // show controller if hidden
1005 {
1006 bSizeChanged = true;
1007 DoSetControllerVisible(flags);
1008 }
1009
1010 // readjust parent sizers
1011 if (bSizeChanged)
1012 {
1013 NotifyMovieSizeChanged();
1014
1015 // remember state in case of loading new media
1016 m_interfaceflags = flags;
1017 }
1018
1019 return ::GetMoviesError() == noErr;
1020}
1021
1022//---------------------------------------------------------------------------
1023// wxQTMediaBackend::GetDataSizeFromStart
1024//
1025// Calls either GetMovieDataSize or GetMovieDataSize64 with a value
1026// of 0 for the starting value
1027//---------------------------------------------------------------------------
1028wxLongLong wxQTMediaBackend::GetDataSizeFromStart(TimeValue end)
1029{
1030#if 0 // old pre-qt4 way
1031 return ::GetMovieDataSize(m_movie, 0, end)
1032#else // qt4 way
1033 wide llDataSize;
1034 ::GetMovieDataSize64(m_movie, 0, end, &llDataSize);
1035 return wxLongLong(llDataSize.hi, llDataSize.lo);
1036#endif
1037}
1038
1039//---------------------------------------------------------------------------
1040// wxQTMediaBackend::GetDownloadProgress
1041//---------------------------------------------------------------------------
1042wxLongLong wxQTMediaBackend::GetDownloadProgress()
1043{
1044#if 0 // hackish and slow
1045 Handle hMovie = NewHandle(0);
1046 PutMovieIntoHandle(m_movie, hMovie);
1047 long lSize = GetHandleSize(hMovie);
1048 DisposeHandle(hMovie);
1049
1050 return lSize;
1051#else
1052 TimeValue tv;
1053 if (::GetMaxLoadedTimeInMovie(m_movie, &tv) != noErr)
1054 {
1055 wxLogDebug(wxT("GetMaxLoadedTimeInMovie failed"));
1056 return 0;
1057 }
1058
1059 return wxQTMediaBackend::GetDataSizeFromStart(tv);
1060#endif
1061}
1062
1063//---------------------------------------------------------------------------
1064// wxQTMediaBackend::GetDownloadTotal
1065//---------------------------------------------------------------------------
1066wxLongLong wxQTMediaBackend::GetDownloadTotal()
1067{
1068 return wxQTMediaBackend::GetDataSizeFromStart(
1069 ::GetMovieDuration(m_movie)
1070 );
1071}
1072
1073//---------------------------------------------------------------------------
1074// wxQTMediaBackend::MacVisibilityChanged
1075//
1076// The main problem here is that Windows quicktime, for example,
1077// renders more directly to a HWND. Mac quicktime does not do this
1078// and instead renders to the port of the WindowRef/WindowPtr on top
1079// of everything else/all other windows.
1080//
1081// So, for example, if you were to have a CreateTabsControl/wxNotebook
1082// and change pages, even if you called HIViewSetVisible/SetControlVisibility
1083// directly the movie will still continue playing on top of everything else
1084// if you went to a different tab.
1085//
1086// Note that another issue, and why we call MCSetControllerPort instead
1087// of SetMovieGWorld directly, is that in addition to rendering on
1088// top of everything else the last created controller steals mouse and
1089// other input from everything else in the window, including other
1090// controllers. Setting the port of it releases this behaviour.
1091//---------------------------------------------------------------------------
1092void wxQTMediaBackend::MacVisibilityChanged()
1093{
1094 if(!m_mc || !m_ctrl->m_bLoaded)
1095 return; //not initialized yet
1096
1097 if(m_ctrl->IsShownOnScreen())
1098 {
1099 //The window is being shown again, so set the GWorld of the
1100 //controller back to the port of the parent WindowRef
1101 WindowRef wrTLW =
1102 (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
1103
1104 ::MCSetControllerPort(m_mc, (CGrafPtr) GetWindowPort(wrTLW));
1105 wxASSERT(::GetMoviesError() == noErr);
1106 }
1107 else
1108 {
1109 //We are being hidden - set the GWorld of the controller
1110 //to the offscreen GWorld
1111 ::MCSetControllerPort(m_mc, m_movieWorld);
1112 wxASSERT(::GetMoviesError() == noErr);
1113 }
1114}
1115
1116//---------------------------------------------------------------------------
1117// wxQTMediaBackend::OnEraseBackground
1118//
1119// Suggestion from Greg Hazel to repaint the movie when idle
1120// (on pause also)
1121//---------------------------------------------------------------------------
1122void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
1123{
1124 // Work around Nasty OSX drawing bug:
1125 // http://lists.apple.com/archives/QuickTime-API/2002/Feb/msg00311.html
1126 WindowRef wrTLW = (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
1127
1128 RgnHandle region = ::MCGetControllerBoundsRgn(m_qtb->m_mc);
1129 ::MCInvalidate(m_qtb->m_mc, wrTLW, region);
1130 ::MCIdle(m_qtb->m_mc);
1131}
1132
1133//---------------------------------------------------------------------------
1134// wxQTMediaBackend::PPRMProc (static)
1135//
1136// Called when done PrePrerolling the movie.
1137// Note that in 99% of the cases this does nothing...
1138// Anyway we set up the loading timer here to tell us when the movie is done
1139//---------------------------------------------------------------------------
1140pascal void wxQTMediaBackend::PPRMProc(
1141 Movie theMovie,
1142 OSErr WXUNUSED_UNLESS_DEBUG(theErr),
1143 void* theRefCon)
1144{
1145 wxASSERT( theMovie );
1146 wxASSERT( theRefCon );
1147 wxASSERT( theErr == noErr );
1148
1149 wxQTMediaBackend* pBE = (wxQTMediaBackend*) theRefCon;
1150
1151 long lTime = ::GetMovieTime(theMovie,NULL);
1152 Fixed rate = ::GetMoviePreferredRate(theMovie);
1153 ::PrerollMovie(theMovie,lTime,rate);
1154 pBE->m_timer = new wxQTMediaLoadTimer(pBE);
1155 pBE->m_timer->Start(MOVIE_DELAY);
1156}
1157
1158//---------------------------------------------------------------------------
1159// wxQTMediaBackend::MCFilterProc (static)
1160//
4c51a665 1161// Callback for when the movie controller receives a message
489468fe
SC
1162//---------------------------------------------------------------------------
1163pascal Boolean wxQTMediaBackend::MCFilterProc(
1164 MovieController WXUNUSED(theController),
1165 short action,
1166 void * WXUNUSED(params),
1167 long refCon)
1168{
1169 wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
1170
1171 switch (action)
1172 {
1173 case 1:
1174 // don't process idle events
1175 break;
1176
1177 case 8:
1178 // play button triggered - MC will set movie to opposite state
1179 // of current - playing ? paused : playing
1180 pThis->m_bPlaying = !(pThis->m_bPlaying);
1181 break;
1182
1183 default:
1184 break;
1185 }
1186
1187 return 0;
1188}
1189
1190//---------------------------------------------------------------------------
1191// wxQTMediaBackend::WindowEventHandler [static]
1192//
1193// Event callback for the top level window of our control that passes
1194// messages to our moviecontroller so it can receive mouse clicks etc.
1195//---------------------------------------------------------------------------
1196pascal OSStatus wxQTMediaBackend::WindowEventHandler(
1197 EventHandlerCallRef WXUNUSED(inHandlerCallRef),
1198 EventRef inEvent,
1199 void *inUserData)
1200{
1201 wxQTMediaBackend* be = (wxQTMediaBackend*) inUserData;
1202
1203 // Only process keyboard messages on this window if it actually
1204 // has focus, otherwise it will steal keystrokes from other windows!
1205 // As well as when it is not loaded properly as it
1206 // will crash in MCIsPlayerEvent
1207 if((GetEventClass(inEvent) == kEventClassKeyboard &&
1208 wxWindow::FindFocus() != be->m_ctrl)
1209 || !be->m_ctrl->m_bLoaded)
1210 return eventNotHandledErr;
1211
1212 // Pass the event onto the movie controller
1213 EventRecord theEvent;
1214 ConvertEventRefToEventRecord( inEvent, &theEvent );
1215 OSStatus err;
1216
1217 // TODO: Apple says MCIsPlayerEvent is depreciated and
1218 // MCClick, MCKey, MCIdle etc. should be used
1219 // (RN: Of course that's what they say about
1220 // CreateMovieControl and HIMovieView as well, LOL!)
1221 err = ::MCIsPlayerEvent( be->m_mc, &theEvent );
1222
1223 // Pass on to other event handlers if not handled- i.e. wx
1224 if (err != noErr)
1225 return noErr;
1226 else
1227 return eventNotHandledErr;
1228}
1229
1230#endif
1231
1232// in source file that contains stuff you don't directly use
1233#include "wx/html/forcelnk.h"
1234FORCE_LINK_ME(basewxmediabackends)
1235
1236#endif // wxUSE_MEDIACTRL