64 bit compilation fix (pointer can't be cast to int); code simplification (don't...

[wxWidgets.git] / src / unix / mediactrl.cpp

diff --git a/src/unix/mediactrl.cpp b/src/unix/mediactrl.cpp
index 3dfbadf6bc23bdc6d5904809a275d59423f745d9..714775be11729670aa9505a6067b16add64bb34c 100644 (file)
--- a/src/unix/mediactrl.cpp
+++ b/src/unix/mediactrl.cpp
@@ -46,8 +46,13 @@
 //
 //  wxGStreamerMediaBackend
 //
 //
 //  wxGStreamerMediaBackend
 //

-// This won't compile/work without a little work yet...
-// 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
 
 //---------------------------------------------------------------------------
 #if wxUSE_GSTREAMER
 


@@ -63,9 +68,15 @@
 
 #ifdef __WXGTK__
     //for <gdk/gdkx.h>/related for GDK_WINDOW_XWINDOW
 
 #ifdef __WXGTK__
     //for <gdk/gdkx.h>/related for GDK_WINDOW_XWINDOW

-#   include "wx/gtk/win_gtk.h"
+#    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
 
 #endif
 

+

 class WXDLLIMPEXP_MEDIA wxGStreamerMediaBackend : public wxMediaBackend
 {
 public:
 class WXDLLIMPEXP_MEDIA wxGStreamerMediaBackend : public wxMediaBackend
 {
 public:


@@ -106,10 +117,21 @@ public:
     static void OnError (GstElement *play,  GstElement *src,
                          GError     *err,   gchar      *debug,
                          gpointer    data);
     static void OnError (GstElement *play,  GstElement *src,
                          GError     *err,   gchar      *debug,
                          gpointer    data);

+    static void OnVideoCapsReady(GstPad* pad,  GParamSpec* pspec, gpointer data);
+    
+    static bool TransCapsToVideoSize(wxGStreamerMediaBackend* be, GstPad* caps);
+    void PostRecalcSize();
+    
+#ifdef __WXGTK__
+    static gint OnGTKRealize(GtkWidget* theWidget, wxGStreamerMediaBackend* be);
+#endif

 
     GstElement* m_player;       //GStreamer media element
 
     GstElement* m_player;       //GStreamer media element

-    GstElement* m_audiosink;
-    GstElement* m_videosink;
+    
+    wxSize      m_videoSize;
+    wxControl*  m_ctrl;
+    
+    wxLongLong m_nPausedPos;

 
     DECLARE_DYNAMIC_CLASS(wxGStreamerMediaBackend);
 };
 
     DECLARE_DYNAMIC_CLASS(wxGStreamerMediaBackend);
 };


@@ -123,18 +145,99 @@ public:
 
 IMPLEMENT_DYNAMIC_CLASS(wxGStreamerMediaBackend, wxMediaBackend);
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxGStreamerMediaBackend, wxMediaBackend);
 

-wxGStreamerMediaBackend::wxGStreamerMediaBackend()
+//---------------------------------------------------------------------------
+// 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()
 {
 wxGStreamerMediaBackend::~wxGStreamerMediaBackend()
 {

-    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));
+    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 wxUSE_THREADS
+#   define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
+#else
+#   define DEBUG_MAIN_THREAD
+#endif
+#else
+#define DEBUG_MAIN_THREAD
+#endif // Debug
+
+extern void wxapp_install_idle_handler();
+extern bool g_isIdle;
+extern bool g_mainThreadLocked;
+
+gint wxGStreamerMediaBackend::OnGTKRealize(GtkWidget* theWidget, 
+                                           wxGStreamerMediaBackend* be)
+{
+    DEBUG_MAIN_THREAD
+    
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    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);
+    
+    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))
+    {
+        gst_element_set_state (m_player, GST_STATE_NULL);
+        gst_object_unref (GST_OBJECT (m_player));
+    }

 }
 
 }
 

+//---------------------------------------------------------------------------
+// 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,
 bool wxGStreamerMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
                                 wxWindowID id,
                                 const wxPoint& pos,


