]> git.saurik.com Git - wxWidgets.git/blob - src/unix/mediactrl.cpp
cleanup - reformat
[wxWidgets.git] / src / unix / mediactrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/mediactrl.cpp
3 // Purpose: Built-in Media Backends for Unix
4 // Author: Ryan Norton <wxprojects@comcast.net>
5 // Modified by:
6 // Created: 02/04/05
7 // RCS-ID: $Id$
8 // Copyright: (c) 2004-2005 Ryan Norton
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 //===========================================================================
13 // DECLARATIONS
14 //===========================================================================
15
16 //---------------------------------------------------------------------------
17 // Pre-compiled header stuff
18 //---------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 //---------------------------------------------------------------------------
28 // Includes
29 //---------------------------------------------------------------------------
30 #include "wx/mediactrl.h"
31
32 //---------------------------------------------------------------------------
33 // Compilation guard
34 //---------------------------------------------------------------------------
35 #if wxUSE_MEDIACTRL
36
37 //===========================================================================
38 // BACKEND DECLARATIONS
39 //===========================================================================
40
41 //---------------------------------------------------------------------------
42 //
43 // wxGStreamerMediaBackend
44 //
45 //TODO:
46 //TODO: This is really not the best way to play-stop -
47 //TODO: it should just have one playbin and stick with it the whole
48 //TODO: instance of wxGStreamerMediaBackend - but stopping appears
49 //TODO: to invalidate the playbin object...
50 //TODO:
51 //
52 //---------------------------------------------------------------------------
53 #if wxUSE_GSTREAMER
54
55 //---------------------------------------------------------------------------
56 // GStreamer Includes
57 //---------------------------------------------------------------------------
58 #include <gst/gst.h>
59 #include <gst/xoverlay/xoverlay.h>
60
61 #include <string.h> //strstr
62
63 #include "wx/log.h"
64
65 #ifdef __WXGTK__
66 //for <gdk/gdkx.h>/related for GDK_WINDOW_XWINDOW
67 # include "wx/gtk/win_gtk.h"
68 # include <gtk/gtksignal.h>
69 # if wxUSE_DYNLIB_CLASS
70 # include "wx/dynlib.h"
71 # endif
72 //# include <gst/gconf/gconf.h> //gstreamer gnome interface - needs deps
73 #endif
74
75
76 class WXDLLIMPEXP_MEDIA wxGStreamerMediaBackend : public wxMediaBackend
77 {
78 public:
79
80 wxGStreamerMediaBackend();
81 ~wxGStreamerMediaBackend();
82
83 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
84 wxWindowID id,
85 const wxPoint& pos,
86 const wxSize& size,
87 long style,
88 const wxValidator& validator,
89 const wxString& name);
90
91 virtual bool Play();
92 virtual bool Pause();
93 virtual bool Stop();
94
95 virtual bool Load(const wxString& fileName);
96 virtual bool Load(const wxURI& location);
97
98 virtual wxMediaState GetState();
99
100 virtual bool SetPosition(wxLongLong where);
101 virtual wxLongLong GetPosition();
102 virtual wxLongLong GetDuration();
103
104 virtual void Move(int x, int y, int w, int h);
105 wxSize GetVideoSize() const;
106
107 virtual double GetPlaybackRate();
108 virtual bool SetPlaybackRate(double dRate);
109
110 void Cleanup();
111
112 static void OnFinish(GstElement *play, gpointer data);
113 static void OnError (GstElement *play, GstElement *src,
114 GError *err, gchar *debug,
115 gpointer data);
116 static void OnVideoCapsReady(GstPad* pad, GParamSpec* pspec, gpointer data);
117
118 static bool TransCapsToVideoSize(wxGStreamerMediaBackend* be, GstPad* caps);
119 void PostRecalcSize();
120
121 #ifdef __WXGTK__
122 static gint OnGTKRealize(GtkWidget* theWidget, wxGStreamerMediaBackend* be);
123 #endif
124
125 GstElement* m_player; //GStreamer media element
126
127 wxSize m_videoSize;
128 wxControl* m_ctrl;
129
130 wxLongLong m_nPausedPos;
131
132 DECLARE_DYNAMIC_CLASS(wxGStreamerMediaBackend);
133 };
134
135
136 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
137 //
138 // wxGStreamerMediaBackend
139 //
140 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
141
142 IMPLEMENT_DYNAMIC_CLASS(wxGStreamerMediaBackend, wxMediaBackend)
143
144 //---------------------------------------------------------------------------
145 // wxGStreamerMediaBackend Constructor
146 //
147 // Sets m_player to NULL signifying we havn't loaded anything yet
148 //---------------------------------------------------------------------------
149 wxGStreamerMediaBackend::wxGStreamerMediaBackend() : m_player(NULL), m_videoSize(0,0)
150 {
151 }
152
153 //---------------------------------------------------------------------------
154 // wxGStreamerMediaBackend Destructor
155 //
156 // Stops/cleans up memory
157 //---------------------------------------------------------------------------
158 wxGStreamerMediaBackend::~wxGStreamerMediaBackend()
159 {
160 Cleanup();
161 }
162
163 //---------------------------------------------------------------------------
164 // wxGStreamerMediaBackend::OnGTKRealize
165 //
166 // If the window wasn't realized when Load was called, this is the
167 // callback for when it is.
168 //
169 // 1) Installs GTK idle handler if it doesn't exist
170 // 2) Yeilds to avoid an X11 bug (?)
171 // 3) Tells GStreamer to play the video in our control
172 //---------------------------------------------------------------------------
173 #ifdef __WXGTK__
174
175 #ifdef __WXDEBUG__
176
177 #if wxUSE_THREADS
178 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
179 #else
180 # define DEBUG_MAIN_THREAD
181 #endif
182 #else
183 #define DEBUG_MAIN_THREAD
184 #endif // Debug
185
186 extern void wxapp_install_idle_handler();
187 extern bool g_isIdle;
188 extern bool g_mainThreadLocked;
189
190 gint wxGStreamerMediaBackend::OnGTKRealize(GtkWidget* theWidget,
191 wxGStreamerMediaBackend* be)
192 {
193 DEBUG_MAIN_THREAD
194
195 if (g_isIdle)
196 wxapp_install_idle_handler();
197
198 wxYield(); //FIXME: X Server gets an error if I don't do this or a messagebox beforehand?!?!??
199
200 GdkWindow *window = GTK_PIZZA(theWidget)->bin_window;
201 wxASSERT(window);
202
203 GstElement* videosink;
204 g_object_get (G_OBJECT (be->m_player), "video-sink", &videosink, NULL);
205
206 GstElement* overlay = gst_bin_get_by_interface (GST_BIN (videosink),
207 GST_TYPE_X_OVERLAY);
208 gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(overlay),
209 GDK_WINDOW_XWINDOW( window )
210 );
211
212 return 0;
213 }
214
215
216 #endif
217
218 //---------------------------------------------------------------------------
219 // wxGStreamerMediaBackend::Cleanup
220 //
221 // Frees the gstreamer interfaces if there were any created
222 //---------------------------------------------------------------------------
223 void wxGStreamerMediaBackend::Cleanup()
224 {
225 if(m_player && GST_IS_OBJECT(m_player))
226 {
227 gst_element_set_state (m_player, GST_STATE_NULL);
228 gst_object_unref (GST_OBJECT (m_player));
229 }
230 }
231
232 //---------------------------------------------------------------------------
233 // wxGStreamerMediaBackend::CreateControl
234 //
235 // Initializes GStreamer and creates the wx side of our media control
236 //---------------------------------------------------------------------------
237 bool wxGStreamerMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
238 wxWindowID id,
239 const wxPoint& pos,
240 const wxSize& size,
241 long style,
242 const wxValidator& validator,
243 const wxString& name)
244 {
245 //init gstreamer
246 gst_init(NULL, NULL);
247
248 m_ctrl = ctrl;
249
250 return m_ctrl->wxControl::Create(parent, id, pos, size,
251 style, //remove borders???
252 validator, name);
253 }
254
255 //---------------------------------------------------------------------------
256 // wxGStreamerMediaBackend::TransCapsToVideoSize
257 //
258 // Gets the size of our video (in wxSize) from a GstPad
259 //---------------------------------------------------------------------------
260 bool wxGStreamerMediaBackend::TransCapsToVideoSize(wxGStreamerMediaBackend* be, GstPad* pad)
261 {
262 const GstCaps* caps = GST_PAD_CAPS (pad);
263 if(caps)
264 {
265
266 const GstStructure *s;
267 s = gst_caps_get_structure (caps, 0);
268 wxASSERT(s);
269
270 gst_structure_get_int (s, "width", &be->m_videoSize.x);
271 gst_structure_get_int (s, "height", &be->m_videoSize.y);
272
273 wxLogDebug(wxT("Native video size: [%i,%i]"), be->m_videoSize.x, be->m_videoSize.y);
274
275 const GValue *par;
276 par = gst_structure_get_value (s, "pixel-aspect-ratio");
277
278 if (par)
279 {
280 int num = gst_value_get_fraction_numerator (par),
281 den = gst_value_get_fraction_denominator (par);
282
283 //TODO: maybe better fraction normalization...
284 if (num > den)
285 be->m_videoSize.x = (int) ((float) num * be->m_videoSize.x / den);
286 else
287 be->m_videoSize.y = (int) ((float) den * be->m_videoSize.y / num);
288 }
289
290 wxLogDebug(wxT("Adjusted video size: [%i,%i]"), be->m_videoSize.x, be->m_videoSize.y);
291
292 be->PostRecalcSize();
293 return true;
294 }//end if caps
295
296 return false;
297 }
298
299 //---------------------------------------------------------------------------
300 // wxGStreamerMediaBackend::PostRecalcSize
301 //
302 // Forces parent to recalc its layout if it has sizers to update
303 // to the new video size
304 //---------------------------------------------------------------------------
305 void wxGStreamerMediaBackend::PostRecalcSize()
306 {
307 m_ctrl->InvalidateBestSize();
308 m_ctrl->GetParent()->Layout();
309 m_ctrl->GetParent()->Refresh();
310 m_ctrl->GetParent()->Update();
311 m_ctrl->SetSize(m_ctrl->GetSize());
312 }
313
314 //---------------------------------------------------------------------------
315 // wxGStreamerMediaBackend::OnFinish
316 //
317 // Called by gstreamer when the media is done playing
318 //
319 // 1) Send a wxEVT_MEDIA_STOP to the control
320 // 2) If veteod, break out
321 // 3) really stop the media
322 // 4) Send a wxEVT_MEDIA_FINISHED to the control
323 //---------------------------------------------------------------------------
324 void wxGStreamerMediaBackend::OnFinish(GstElement *play, gpointer data)
325 {
326 wxGStreamerMediaBackend* m_parent = (wxGStreamerMediaBackend*) data;
327
328 wxMediaEvent theEvent(wxEVT_MEDIA_STOP,
329 m_parent->m_ctrl->GetId());
330 m_parent->m_ctrl->ProcessEvent(theEvent);
331
332 if(theEvent.IsAllowed())
333 {
334 bool bOk = m_parent->Stop();
335 wxASSERT(bOk);
336
337 //send the event to our child
338 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
339 m_parent->m_ctrl->GetId());
340 m_parent->m_ctrl->ProcessEvent(theEvent);
341 }
342 }
343
344 //---------------------------------------------------------------------------
345 // wxGStreamerMediaBackend::OnError
346 //
347 // Called by gstreamer when an error is encountered playing the media
348 //
349 // TODO: Make this better - maybe some more intelligent wxLog stuff
350 //---------------------------------------------------------------------------
351 void wxGStreamerMediaBackend::OnError(GstElement *play,
352 GstElement *src,
353 GError *err,
354 gchar *debug,
355 gpointer data)
356 {
357 wxLogSysError(
358 wxString::Format(
359 wxT("Error in wxMediaCtrl!\nError Message:%s\nDebug:%s\n"),
360 (const wxChar*)wxConvUTF8.cMB2WX(err->message),
361 (const wxChar*)wxConvUTF8.cMB2WX(debug)
362 )
363 );
364 }
365
366
367 //---------------------------------------------------------------------------
368 // wxGStreamerMediaBackend::Load (File version)
369 //
370 // Just calls the URI version
371 //---------------------------------------------------------------------------
372 bool wxGStreamerMediaBackend::Load(const wxString& fileName)
373 {
374 return Load(
375 wxURI(
376 wxString( wxT("file://") ) + fileName
377 )
378 );
379 }
380
381 //---------------------------------------------------------------------------
382 // wxGStreamerMediaBackend::OnVideoCapsReady
383 //
384 // Called by gstreamer when the video caps for the media is ready
385 //---------------------------------------------------------------------------
386 void wxGStreamerMediaBackend::OnVideoCapsReady(GstPad* pad, GParamSpec* pspec, gpointer data)
387 {
388 wxGStreamerMediaBackend::TransCapsToVideoSize((wxGStreamerMediaBackend*) data, pad);
389 }
390
391 //---------------------------------------------------------------------------
392 // wxGStreamerMediaBackend::Load (URI version)
393 //
394 // 1) Stops/Cleanups the previous instance if there is any
395 // 2) Creates the gstreamer playbin
396 // 3) If there is no playbin bail out
397 // 4) Set up the error and end-of-stream callbacks for our player
398 // 5) Make our video sink and make sure it supports the x overlay interface
399 // 6) Make sure the passed URI is valid and tell playbin to load it
400 // 7) Use the xoverlay extension to tell gstreamer to play in our window
401 // 8) Get the video size - pause required to set the stream in action
402 //---------------------------------------------------------------------------
403 bool wxGStreamerMediaBackend::Load(const wxURI& location)
404 {
405 //1
406 Cleanup();
407
408 //2
409 m_player = gst_element_factory_make ("playbin", "play");
410
411 //3
412 if (!m_player)
413 return false;
414
415 //4
416 g_signal_connect (m_player, "eos", G_CALLBACK (OnFinish), this);
417 g_signal_connect (m_player, "error", G_CALLBACK (OnError), this);
418
419 //5
420 GstElement* overlay = NULL;
421 GstElement* videosink;
422
423 #if defined(__WXGTK__) && wxUSE_DYNLIB_CLASS
424
425 //use gnome-specific gstreamer extensions
426 //if synthisis (?) file not found, it
427 //spits out a warning and uses ximagesink
428 wxDynamicLibrary gstgconf;
429 if(gstgconf.Load(gstgconf.CanonicalizeName(wxT("gstgconf-0.8"))))
430 {
431 typedef GstElement* (*LPgst_gconf_get_default_video_sink) (void);
432 LPgst_gconf_get_default_video_sink pGst_gconf_get_default_video_sink =
433 (LPgst_gconf_get_default_video_sink)
434 gstgconf.GetSymbol(wxT("gst_gconf_get_default_video_sink"));
435
436 if (pGst_gconf_get_default_video_sink)
437 {
438 videosink = (*pGst_gconf_get_default_video_sink) ();
439 wxASSERT( GST_IS_BIN(videosink) );
440 overlay = gst_bin_get_by_interface (GST_BIN (videosink),
441 GST_TYPE_X_OVERLAY);
442 }
443
444 gstgconf.Detach();
445 }
446
447 if ( ! GST_IS_X_OVERLAY(overlay) )
448 {
449 #endif
450 wxLogDebug(wxT("Could not load Gnome preferences, reverting to xvimagesink for video for gstreamer"));
451 videosink = gst_element_factory_make ("xvimagesink", "videosink");
452 if ( !GST_IS_OBJECT(videosink) )
453 videosink = gst_element_factory_make ("ximagesink", "videosink");
454
455 overlay = videosink;
456
457 wxASSERT( GST_IS_X_OVERLAY(overlay) );
458 if ( ! GST_IS_X_OVERLAY(overlay) )
459 return false;
460 #if defined(__WXGTK__) && wxUSE_DYNLIB_CLASS
461 }
462 #endif
463
464 g_object_set (G_OBJECT (m_player),
465 "video-sink", videosink,
466 // "audio-sink", m_audiosink,
467 NULL);
468
469 //6
470 wxString locstring = location.BuildUnescapedURI();
471 wxASSERT(gst_uri_protocol_is_valid("file"));
472 wxASSERT(gst_uri_is_valid(locstring.mb_str()));
473
474 g_object_set (G_OBJECT (m_player), "uri", (const char*)locstring.mb_str(), NULL);
475
476 //7
477 #ifdef __WXGTK__
478 if(!GTK_WIDGET_REALIZED(m_ctrl->m_wxwindow))
479 {
480 //Not realized yet - set to connect at realization time
481 gtk_signal_connect( GTK_OBJECT(m_ctrl->m_wxwindow),
482 "realize",
483 GTK_SIGNAL_FUNC(wxGStreamerMediaBackend::OnGTKRealize),
484 (gpointer) this );
485 }
486 else
487 {
488 wxYield(); //see realize callback...
489 GdkWindow *window = GTK_PIZZA(m_ctrl->m_wxwindow)->bin_window;
490 wxASSERT(window);
491 #endif
492
493
494 gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(overlay),
495 #ifdef __WXGTK__
496 GDK_WINDOW_XWINDOW( window )
497 #else
498 ctrl->GetHandle()
499 #endif
500 );
501
502 #ifdef __WXGTK__
503 } //end else block
504 #endif
505
506 //8
507 int nResult = gst_element_set_state (m_player, GST_STATE_PAUSED);
508 if(nResult != GST_STATE_SUCCESS)
509 {
510 wxLogDebug(wxT("Could not set initial state to paused!"));
511 return false;
512 }
513
514 const GList *list = NULL;
515 g_object_get (G_OBJECT (m_player), "stream-info", &list, NULL);
516
517 bool bVideoFound = false;
518
519 for ( ; list != NULL; list = list->next)
520 {
521 GObject *info = (GObject *) list->data;
522 gint type;
523 GParamSpec *pspec;
524 GEnumValue *val;
525 GstPad *pad = NULL;
526
527 g_object_get (info, "type", &type, NULL);
528 pspec = g_object_class_find_property (
529 G_OBJECT_GET_CLASS (info), "type");
530 val = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, type);
531
532 if (strstr (val->value_name, "VIDEO"))
533 {
534 //Newer gstreamer 0.8+ is SUPPOSED to have "object"...
535 //but a lot of old plugins still use "pad" :)
536 pspec = g_object_class_find_property (
537 G_OBJECT_GET_CLASS (info), "object");
538
539 if (!pspec)
540 g_object_get (info, "pad", &pad, NULL);
541 else
542 g_object_get (info, "object", &pad, NULL);
543
544 pad = (GstPad *) GST_PAD_REALIZE (pad);
545 wxASSERT(pad);
546
547 if(!wxGStreamerMediaBackend::TransCapsToVideoSize(this, pad));
548 {
549 //wait for those caps to get ready
550 g_signal_connect(
551 pad,
552 "notify::caps",
553 G_CALLBACK(wxGStreamerMediaBackend::OnVideoCapsReady),
554 this);
555 }
556
557 bVideoFound = true;
558 break;
559 }//end if video
560 else
561 {
562 m_videoSize = wxSize(0,0);
563 PostRecalcSize();
564 }
565 }//end searching through info list
566
567 if(!bVideoFound)
568 {
569 wxLogDebug(wxT("No video found for gstreamer stream"));
570 }
571 m_nPausedPos = 0;
572
573 //send loaded event
574 wxMediaEvent theEvent(wxEVT_MEDIA_LOADED,
575 m_ctrl->GetId());
576 m_ctrl->AddPendingEvent(theEvent);
577
578 return true;
579 }
580
581 //---------------------------------------------------------------------------
582 // wxGStreamerMediaBackend::Play
583 //
584 // Sets the stream to a playing state
585 //---------------------------------------------------------------------------
586 bool wxGStreamerMediaBackend::Play()
587 {
588 if (gst_element_set_state (m_player, GST_STATE_PLAYING)
589 != GST_STATE_SUCCESS)
590 return false;
591 return true;
592 }
593
594 //---------------------------------------------------------------------------
595 // wxGStreamerMediaBackend::Pause
596 //
597 // Marks where we paused and pauses the stream
598 //---------------------------------------------------------------------------
599 bool wxGStreamerMediaBackend::Pause()
600 {
601 m_nPausedPos = GetPosition();
602 if (gst_element_set_state (m_player, GST_STATE_PAUSED)
603 != GST_STATE_SUCCESS)
604 return false;
605 return true;
606 }
607
608 //---------------------------------------------------------------------------
609 // wxGStreamerMediaBackend::Stop
610 //
611 // Pauses the stream and sets the position to 0
612 //---------------------------------------------------------------------------
613 bool wxGStreamerMediaBackend::Stop()
614 {
615 if (gst_element_set_state (m_player,
616 GST_STATE_PAUSED) != GST_STATE_SUCCESS)
617 return false;
618 return wxGStreamerMediaBackend::SetPosition(0);
619 }
620
621 //---------------------------------------------------------------------------
622 // wxGStreamerMediaBackend::GetState
623 //
624 // Gets the state of the stream
625 //---------------------------------------------------------------------------
626 wxMediaState wxGStreamerMediaBackend::GetState()
627 {
628 switch(GST_STATE(m_player))
629 {
630 case GST_STATE_PLAYING:
631 return wxMEDIASTATE_PLAYING;
632 case GST_STATE_PAUSED:
633 if (m_nPausedPos == 0)
634 return wxMEDIASTATE_STOPPED;
635 else
636 return wxMEDIASTATE_PAUSED;
637 default://case GST_STATE_READY:
638 return wxMEDIASTATE_STOPPED;
639 }
640 }
641
642 //---------------------------------------------------------------------------
643 // wxGStreamerMediaBackend::GetPosition
644 //
645 // If paused, returns our marked position - otherwise it queries the
646 // GStreamer playbin for the position and returns that
647 //
648 //TODO:
649 //TODO: In lue of the last big TODO, when you pause and seek gstreamer
650 //TODO: doesn't update the position sometimes, so we need to keep track of whether
651 //TODO: we have paused or not and keep track of the time after the pause
652 //TODO: and whenever the user seeks while paused
653 //TODO:
654 //---------------------------------------------------------------------------
655 wxLongLong wxGStreamerMediaBackend::GetPosition()
656 {
657 if(GetState() != wxMEDIASTATE_PLAYING)
658 return m_nPausedPos;
659 else
660 {
661 gint64 pos;
662 GstFormat fmtTime = GST_FORMAT_TIME;
663
664 if (!gst_element_query (m_player, GST_QUERY_POSITION, &fmtTime, &pos))
665 return 0;
666 return pos / GST_MSECOND ;
667 }
668 }
669
670 //---------------------------------------------------------------------------
671 // wxGStreamerMediaBackend::SetPosition
672 //
673 // Sets the position of the stream
674 // Note that GST_MSECOND is 1000000 (GStreamer uses nanoseconds - so
675 // there is 1000000 nanoseconds in a millisecond)
676 //
677 // If paused marks where we seeked to
678 //---------------------------------------------------------------------------
679 bool wxGStreamerMediaBackend::SetPosition(wxLongLong where)
680 {
681 if( gst_element_seek (m_player, (GstSeekType) (GST_SEEK_METHOD_SET |
682 GST_FORMAT_TIME | GST_SEEK_FLAG_FLUSH),
683 where.GetValue() * GST_MSECOND ) )
684 {
685 if (GetState() != wxMEDIASTATE_PLAYING)
686 m_nPausedPos = where;
687
688 return true;
689 }
690
691 return false;
692 }
693
694 //---------------------------------------------------------------------------
695 // wxGStreamerMediaBackend::GetDuration
696 //
697 // Obtains the total time of our stream
698 //---------------------------------------------------------------------------
699 wxLongLong wxGStreamerMediaBackend::GetDuration()
700 {
701 gint64 length;
702 GstFormat fmtTime = GST_FORMAT_TIME;
703
704 if(!gst_element_query(m_player, GST_QUERY_TOTAL, &fmtTime, &length))
705 return 0;
706 return length / GST_MSECOND ;
707 }
708
709 //---------------------------------------------------------------------------
710 // wxGStreamerMediaBackend::Move
711 //
712 // Called when the window is moved - GStreamer takes care of this
713 // for us so nothing is needed
714 //---------------------------------------------------------------------------
715 void wxGStreamerMediaBackend::Move(int x, int y, int w, int h)
716 {
717 }
718
719 //---------------------------------------------------------------------------
720 // wxGStreamerMediaBackend::GetVideoSize
721 //
722 // Returns our cached video size from Load/OnVideoCapsReady
723 //---------------------------------------------------------------------------
724 wxSize wxGStreamerMediaBackend::GetVideoSize() const
725 {
726 return m_videoSize;
727 }
728
729 //---------------------------------------------------------------------------
730 // wxGStreamerMediaBackend::GetPlaybackRate
731 // wxGStreamerMediaBackend::SetPlaybackRate
732 //
733 // Obtains/Sets the playback rate of the stream
734 //
735 //TODO: PlaybackRate not currently supported via playbin directly -
736 //TODO: Ronald S. Bultje noted on gstreamer-devel:
737 //TODO:
738 //TODO: Like "play at twice normal speed"? Or "play at 25 fps and 44,1 kHz"? As
739 //TODO: for the first, yes, we have elements for that, btu they"re not part of
740 //TODO: playbin. You can create a bin (with a ghost pad) containing the actual
741 //TODO: video/audiosink and the speed-changing element for this, and set that
742 //TODO: element as video-sink or audio-sink property in playbin. The
743 //TODO: audio-element is called "speed", the video-element is called "videodrop"
744 //TODO: (although that appears to be deprecated in favour of "videorate", which
745 //TODO: again cannot do this, so this may not work at all in the end). For
746 //TODO: forcing frame/samplerates, see audioscale and videorate. Audioscale is
747 //TODO: part of playbin.
748 //---------------------------------------------------------------------------
749 double wxGStreamerMediaBackend::GetPlaybackRate()
750 {
751 //not currently supported via playbin
752 return 1.0;
753 }
754
755 bool wxGStreamerMediaBackend::SetPlaybackRate(double dRate)
756 {
757 //not currently supported via playbin
758 return false;
759 }
760
761 #endif //wxUSE_GSTREAMER
762
763 //in source file that contains stuff you don't directly use
764 #include "wx/html/forcelnk.h"
765 FORCE_LINK_ME(basewxmediabackends)
766
767 #endif //wxUSE_MEDIACTRL