// Pre-compiled header stuff
//---------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "mediactrl.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
//
// 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
#include <string.h> //strstr
#include "wx/log.h"
-#include "wx/msgdlg.h"
#ifdef __WXGTK__
//for <gdk/gdkx.h>/related for GDK_WINDOW_XWINDOW
# include "wx/gtk/win_gtk.h"
# include <gtk/gtksignal.h>
+# if wxUSE_DYNLIB_CLASS
+# include "wx/dynlib.h"
+# endif
+//# include <gst/gconf/gconf.h> //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
{
#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);
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__
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;
}
#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,
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);
gst_structure_get_int (s, "width", &be->m_videoSize.x);
gst_structure_get_int (s, "height", &be->m_videoSize.y);
+ wxLogDebug(wxT("Native video size: [%i,%i]"), be->m_videoSize.x, be->m_videoSize.y);
+
const GValue *par;
par = gst_structure_get_value (s, "pixel-aspect-ratio");
be->m_videoSize.y = (int) ((float) den * be->m_videoSize.y / num);
}
+ wxLogDebug(wxT("Adjusted video size: [%i,%i]"), be->m_videoSize.x, be->m_videoSize.y);
+
be->PostRecalcSize();
return true;
}//end if caps
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();
m_ctrl->GetParent()->Layout();
m_ctrl->GetParent()->Refresh();
m_ctrl->GetParent()->Update();
+ m_ctrl->SetSize(m_ctrl->GetSize());
}
+//---------------------------------------------------------------------------
+// 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;
}
}
+//---------------------------------------------------------------------------
+// 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(
);
}
+//---------------------------------------------------------------------------
+// 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
+ wxLogDebug(wxT("Could not load Gnome preferences, reverting to xvimagesink for video for gstreamer"));
+ 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);
+ "video-sink", 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);
-
- 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))
{
#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
#ifdef __WXGTK__
} //end else block
#endif
-
- wxASSERT(gst_element_set_state (m_player,
- GST_STATE_PAUSED) == GST_STATE_SUCCESS);
+ //8
+ int nResult = gst_element_set_state (m_player, GST_STATE_PAUSED);
+ if(nResult != GST_STATE_SUCCESS)
+ {
+ wxLogDebug(wxT("Could not set initial state to paused!"));
+ return false;
+ }
+
const GList *list = NULL;
g_object_get (G_OBJECT (m_player), "stream-info", &list, NULL);
+ bool bVideoFound = false;
+
for ( ; list != NULL; list = list->next)
{
GObject *info = (GObject *) list->data;
G_CALLBACK(wxGStreamerMediaBackend::OnVideoCapsReady),
this);
}
+
+ bVideoFound = true;
+ break;
}//end if video
else
{
}
}//end searching through info list
+ if(!bVideoFound)
+ {
+ wxLogDebug(wxT("No video found for gstreamer stream"));
+ }
m_nPausedPos = 0;
+
+ //send loaded event
+ wxMediaEvent theEvent(wxEVT_MEDIA_LOADED,
+ m_ctrl->GetId());
+ m_ctrl->AddPendingEvent(theEvent);
+
return true;
}
+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::Play
+//
+// Sets the stream to a playing state
+//---------------------------------------------------------------------------
bool wxGStreamerMediaBackend::Play()
{
if (gst_element_set_state (m_player, GST_STATE_PLAYING)
return true;
}
+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::Pause
+//
+// Marks where we paused and pauses the stream
+//---------------------------------------------------------------------------
bool wxGStreamerMediaBackend::Pause()
{
m_nPausedPos = GetPosition();
return true;
}
+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::Stop
+//
+// Pauses the stream and sets the position to 0
+//---------------------------------------------------------------------------
bool wxGStreamerMediaBackend::Stop()
{
if (gst_element_set_state (m_player,
return wxGStreamerMediaBackend::SetPosition(0);
}
+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::GetState
+//
+// Gets the state of the stream
+//---------------------------------------------------------------------------
wxMediaState wxGStreamerMediaBackend::GetState()
{
switch(GST_STATE(m_player))
}
}
-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)
}
}
+//---------------------------------------------------------------------------
+// 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;
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
projects / wxWidgets.git / blobdiff