@@ -145,47 +248,83 @@ bool wxGStreamerMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
 {
     //init gstreamer
     gst_init(NULL, NULL);
 {
     //init gstreamer
     gst_init(NULL, NULL);

+    
+    m_ctrl = ctrl;

 
 

-    //
-    // Create window
-    // By default wxWindow(s) is created with a border -
-    // so we need to get rid of those    return Load(
-    //
-    // Since we don't have a child window like most other
-    // backends, we don't need wxCLIP_CHILDREN
-    //
-    if ( !
-    ctrl->wxControl::Create(parent, id, pos, size,
+    return m_ctrl->wxControl::Create(parent, id, pos, size,

                             style,  //remove borders???
                             style,  //remove borders???

-                            validator, name)
-        )
-        return false;
+                            validator, name);
+}

 
 

-    m_player    = gst_element_factory_make ("playbin", "play");
-    m_audiosink = gst_element_factory_make ("alsasink", "audiosink");
-    m_videosink = gst_element_factory_make ("xvimagesink", "videosink");
+//---------------------------------------------------------------------------
+// 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);
+    if(caps)
+    {

 
 

-    g_object_set (G_OBJECT (m_player),
-                    "video-sink", m_videosink,
-                    "audio-sink", m_audiosink,
-                    NULL);
+        const GstStructure *s;
+        s = gst_caps_get_structure (caps, 0);
+        wxASSERT(s);

 
 

-    g_signal_connect (m_player, "eos", G_CALLBACK (OnError), this);
-    g_signal_connect (m_player, "error", G_CALLBACK (OnFinish), this);
+        gst_structure_get_int (s, "width", &be->m_videoSize.x);
+        gst_structure_get_int (s, "height", &be->m_videoSize.y);

 
 

-    if ( ! GST_IS_X_OVERLAY(m_videosink) )
-        return false;
+        wxLogDebug(wxT("Native video size: [%i,%i]"), be->m_videoSize.x, be->m_videoSize.y);

 
 

-    gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(m_videosink),
-#ifdef __WXGTK__
-                        GDK_WINDOW_XWINDOW(ctrl->GetHandle())
-#else
-                        ctrl->GetHandle()
-#endif
-                                  );
-    return true;
+        const GValue *par;
+        par = gst_structure_get_value (s, "pixel-aspect-ratio");
+
+        if (par)
+        {
+            int num = gst_value_get_fraction_numerator (par),
+                den = gst_value_get_fraction_denominator (par);
+
+            //TODO: maybe better fraction normalization...
+            if (num > den)
+                be->m_videoSize.x = (int) ((float) num * be->m_videoSize.x / den);
+            else
+                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;

 }
 
 }
 

