X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e47570f11c39e6456d068755cab2e04295f44a0d..19c5a468e9e35303ad67e40259885dededdcdafa:/src/unix/mediactrl.cpp diff --git a/src/unix/mediactrl.cpp b/src/unix/mediactrl.cpp index 522f2121b7..cf20c15e2e 100644 --- a/src/unix/mediactrl.cpp +++ b/src/unix/mediactrl.cpp @@ -46,7 +46,13 @@ // // wxGStreamerMediaBackend // -// Uses nanoseconds... +//TODO: +//TODO: This is really not the best way to play-stop - +//TODO: it should just have one playbin and stick with it the whole +//TODO: instance of wxGStreamerMediaBackend - but stopping appears +//TODO: to invalidate the playbin object... +//TODO: +// //--------------------------------------------------------------------------- #if wxUSE_GSTREAMER @@ -59,20 +65,17 @@ #include //strstr #include "wx/log.h" -#include "wx/msgdlg.h" #ifdef __WXGTK__ //for /related for GDK_WINDOW_XWINDOW # include "wx/gtk/win_gtk.h" # include +# if wxUSE_DYNLIB_CLASS +# include "wx/dynlib.h" +# endif +//# include //gstreamer gnome interface - needs deps #endif -//FIXME: -//FIXME: This is really not the best way to play-stop - -//FIXME: it should just have one playbin and stick with it the whole -//FIXME: instance of wxGStreamerMediaBackend - but stopping appears -//FIXME: to invalidate the playbin object... -//FIXME: class WXDLLIMPEXP_MEDIA wxGStreamerMediaBackend : public wxMediaBackend { @@ -124,18 +127,10 @@ public: #endif GstElement* m_player; //GStreamer media element - GstElement* m_audiosink; - GstElement* m_videosink; wxSize m_videoSize; wxControl* m_ctrl; - //FIXME: - //FIXME: In lue of the last big FIXME, when you pause and seek gstreamer - //FIXME: doesn't update the position sometimes, so we need to keep track of whether - //FIXME: we have paused or not and keep track of the time after the pause - //FIXME: and whenever the user seeks while paused - //FIXME: wxLongLong m_nPausedPos; DECLARE_DYNAMIC_CLASS(wxGStreamerMediaBackend); @@ -150,15 +145,35 @@ public: IMPLEMENT_DYNAMIC_CLASS(wxGStreamerMediaBackend, wxMediaBackend); +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend Constructor +// +// Sets m_player to NULL signifying we havn't loaded anything yet +//--------------------------------------------------------------------------- wxGStreamerMediaBackend::wxGStreamerMediaBackend() : m_player(NULL), m_videoSize(0,0) { } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend Destructor +// +// Stops/cleans up memory +//--------------------------------------------------------------------------- wxGStreamerMediaBackend::~wxGStreamerMediaBackend() { Cleanup(); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::OnGTKRealize +// +// If the window wasn't realized when Load was called, this is the +// callback for when it is. +// +// 1) Installs GTK idle handler if it doesn't exist +// 2) Yeilds to avoid an X11 bug (?) +// 3) Tells GStreamer to play the video in our control +//--------------------------------------------------------------------------- #ifdef __WXGTK__ #ifdef __WXDEBUG__ @@ -184,14 +199,19 @@ gint wxGStreamerMediaBackend::OnGTKRealize(GtkWidget* theWidget, if (g_isIdle) wxapp_install_idle_handler(); - wxYield(); //X Server gets an error if I don't do this or a messagebox beforehand?!?!?? + wxYield(); //FIXME: X Server gets an error if I don't do this or a messagebox beforehand?!?!?? GdkWindow *window = GTK_PIZZA(theWidget)->bin_window; wxASSERT(window); - gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(be->m_videosink), - GDK_WINDOW_XWINDOW( window ) - ); + GstElement* videosink; + g_object_get (G_OBJECT (be->m_player), "video-sink", &videosink, NULL); + + GstElement* overlay = gst_bin_get_by_interface (GST_BIN (videosink), + GST_TYPE_X_OVERLAY); + gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(overlay), + GDK_WINDOW_XWINDOW( window ) + ); return 0; } @@ -199,20 +219,25 @@ gint wxGStreamerMediaBackend::OnGTKRealize(GtkWidget* theWidget, #endif +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Cleanup +// +// Frees the gstreamer interfaces if there were any created +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::Cleanup() { if(m_player && GST_IS_OBJECT(m_player)) { - // wxASSERT(GST_IS_OBJECT(m_audiosink)); - // wxASSERT(GST_IS_OBJECT(m_videosink)); - gst_element_set_state (m_player, GST_STATE_NULL); gst_object_unref (GST_OBJECT (m_player)); - //gst_object_unref (GST_OBJECT (m_videosink)); - //gst_object_unref (GST_OBJECT (m_audiosink)); } } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::CreateControl +// +// Initializes GStreamer and creates the wx side of our media control +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, const wxPoint& pos, @@ -231,6 +256,11 @@ bool wxGStreamerMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, validator, name); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::TransCapsToVideoSize +// +// Gets the size of our video (in wxSize) from a GstPad +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::TransCapsToVideoSize(wxGStreamerMediaBackend* be, GstPad* pad) { const GstCaps* caps = GST_PAD_CAPS (pad); @@ -266,8 +296,12 @@ bool wxGStreamerMediaBackend::TransCapsToVideoSize(wxGStreamerMediaBackend* be, return false; } -//forces parent to recalc its layout if it has sizers to update -//to the new video size +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::PostRecalcSize +// +// Forces parent to recalc its layout if it has sizers to update +// to the new video size +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::PostRecalcSize() { m_ctrl->InvalidateBestSize(); @@ -276,6 +310,16 @@ void wxGStreamerMediaBackend::PostRecalcSize() m_ctrl->GetParent()->Update(); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::OnFinish +// +// Called by gstreamer when the media is done playing +// +// 1) Send a wxEVT_MEDIA_STOP to the control +// 2) If veteod, break out +// 3) really stop the media +// 4) Send a wxEVT_MEDIA_FINISHED to the control +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::OnFinish(GstElement *play, gpointer data) { wxGStreamerMediaBackend* m_parent = (wxGStreamerMediaBackend*) data; @@ -296,16 +340,34 @@ void wxGStreamerMediaBackend::OnFinish(GstElement *play, gpointer data) } } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::OnError +// +// Called by gstreamer when an error is encountered playing the media +// +// TODO: Make this better - maybe some more intelligent wxLog stuff +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::OnError(GstElement *play, GstElement *src, GError *err, gchar *debug, gpointer data) { - wxMessageBox(wxString::Format(wxT("Error in wxMediaCtrl!\nError Message:%s"), wxString(err->message, wxConvLocal).c_str())); + wxLogSysError( + wxString::Format( + wxT("Error in wxMediaCtrl!\nError Message:%s\nDebug:%s\n"), + (const wxChar*)wxConvUTF8.cMB2WX(err->message), + (const wxChar*)wxConvUTF8.cMB2WX(debug) + ) + ); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Load (File version) +// +// Just calls the URI version +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::Load(const wxString& fileName) { return Load( @@ -315,52 +377,101 @@ bool wxGStreamerMediaBackend::Load(const wxString& fileName) ); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::OnVideoCapsReady +// +// Called by gstreamer when the video caps for the media is ready +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::OnVideoCapsReady(GstPad* pad, GParamSpec* pspec, gpointer data) { wxGStreamerMediaBackend::TransCapsToVideoSize((wxGStreamerMediaBackend*) data, pad); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Load (URI version) +// +// 1) Stops/Cleanups the previous instance if there is any +// 2) Creates the gstreamer playbin +// 3) If there is no playbin bail out +// 4) Set up the error and end-of-stream callbacks for our player +// 5) Make our video sink and make sure it supports the x overlay interface +// 6) Make sure the passed URI is valid and tell playbin to load it +// 7) Use the xoverlay extension to tell gstreamer to play in our window +// 8) Get the video size - pause required to set the stream in action +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::Load(const wxURI& location) { + //1 Cleanup(); + //2 m_player = gst_element_factory_make ("playbin", "play"); - m_audiosink = gst_element_factory_make ("alsasink", "audiosink"); - m_videosink = gst_element_factory_make ("xvimagesink", "videosink"); - //no playbin -- outta here :) + //3 if (!m_player) return false; - //have alsa? - if (GST_IS_OBJECT(m_audiosink) == false) + //4 + g_signal_connect (m_player, "eos", G_CALLBACK (OnFinish), this); + g_signal_connect (m_player, "error", G_CALLBACK (OnError), this); + + //5 + GstElement* overlay = NULL; + GstElement* videosink; + +#if defined(__WXGTK__) && wxUSE_DYNLIB_CLASS + + //use gnome-specific gstreamer extensions + //if synthisis (?) file not found, it + //spits out a warning and uses ximagesink + wxDynamicLibrary gstgconf; + if(gstgconf.Load(gstgconf.CanonicalizeName(wxT("gstgconf-0.8")))) { - //nope, try OSS - m_audiosink = gst_element_factory_make ("osssink", "audiosink"); - wxASSERT_MSG(GST_IS_OBJECT(m_audiosink), wxT("WARNING: Alsa and OSS drivers for gstreamer not found - audio will be unavailable for wxMediaCtrl")); + typedef GstElement* (*LPgst_gconf_get_default_video_sink) (void); + LPgst_gconf_get_default_video_sink pGst_gconf_get_default_video_sink = + (LPgst_gconf_get_default_video_sink) + gstgconf.GetSymbol(wxT("gst_gconf_get_default_video_sink")); + + if (pGst_gconf_get_default_video_sink) + { + videosink = (*pGst_gconf_get_default_video_sink) (); + wxASSERT( GST_IS_BIN(videosink) ); + overlay = gst_bin_get_by_interface (GST_BIN (videosink), + GST_TYPE_X_OVERLAY); + } + + gstgconf.Detach(); } - - wxASSERT_MSG(GST_IS_OBJECT(m_videosink), wxT("WARNING: No X video driver for gstreamer not found - video will be unavailable for wxMediaCtrl")); + if ( ! GST_IS_X_OVERLAY(overlay) ) + { +#endif + videosink = gst_element_factory_make ("xvimagesink", "videosink"); + if ( !GST_IS_OBJECT(videosink) ) + videosink = gst_element_factory_make ("ximagesink", "videosink"); + + overlay = videosink; + + wxASSERT( GST_IS_X_OVERLAY(overlay) ); + if ( ! GST_IS_X_OVERLAY(overlay) ) + return false; +#if defined(__WXGTK__) && wxUSE_DYNLIB_CLASS + } +#endif g_object_set (G_OBJECT (m_player), - "video-sink", m_videosink, - "audio-sink", m_audiosink, - NULL); - - g_signal_connect (m_player, "eos", G_CALLBACK (OnError), this); - g_signal_connect (m_player, "error", G_CALLBACK (OnFinish), this); + "video-sink", videosink, +// "audio-sink", m_audiosink, + NULL); - wxASSERT( GST_IS_X_OVERLAY(m_videosink) ); - if ( ! GST_IS_X_OVERLAY(m_videosink) ) - return false; - + //6 wxString locstring = location.BuildUnescapedURI(); wxASSERT(gst_uri_protocol_is_valid("file")); wxASSERT(gst_uri_is_valid(locstring.mb_str())); g_object_set (G_OBJECT (m_player), "uri", (const char*)locstring.mb_str(), NULL); + //7 #ifdef __WXGTK__ if(!GTK_WIDGET_REALIZED(m_ctrl->m_wxwindow)) { @@ -378,7 +489,7 @@ bool wxGStreamerMediaBackend::Load(const wxURI& location) #endif - gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(m_videosink), + gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(overlay), #ifdef __WXGTK__ GDK_WINDOW_XWINDOW( window ) #else @@ -389,10 +500,12 @@ bool wxGStreamerMediaBackend::Load(const wxURI& location) #ifdef __WXGTK__ } //end else block #endif - - wxASSERT(gst_element_set_state (m_player, - GST_STATE_PAUSED) == GST_STATE_SUCCESS); + //8 + + wxASSERT(gst_element_set_state (m_player, + GST_STATE_PAUSED) == GST_STATE_SUCCESS); + const GList *list = NULL; g_object_get (G_OBJECT (m_player), "stream-info", &list, NULL); @@ -445,6 +558,11 @@ bool wxGStreamerMediaBackend::Load(const wxURI& location) return true; } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Play +// +// Sets the stream to a playing state +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::Play() { if (gst_element_set_state (m_player, GST_STATE_PLAYING) @@ -453,6 +571,11 @@ bool wxGStreamerMediaBackend::Play() return true; } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Pause +// +// Marks where we paused and pauses the stream +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::Pause() { m_nPausedPos = GetPosition(); @@ -462,6 +585,11 @@ bool wxGStreamerMediaBackend::Pause() return true; } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Stop +// +// Pauses the stream and sets the position to 0 +//--------------------------------------------------------------------------- bool wxGStreamerMediaBackend::Stop() { if (gst_element_set_state (m_player, @@ -470,6 +598,11 @@ bool wxGStreamerMediaBackend::Stop() return wxGStreamerMediaBackend::SetPosition(0); } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::GetState +// +// Gets the state of the stream +//--------------------------------------------------------------------------- wxMediaState wxGStreamerMediaBackend::GetState() { switch(GST_STATE(m_player)) @@ -486,21 +619,19 @@ wxMediaState wxGStreamerMediaBackend::GetState() } } -bool wxGStreamerMediaBackend::SetPosition(wxLongLong where) -{ - if( gst_element_seek (m_player, (GstSeekType) (GST_SEEK_METHOD_SET | - GST_FORMAT_TIME | GST_SEEK_FLAG_FLUSH), - where.GetValue() * GST_MSECOND ) ) - { - if (GetState() != wxMEDIASTATE_PLAYING) - m_nPausedPos = where; - - return true; - } - - return false; -} - +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::GetPosition +// +// If paused, returns our marked position - otherwise it queries the +// GStreamer playbin for the position and returns that +// +//TODO: +//TODO: In lue of the last big TODO, when you pause and seek gstreamer +//TODO: doesn't update the position sometimes, so we need to keep track of whether +//TODO: we have paused or not and keep track of the time after the pause +//TODO: and whenever the user seeks while paused +//TODO: +//--------------------------------------------------------------------------- wxLongLong wxGStreamerMediaBackend::GetPosition() { if(GetState() != wxMEDIASTATE_PLAYING) @@ -516,6 +647,35 @@ wxLongLong wxGStreamerMediaBackend::GetPosition() } } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::SetPosition +// +// Sets the position of the stream +// Note that GST_MSECOND is 1000000 (GStreamer uses nanoseconds - so +// there is 1000000 nanoseconds in a millisecond) +// +// If paused marks where we seeked to +//--------------------------------------------------------------------------- +bool wxGStreamerMediaBackend::SetPosition(wxLongLong where) +{ + if( gst_element_seek (m_player, (GstSeekType) (GST_SEEK_METHOD_SET | + GST_FORMAT_TIME | GST_SEEK_FLAG_FLUSH), + where.GetValue() * GST_MSECOND ) ) + { + if (GetState() != wxMEDIASTATE_PLAYING) + m_nPausedPos = where; + + return true; + } + + return false; +} + +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::GetDuration +// +// Obtains the total time of our stream +//--------------------------------------------------------------------------- wxLongLong wxGStreamerMediaBackend::GetDuration() { gint64 length; @@ -526,31 +686,46 @@ wxLongLong wxGStreamerMediaBackend::GetDuration() return length / GST_MSECOND ; } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::Move +// +// Called when the window is moved - GStreamer takes care of this +// for us so nothing is needed +//--------------------------------------------------------------------------- void wxGStreamerMediaBackend::Move(int x, int y, int w, int h) { } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::GetVideoSize +// +// Returns our cached video size from Load/OnVideoCapsReady +//--------------------------------------------------------------------------- wxSize wxGStreamerMediaBackend::GetVideoSize() const { return m_videoSize; } +//--------------------------------------------------------------------------- +// wxGStreamerMediaBackend::GetPlaybackRate +// wxGStreamerMediaBackend::SetPlaybackRate // -//PlaybackRate not currently supported via playbin directly - -// Ronald S. Bultje noted on gstreamer-devel: -// -// Like "play at twice normal speed"? Or "play at 25 fps and 44,1 kHz"? As -// for the first, yes, we have elements for that, btu they"re not part of -// playbin. You can create a bin (with a ghost pad) containing the actual -// video/audiosink and the speed-changing element for this, and set that -// element as video-sink or audio-sink property in playbin. The -// audio-element is called "speed", the video-element is called "videodrop" -// (although that appears to be deprecated in favour of "videorate", which -// again cannot do this, so this may not work at all in the end). For -// forcing frame/samplerates, see audioscale and videorate. Audioscale is -// part of playbin. +// Obtains/Sets the playback rate of the stream // - +//TODO: PlaybackRate not currently supported via playbin directly - +//TODO: Ronald S. Bultje noted on gstreamer-devel: +//TODO: +//TODO: Like "play at twice normal speed"? Or "play at 25 fps and 44,1 kHz"? As +//TODO: for the first, yes, we have elements for that, btu they"re not part of +//TODO: playbin. You can create a bin (with a ghost pad) containing the actual +//TODO: video/audiosink and the speed-changing element for this, and set that +//TODO: element as video-sink or audio-sink property in playbin. The +//TODO: audio-element is called "speed", the video-element is called "videodrop" +//TODO: (although that appears to be deprecated in favour of "videorate", which +//TODO: again cannot do this, so this may not work at all in the end). For +//TODO: forcing frame/samplerates, see audioscale and videorate. Audioscale is +//TODO: part of playbin. +//--------------------------------------------------------------------------- double wxGStreamerMediaBackend::GetPlaybackRate() { //not currently supported via playbin