+//---------------------------------------------------------------------------
+// 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;
 void wxGStreamerMediaBackend::OnFinish(GstElement *play, gpointer    data)
 {
     wxGStreamerMediaBackend* m_parent = (wxGStreamerMediaBackend*) data;


@@ -206,41 +345,248 @@ 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)
 {
 void wxGStreamerMediaBackend::OnError(GstElement *play,
     GstElement *src,
     GError     *err,
     gchar      *debug,
     gpointer    data)
 {

-    wxLogSysError(wxString::Format(wxT("Error in GStreamer Playback!\nError Message:%s"), wxString(err->message).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)
 {
 bool wxGStreamerMediaBackend::Load(const wxString& fileName)
 {

-    return Load(
-                wxURI(
-                    wxString( wxT("file://") ) + fileName
-                     )
+    return Load( 
+                    wxURI( 
+                            wxString( wxT("file://") ) + 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)
 {
 bool wxGStreamerMediaBackend::Load(const wxURI& location)
 {

+    //1

     Cleanup();
     Cleanup();

-    wxString locstring = location.BuildURI();
+    
+    //2
+    m_player    = gst_element_factory_make ("playbin", "play");

 
 

+    //3
+    if (!m_player)
+        return 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"))))
+    {
+        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 ( GST_STATE(m_player) > GST_STATE_READY )
-        gst_element_set_state(m_player, GST_STATE_READY);
+        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();
+    }
+        
+        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), "uri", locstring.c_str(), NULL);
+    g_object_set (G_OBJECT (m_player),
+                    "video-sink", videosink,
+//                    "audio-sink", m_audiosink,
+                    NULL);    
+
+    //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))
+    {
+        //Not realized yet - set to connect at realization time
+        gtk_signal_connect( GTK_OBJECT(m_ctrl->m_wxwindow), 
+                            "realize",
+                            GTK_SIGNAL_FUNC(wxGStreamerMediaBackend::OnGTKRealize),
+                            (gpointer) this );
+    }        
+    else
+    {
+        wxYield(); //see realize callback...
+        GdkWindow *window = GTK_PIZZA(m_ctrl->m_wxwindow)->bin_window;
+        wxASSERT(window);
+#endif
+
+ 
+    gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(overlay),
+#ifdef __WXGTK__
+                        GDK_WINDOW_XWINDOW( window )
+#else
+                        ctrl->GetHandle()
+#endif
+                                  );

 
 

-    gst_x_overlay_expose(GST_X_OVERLAY(m_videosink));
+#ifdef __WXGTK__                                  
+    } //end else block
+#endif 
+    
+    //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;
+       }

 
 

-    return GST_STATE(m_player) == GST_STATE_READY;
+    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;
+        gint type;
+        GParamSpec *pspec;
+        GEnumValue *val;
+        GstPad *pad = NULL;
+
+        g_object_get (info, "type", &type, NULL);
+        pspec = g_object_class_find_property (
+                        G_OBJECT_GET_CLASS (info), "type");
+        val = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, type);
+
+        if (strstr (val->value_name, "VIDEO"))
+        {
+            //Newer gstreamer 0.8+ is SUPPOSED to have "object"...
+            //but a lot of old plugins still use "pad" :)
+            pspec = g_object_class_find_property (
+                        G_OBJECT_GET_CLASS (info), "object");
+                        
+            if (!pspec)
+                g_object_get (info, "pad", &pad, NULL);
+            else
+                g_object_get (info, "object", &pad, NULL);
+            
+            pad = (GstPad *) GST_PAD_REALIZE (pad);
+            wxASSERT(pad);
+
+            if(!wxGStreamerMediaBackend::TransCapsToVideoSize(this, pad));
+            {
+                //wait for those caps to get ready
+                g_signal_connect(
+                pad, 
+                "notify::caps", 
+                G_CALLBACK(wxGStreamerMediaBackend::OnVideoCapsReady),
+                this);
+            }
+
+            bVideoFound = true;
+            break;
+        }//end if video
+        else
+        {
+            m_videoSize = wxSize(0,0);
+            PostRecalcSize();
+        }
+    }//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)
 bool wxGStreamerMediaBackend::Play()
 {
     if (gst_element_set_state (m_player, GST_STATE_PLAYING)


@@ -249,22 +595,38 @@ bool wxGStreamerMediaBackend::Play()
     return true;
 }
 
     return true;
 }
 

+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::Pause
+//
+// Marks where we paused and pauses the stream
+//---------------------------------------------------------------------------

 bool wxGStreamerMediaBackend::Pause()
 {
 bool wxGStreamerMediaBackend::Pause()
 {

+    m_nPausedPos = GetPosition();

     if (gst_element_set_state (m_player, GST_STATE_PAUSED)
             != GST_STATE_SUCCESS)
         return false;
     return true;
 }
 
     if (gst_element_set_state (m_player, GST_STATE_PAUSED)
             != GST_STATE_SUCCESS)
         return false;
     return true;
 }
 

+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::Stop
+//
+// Pauses the stream and sets the position to 0
+//---------------------------------------------------------------------------

 bool wxGStreamerMediaBackend::Stop()
 {
     if (gst_element_set_state (m_player,
 bool wxGStreamerMediaBackend::Stop()
 {
     if (gst_element_set_state (m_player,

-                    GST_STATE_READY)    != GST_STATE_SUCCESS)
+                    GST_STATE_PAUSED)    != GST_STATE_SUCCESS)

         return false;
         return false;

-    return true;
+    return wxGStreamerMediaBackend::SetPosition(0);

 }
 
 }
 

+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::GetState
+//
+// Gets the state of the stream
+//---------------------------------------------------------------------------

 wxMediaState wxGStreamerMediaBackend::GetState()
 {
     switch(GST_STATE(m_player))
 wxMediaState wxGStreamerMediaBackend::GetState()
 {
     switch(GST_STATE(m_player))


@@ -272,29 +634,72 @@ wxMediaState wxGStreamerMediaBackend::GetState()
         case GST_STATE_PLAYING:
             return wxMEDIASTATE_PLAYING;
         case GST_STATE_PAUSED:
         case GST_STATE_PLAYING:
             return wxMEDIASTATE_PLAYING;
         case GST_STATE_PAUSED:

-            return wxMEDIASTATE_PAUSED;
+            if (m_nPausedPos == 0)
+                return wxMEDIASTATE_STOPPED;
+            else
+                return wxMEDIASTATE_PAUSED;

         default://case GST_STATE_READY:
             return wxMEDIASTATE_STOPPED;
     }
 }
 
         default://case GST_STATE_READY:
             return wxMEDIASTATE_STOPPED;
     }
 }
 

-bool wxGStreamerMediaBackend::SetPosition(wxLongLong where)
+//---------------------------------------------------------------------------
+// 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()

 {
 {

-    return gst_element_seek (play, (GstSeekType) (GST_SEEK_METHOD_SET |
-            GST_FORMAT_TIME | GST_SEEK_FLAG_FLUSH),
-            where * GST_MSECOND );
+    if(GetState() != wxMEDIASTATE_PLAYING)
+        return m_nPausedPos;
+    else
+    {
+        gint64 pos;
+        GstFormat fmtTime = GST_FORMAT_TIME;
+    
+        if (!gst_element_query (m_player, GST_QUERY_POSITION, &fmtTime, &pos))
+            return 0;
+        return pos / GST_MSECOND ;
+    }

 }
 
 }
 

-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)

 {
 {

-    gint64 pos;
-    GstFormat fmtTime = GST_FORMAT_TIME;
-
-    if (!gst_element_query (play, GST_QUERY_POSITION, &fmtTime, &pos))
-        return 0;
-    return pos / GST_MSECOND ;
+    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;
 wxLongLong wxGStreamerMediaBackend::GetDuration()
 {
     gint64 length;


@@ -305,80 +710,56 @@ wxLongLong wxGStreamerMediaBackend::GetDuration()
     return length / GST_MSECOND ;
 }
 
     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)
 {
 }
 
 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
 wxSize wxGStreamerMediaBackend::GetVideoSize() const

-{
-    //TODO: check state
-    //TODO: maybe cache size
-    wxSize retSize = wxSize(0,0);
-
-    const GList *list = NULL;
-    g_object_get (G_OBJECT (m_player), "stream-info", &list, NULL);
-
-    for ( ; list != NULL; list = list->next)
-    {
-        GObject *info = (GObject *) list->data;
-        gint type;
-        GParamSpec *pspec;
-        GEnumValue *val;
-        GstPad *pad = NULL;
-
-        g_object_get (info, "type", &type, NULL);
-        pspec = g_object_class_find_property (
-                        G_OBJECT_GET_CLASS (info), "type");
-        val = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, type);
-
-        if (strstr (val->value_name, "VIDEO"))
-        {
-            g_object_get (info, "object", &pad, NULL);
-            pad = (GstPad *) GST_PAD_REALIZE (pad);
-            wxAssert(pad);
-
-            GstCaps* caps = GST_PAD_CAPS (pad);
-            wxAssert(caps);
-
-            const GstStructure *s;
-            s = gst_caps_get_structure (caps, 0);
-            wxAssert(s);
-
-            gst_structure_get_int (s, "width", &retSize.x);
-            gst_structure_get_int (s, "height", &retSize.y);
-
-            const GValue *par;
-            par = gst_structure_get_value (s, "pixel-aspect-ratio"));
-
-            if (par)
-            {
-                int num = gst_value_get_fraction_numerator (par),
-                    den = gst_value_get_fraction_denominator (par);
-
-                //TODO: maybe better fraction normalization...
-                if (num > den)
-                    retSize.x = (int) ((float) num * retSize.x / den);
-                else
-                    retSize.y = (int) ((float) den * retSize.y / num);
-            }
-        }
-    }
+{    
+    return m_videoSize;

 }
 
 }
 

+//---------------------------------------------------------------------------
+// wxGStreamerMediaBackend::GetPlaybackRate
+// wxGStreamerMediaBackend::SetPlaybackRate
+//
+// 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()
 {
 double wxGStreamerMediaBackend::GetPlaybackRate()
 {

-    //guess...
-    GstClock* theClock = gst_element_get_clock(m_player);
-    wxAssert(theClock);
-    return gst_clock_get_speed(theClock);
+    //not currently supported via playbin
+    return 1.0;

 }
 
 bool wxGStreamerMediaBackend::SetPlaybackRate(double dRate)
 {
 }
 
 bool wxGStreamerMediaBackend::SetPlaybackRate(double dRate)
 {

-    //guess...
-    GstClock* theClock = gst_element_get_clock(m_player);
-    wxAssert(theClock);
-    return gst_clock_change_speed(theClock, GetPlaybackRate(), dRate)==dRate;
+    //not currently supported via playbin
+    return false;

 }
 
 #endif //wxUSE_GSTREAMER
 }
 
 #endif //wxUSE_GSTREAMER