llmediaplugins first step

11 files changed, 3048 insertions, 114 deletions

diff --git a/linden/indra/media_plugins/gstreamer010/CMakeLists.txt b/linden/indra/media_plugins/gstreamer010/CMakeLists.txt
new file mode 100644
index 0000000..a3a32d8
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/CMakeLists.txt
@@ -0,0 +1,71 @@
+# -*- cmake -*-
+
+project(media_plugin_gstreamer010)
+
+include(00-Common)
+include(LLCommon)
+include(LLImage)
+include(LLPlugin)
+include(LLMath)
+include(LLRender)
+include(LLWindow)
+include(Linking)
+include(PluginAPI)
+include(MediaPluginBase)
+include(FindOpenGL)
+
+include(GStreamer010Plugin)
+
+include_directories(
+    ${LLPLUGIN_INCLUDE_DIRS}
+    ${MEDIA_PLUGIN_BASE_INCLUDE_DIRS}
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LLMATH_INCLUDE_DIRS}
+    ${LLIMAGE_INCLUDE_DIRS}
+    ${LLRENDER_INCLUDE_DIRS}
+    ${LLWINDOW_INCLUDE_DIRS}
+    ${GSTREAMER010_INCLUDE_DIRS}
+    ${GSTREAMER010_PLUGINS_BASE_INCLUDE_DIRS}
+)
+
+### media_plugin_gstreamer010
+
+set(media_plugin_gstreamer010_SOURCE_FILES
+    media_plugin_gstreamer010.cpp
+    llmediaimplgstreamer_syms.cpp
+    llmediaimplgstreamervidplug.cpp
+    )
+
+set(media_plugin_gstreamer010_HEADER_FILES
+    llmediaimplgstreamervidplug.h
+    llmediaimplgstreamer_syms.h
+    llmediaimplgstreamertriviallogging.h
+    )
+
+#awfixme if (${CXX_VERSION_NUMBER} MATCHES "4[23].")
+    # Work around a bad interaction between broken gstreamer headers and
+    # g++ 4.3's increased strictness.
+    set_source_files_properties(llmediaimplgstreamervidplug.cpp PROPERTIES
+                                COMPILE_FLAGS -Wno-write-strings)
+#awfixme endif (${CXX_VERSION_NUMBER} MATCHES "4[23].")
+
+add_library(media_plugin_gstreamer010
+    SHARED
+    ${media_plugin_gstreamer010_SOURCE_FILES}
+)
+
+target_link_libraries(media_plugin_gstreamer010
+  ${LLPLUGIN_LIBRARIES}
+  ${MEDIA_PLUGIN_BASE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+  ${PLUGIN_API_WINDOWS_LIBRARIES}
+  ${GSTREAMER010_LIBRARIES}
+)
+
+add_dependencies(media_plugin_gstreamer010
+  ${LLPLUGIN_LIBRARIES}
+  ${MEDIA_PLUGIN_BASE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+)
+
+
diff --git a/linden/indra/llmedia/llmediaimplregister.h b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer.h
index 5191274..ef41736 100644
--- a/linden/indra/llmedia/llmediaimplregister.h
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer.h
@@ -1,6 +1,7 @@
-/**
- * @file llmediaimplregister.h
- * @brief Allow impls to register themselves with the impl factory
+/** 
+ * @file llmediaimplgstreamer.h
+ * @author Tofu Linden
+ * @brief implementation that supports media playback via GStreamer.
  *
  * $LicenseInfo:firstyear=2007&license=viewergpl$
  * 
@@ -30,31 +31,27 @@
  * $/LicenseInfo$
  */
 
-#ifndef LLIMEDIAIMPLREGISTER_H
-#define LLIMEDIAIMPLREGISTER_H
+// header guard
+#ifndef llmediaimplgstreamer_h
+#define llmediaimplgstreamer_h
 
-#include <string>
+#if LL_GSTREAMER010_ENABLED
 
-#include "llmediaimplfactory.h"
+extern "C" {
+#include <stdio.h>
+#include <gst/gst.h>
 
-///////////////////////////////////////////////////////////////////////////////
-//
-class LLMediaImplRegister
-{
-        public:
-                LLMediaImplRegister( std::string impl_name, LLMediaImplMaker* impl_maker ) :
-                  mImplName( impl_name )
-                {
-                        LLMediaImplFactory::getInstance()->registerImpl( impl_name, impl_maker );
-                };
+#include "apr_pools.h"
+#include "apr_dso.h"
+}
 
-                std::string getImplName()
-                {
-                        return mImplName;
-                };
 
-        private:
-                std::string mImplName;
-};
+extern "C" {
+gboolean llmediaimplgstreamer_bus_callback (GstBus     *bus,
+                                            GstMessage *message,
+                                            gpointer    data);
+}
 
-#endif  // LLIMEDIAIMPLREGISTER_H
+#endif // LL_GSTREAMER010_ENABLED
+
+#endif // llmediaimplgstreamer_h
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.cpp b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.cpp
new file mode 100644
index 0000000..cc52232
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.cpp
@@ -0,0 +1,171 @@
+/** 
+ * @file llmediaimplgstreamer_syms.cpp
+ * @brief dynamic GStreamer symbol-grabbing code
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#if LL_GSTREAMER010_ENABLED
+
+#include <string>
+
+extern "C" {
+#include <gst/gst.h>
+
+#include "apr_pools.h"
+#include "apr_dso.h"
+}
+
+#include "llmediaimplgstreamertriviallogging.h"
+
+#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) RTN (*ll##GSTSYM)(__VA_ARGS__) = NULL
+#include "llmediaimplgstreamer_syms_raw.inc"
+#include "llmediaimplgstreamer_syms_rawv.inc"
+#undef LL_GST_SYM
+
+// a couple of stubs for disgusting reasons
+GstDebugCategory*
+ll_gst_debug_category_new(gchar *name, guint color, gchar *description)
+{
+        static GstDebugCategory dummy;
+        return &dummy;
+}
+void ll_gst_debug_register_funcptr(GstDebugFuncPtr func, gchar* ptrname)
+{
+}
+
+static bool sSymsGrabbed = false;
+static apr_pool_t *sSymGSTDSOMemoryPool = NULL;
+static apr_dso_handle_t *sSymGSTDSOHandleG = NULL;
+static apr_dso_handle_t *sSymGSTDSOHandleV = NULL;
+
+
+bool grab_gst_syms(std::string gst_dso_name,
+                   std::string gst_dso_name_vid)
+{
+        if (sSymsGrabbed)
+        {
+                // already have grabbed good syms
+                return TRUE;
+        }
+
+        bool sym_error = false;
+        bool rtn = false;
+        apr_status_t rv;
+        apr_dso_handle_t *sSymGSTDSOHandle = NULL;
+
+#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##GSTSYM, sSymGSTDSOHandle, #GSTSYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #GSTSYM); if (REQ) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #GSTSYM, (void*)ll##GSTSYM);}while(0)
+
+        //attempt to load the shared libraries
+        apr_pool_create(&sSymGSTDSOMemoryPool, NULL);
+  
+        if ( APR_SUCCESS == (rv = apr_dso_load(&sSymGSTDSOHandle,
+                                               gst_dso_name.c_str(),
+                                               sSymGSTDSOMemoryPool) ))
+        {
+                INFOMSG("Found DSO: %s", gst_dso_name.c_str());
+#include "llmediaimplgstreamer_syms_raw.inc"
+      
+                if ( sSymGSTDSOHandle )
+                {
+                        sSymGSTDSOHandleG = sSymGSTDSOHandle;
+                        sSymGSTDSOHandle = NULL;
+                }
+      
+                if ( APR_SUCCESS ==
+                     (rv = apr_dso_load(&sSymGSTDSOHandle,
+                                        gst_dso_name_vid.c_str(),
+                                        sSymGSTDSOMemoryPool) ))
+                {
+                        INFOMSG("Found DSO: %s", gst_dso_name_vid.c_str());
+#include "llmediaimplgstreamer_syms_rawv.inc"
+                        rtn = !sym_error;
+                }
+                else
+                {
+                        INFOMSG("Couldn't load DSO: %s", gst_dso_name_vid.c_str());
+                        rtn = false; // failure
+                }
+        }
+        else
+        {
+                INFOMSG("Couldn't load DSO: %s", gst_dso_name.c_str());
+                rtn = false; // failure
+        }
+
+        if (sym_error)
+        {
+                WARNMSG("Failed to find necessary symbols in GStreamer libraries.");
+        }
+        
+        if ( sSymGSTDSOHandle )
+        {
+                sSymGSTDSOHandleV = sSymGSTDSOHandle;
+                sSymGSTDSOHandle = NULL;
+        }
+#undef LL_GST_SYM
+
+        sSymsGrabbed = !!rtn;
+        return rtn;
+}
+
+
+void ungrab_gst_syms()
+{ 
+        // should be safe to call regardless of whether we've
+        // actually grabbed syms.
+
+        if ( sSymGSTDSOHandleG )
+        {
+                apr_dso_unload(sSymGSTDSOHandleG);
+                sSymGSTDSOHandleG = NULL;
+        }
+        
+        if ( sSymGSTDSOHandleV )
+        {
+                apr_dso_unload(sSymGSTDSOHandleV);
+                sSymGSTDSOHandleV = NULL;
+        }
+        
+        if ( sSymGSTDSOMemoryPool )
+        {
+                apr_pool_destroy(sSymGSTDSOMemoryPool);
+                sSymGSTDSOMemoryPool = NULL;
+        }
+        
+        // NULL-out all of the symbols we'd grabbed
+#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) do{ll##GSTSYM = NULL;}while(0)
+#include "llmediaimplgstreamer_syms_raw.inc"
+#include "llmediaimplgstreamer_syms_rawv.inc"
+#undef LL_GST_SYM
+
+        sSymsGrabbed = false;
+}
+
+
+#endif // LL_GSTREAMER010_ENABLED
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.h b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.h
new file mode 100644
index 0000000..ee7473d
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.h
@@ -0,0 +1,78 @@
+/** 
+ * @file llmediaimplgstreamer_syms.h
+ * @brief dynamic GStreamer symbol-grabbing code
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#if LL_GSTREAMER010_ENABLED
+
+extern "C" {
+#include <gst/gst.h>
+}
+
+bool grab_gst_syms(std::string gst_dso_name,
+                   std::string gst_dso_name_vid);
+void ungrab_gst_syms();
+
+#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) extern RTN (*ll##GSTSYM)(__VA_ARGS__)
+#include "llmediaimplgstreamer_syms_raw.inc"
+#include "llmediaimplgstreamer_syms_rawv.inc"
+#undef LL_GST_SYM
+
+// regrettable hacks to give us better runtime compatibility with older systems
+#define llg_return_if_fail(COND) do{if (!(COND)) return;}while(0)
+#define llg_return_val_if_fail(COND,V) do{if (!(COND)) return V;}while(0)
+
+// regrettable hacks because GStreamer was not designed for runtime loading
+#undef GST_TYPE_MESSAGE
+#define GST_TYPE_MESSAGE (llgst_message_get_type())
+#undef GST_TYPE_OBJECT
+#define GST_TYPE_OBJECT (llgst_object_get_type())
+#undef GST_TYPE_PIPELINE
+#define GST_TYPE_PIPELINE (llgst_pipeline_get_type())
+#undef GST_TYPE_ELEMENT
+#define GST_TYPE_ELEMENT (llgst_element_get_type())
+#undef GST_TYPE_VIDEO_SINK
+#define GST_TYPE_VIDEO_SINK (llgst_video_sink_get_type())
+// more regrettable hacks to stub-out these .h-exposed GStreamer internals
+void ll_gst_debug_register_funcptr(GstDebugFuncPtr func, gchar* ptrname);
+#undef _gst_debug_register_funcptr
+#define _gst_debug_register_funcptr ll_gst_debug_register_funcptr
+GstDebugCategory* ll_gst_debug_category_new(gchar *name, guint color, gchar *description);
+#undef _gst_debug_category_new
+#define _gst_debug_category_new ll_gst_debug_category_new
+#undef __gst_debug_enabled
+#define __gst_debug_enabled (0)
+
+// more hacks
+#define LLGST_MESSAGE_TYPE_NAME(M) (llgst_message_type_get_name(GST_MESSAGE_TYPE(M)))
+
+#endif // LL_GSTREAMER010_ENABLED
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_raw.inc b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_raw.inc
new file mode 100644
index 0000000..b33e593
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_raw.inc
@@ -0,0 +1,51 @@
+
+// required symbols to grab
+LL_GST_SYM(true, gst_pad_peer_accept_caps, gboolean, GstPad *pad, GstCaps *caps);
+LL_GST_SYM(true, gst_buffer_new, GstBuffer*, void);
+LL_GST_SYM(true, gst_buffer_set_caps, void, GstBuffer*, GstCaps *);
+LL_GST_SYM(true, gst_structure_set_value, void, GstStructure *, const gchar *, const GValue*);
+LL_GST_SYM(true, gst_init_check, gboolean, int *argc, char **argv[], GError ** err);
+LL_GST_SYM(true, gst_message_get_type, GType, void);
+LL_GST_SYM(true, gst_message_type_get_name, const gchar*, GstMessageType type);
+LL_GST_SYM(true, gst_message_parse_error, void, GstMessage *message, GError **gerror, gchar **debug);
+LL_GST_SYM(true, gst_message_parse_warning, void, GstMessage *message, GError **gerror, gchar **debug);
+LL_GST_SYM(true, gst_message_parse_state_changed, void, GstMessage *message, GstState *oldstate, GstState *newstate, GstState *pending);
+LL_GST_SYM(true, gst_element_set_state, GstStateChangeReturn, GstElement *element, GstState state);
+LL_GST_SYM(true, gst_object_unref, void, gpointer object);
+LL_GST_SYM(true, gst_object_get_type, GType, void);
+LL_GST_SYM(true, gst_pipeline_get_type, GType, void);
+LL_GST_SYM(true, gst_pipeline_get_bus, GstBus*, GstPipeline *pipeline);
+LL_GST_SYM(true, gst_bus_add_watch, guint, GstBus * bus, GstBusFunc func, gpointer user_data);
+LL_GST_SYM(true, gst_element_factory_make, GstElement*, const gchar *factoryname, const gchar *name);
+LL_GST_SYM(true, gst_element_get_type, GType, void);
+LL_GST_SYM(true, gst_static_pad_template_get, GstPadTemplate*, GstStaticPadTemplate *pad_template);
+LL_GST_SYM(true, gst_element_class_add_pad_template, void, GstElementClass *klass, GstPadTemplate *temp);
+LL_GST_SYM(true, gst_element_class_set_details, void, GstElementClass *klass, const GstElementDetails *details);
+LL_GST_SYM(true, gst_caps_unref, void, GstCaps* caps);
+LL_GST_SYM(true, gst_caps_ref, GstCaps *, GstCaps* caps);
+//LL_GST_SYM(true, gst_caps_is_empty, gboolean, const GstCaps *caps);
+LL_GST_SYM(true, gst_caps_from_string, GstCaps *, const gchar *string);
+LL_GST_SYM(true, gst_caps_replace, void, GstCaps **caps, GstCaps *newcaps);
+LL_GST_SYM(true, gst_caps_get_structure, GstStructure *, const GstCaps *caps, guint index);
+LL_GST_SYM(true, gst_caps_copy, GstCaps *, const GstCaps * caps);
+//LL_GST_SYM(true, gst_caps_intersect, GstCaps *, const GstCaps *caps1, const GstCaps *caps2);
+LL_GST_SYM(true, gst_element_register, gboolean, GstPlugin *plugin, const gchar *name, guint rank, GType type);
+LL_GST_SYM(true, _gst_plugin_register_static, void, GstPluginDesc *desc);
+LL_GST_SYM(true, gst_structure_get_int, gboolean, const GstStructure *structure, const gchar *fieldname, gint *value);
+LL_GST_SYM(true, gst_structure_get_value, G_CONST_RETURN GValue *, const GstStructure *structure, const gchar *fieldname);
+LL_GST_SYM(true, gst_value_get_fraction_numerator, gint, const GValue *value);
+LL_GST_SYM(true, gst_value_get_fraction_denominator, gint, const GValue *value);
+LL_GST_SYM(true, gst_structure_get_name, G_CONST_RETURN gchar *, const GstStructure *structure);
+LL_GST_SYM(true, gst_element_seek, bool, GstElement *, gdouble, GstFormat, GstSeekFlags, GstSeekType, gint64, GstSeekType, gint64);
+
+// optional symbols to grab
+LL_GST_SYM(false, gst_registry_fork_set_enabled, void, gboolean enabled);
+LL_GST_SYM(false, gst_segtrap_set_enabled, void, gboolean enabled);
+LL_GST_SYM(false, gst_message_parse_buffering, void, GstMessage *message, gint *percent);
+LL_GST_SYM(false, gst_message_parse_info, void, GstMessage *message, GError **gerror, gchar **debug);
+LL_GST_SYM(false, gst_element_query_position, gboolean, GstElement *element, GstFormat *format, gint64 *cur);
+LL_GST_SYM(false, gst_version, void, guint *major, guint *minor, guint *micro, guint *nano);
+
+// GStreamer 'internal' symbols which may not be visible in some runtimes but are still used in expanded GStreamer header macros - yuck!  We'll substitute our own stubs for these.
+//LL_GST_SYM(true, _gst_debug_register_funcptr, void, GstDebugFuncPtr func, gchar* ptrname);
+//LL_GST_SYM(true, _gst_debug_category_new, GstDebugCategory *, gchar *name, guint color, gchar *description);
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_rawv.inc b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_rawv.inc
new file mode 100644
index 0000000..14fbcb4
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms_rawv.inc
@@ -0,0 +1,5 @@
+
+// required symbols to grab
+LL_GST_SYM(true, gst_video_sink_get_type, GType, void);
+
+// optional symbols to grab
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
new file mode 100644
index 0000000..e31d4a3
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
@@ -0,0 +1,53 @@
+/**
+ * @file llmediaimplgstreamertriviallogging.h
+ * @brief minimal logging utilities.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef __LLMEDIAIMPLGSTREAMERTRIVIALLOGGING_H__
+#define __LLMEDIAIMPLGSTREAMERTRIVIALLOGGING_H__
+
+#include <cstdio>
+
+/////////////////////////////////////////////////////////////////////////
+// Debug/Info/Warning macros.
+#define MSGMODULEFOO "(media plugin)"
+#define STDERRMSG(...) do{\
+    fprintf(stderr, MSGMODULEFOO " %s:%d: ", __FUNCTION__, __LINE__);\
+    fprintf(stderr, __VA_ARGS__);\
+    fputc('\n',stderr);\
+  }while(0)
+#define NULLMSG(...) do{}while(0)
+
+#define DEBUGMSG NULLMSG
+#define INFOMSG  STDERRMSG
+#define WARNMSG  STDERRMSG
+/////////////////////////////////////////////////////////////////////////
+
+#endif /* __LLMEDIAIMPLGSTREAMERTRIVIALLOGGING_H__ */
diff --git a/linden/indra/llmedia/llmediaimplgstreamervidplug.cpp b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.cpp
index f2c0e88..25e96d4 100644
--- a/linden/indra/llmedia/llmediaimplgstreamervidplug.cpp
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.cpp
@@ -1,5 +1,5 @@
 /**
- * @file llmediaimplgstreamervidplug.h
+ * @file llmediaimplgstreamervidplug.cpp
  * @brief Video-consuming static GStreamer plugin for gst-to-LLMediaImpl
  *
  * $LicenseInfo:firstyear=2007&license=viewergpl$
@@ -30,7 +30,7 @@
  * $/LicenseInfo$
  */
 
-///#if LL_GSTREAMER_ENABLED
+#if LL_GSTREAMER010_ENABLED
 
 #include "linden_common.h"
 
@@ -38,30 +38,21 @@
 #include <gst/video/video.h>
 #include <gst/video/gstvideosink.h>
 
-#include "llthread.h"
+#include "llmediaimplgstreamer_syms.h"
+#include "llmediaimplgstreamertriviallogging.h"
 
 #include "llmediaimplgstreamervidplug.h"
 
+
 GST_DEBUG_CATEGORY_STATIC (gst_slvideo_debug);
 #define GST_CAT_DEFAULT gst_slvideo_debug
 
-/* Filter signals and args */
-enum
-{
-        /* FILL ME */
-        LAST_SIGNAL
-};
-
-enum
-{
-        ARG_0
-};
 
-#define SLV_SIZECAPS ", width=(int){1,2,4,8,16,32,64,128,256,512,1024}, height=(int){1,2,4,8,16,32,64,128,256,512,1024} "
-#define SLV_ALLCAPS GST_VIDEO_CAPS_RGBx SLV_SIZECAPS ";" GST_VIDEO_CAPS_BGRx SLV_SIZECAPS
+#define SLV_SIZECAPS ", width=(int)[1,2048], height=(int)[1,2048] "
+#define SLV_ALLCAPS GST_VIDEO_CAPS_RGBx SLV_SIZECAPS
 
 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE (
-    "sink",
+    (gchar*)"sink",
     GST_PAD_SINK,
     GST_PAD_ALWAYS,
     GST_STATIC_CAPS (SLV_ALLCAPS)
@@ -87,9 +78,9 @@ gst_slvideo_base_init (gpointer gclass)
         };
         GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
         
-        gst_element_class_add_pad_template (element_class,
-                              gst_static_pad_template_get (&sink_factory));
-        gst_element_class_set_details (element_class, &element_details);
+        llgst_element_class_add_pad_template (element_class,
+                              llgst_static_pad_template_get (&sink_factory));
+        llgst_element_class_set_details (element_class, &element_details);
 }
 
 
@@ -100,7 +91,7 @@ gst_slvideo_finalize (GObject * object)
         slvideo = GST_SLVIDEO (object);
         if (slvideo->caps)
         {
-                gst_caps_unref(slvideo->caps);
+                llgst_caps_unref(slvideo->caps);
         }
 
         G_OBJECT_CLASS(parent_class)->finalize (object);
@@ -111,7 +102,7 @@ static GstFlowReturn
 gst_slvideo_show_frame (GstBaseSink * bsink, GstBuffer * buf)
 {
         GstSLVideo *slvideo;
-        g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
+        llg_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
         
         slvideo = GST_SLVIDEO(bsink);
         
@@ -204,7 +195,7 @@ gst_slvideo_get_caps (GstBaseSink * bsink)
         GstSLVideo *slvideo;
         slvideo = GST_SLVIDEO(bsink);
         
-        return gst_caps_ref (slvideo->caps);
+        return llgst_caps_ref (slvideo->caps);
 }
 
 
@@ -214,42 +205,37 @@ gst_slvideo_set_caps (GstBaseSink * bsink, GstCaps * caps)
 {
         GstSLVideo *filter;
         GstStructure *structure;
-        GstCaps *intersection;
         
         GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps);
         
         filter = GST_SLVIDEO(bsink);
-        
-        intersection = gst_caps_intersect (filter->caps, caps);
-        if (gst_caps_is_empty (intersection))
-        {
-                // no overlap between our caps and requested caps
-                return FALSE;
-        }
-        gst_caps_unref(intersection);
-        
-        int width = 0;
-        int height = 0;
+
+        int width, height;
         gboolean ret;
         const GValue *fps;
         const GValue *par;
-        structure = gst_caps_get_structure (caps, 0);
-        ret = gst_structure_get_int (structure, "width", &width);
-        ret = ret && gst_structure_get_int (structure, "height", &height);
-        fps = gst_structure_get_value (structure, "framerate");
+        structure = llgst_caps_get_structure (caps, 0);
+        ret = llgst_structure_get_int (structure, "width", &width);
+        ret = ret && llgst_structure_get_int (structure, "height", &height);
+        fps = llgst_structure_get_value (structure, "framerate");
         ret = ret && (fps != NULL);
-        par = gst_structure_get_value (structure, "pixel-aspect-ratio");
+        par = llgst_structure_get_value (structure, "pixel-aspect-ratio");
         if (!ret)
                 return FALSE;
 
+        INFOMSG("** filter caps set with width=%d, height=%d", width, height);
+
+        GST_OBJECT_LOCK(filter);
+
         filter->width = width;
         filter->height = height;
-        filter->fps_n = gst_value_get_fraction_numerator(fps);
-        filter->fps_d = gst_value_get_fraction_denominator(fps);
+
+        filter->fps_n = llgst_value_get_fraction_numerator(fps);
+        filter->fps_d = llgst_value_get_fraction_denominator(fps);
         if (par)
         {
-                filter->par_n = gst_value_get_fraction_numerator(par);
-                filter->par_d = gst_value_get_fraction_denominator(par);
+                filter->par_n = llgst_value_get_fraction_numerator(par);
+                filter->par_d = llgst_value_get_fraction_denominator(par);
         }
         else
         {
@@ -259,16 +245,18 @@ gst_slvideo_set_caps (GstBaseSink * bsink, GstCaps * caps)
         GST_VIDEO_SINK_WIDTH(filter) = width;
         GST_VIDEO_SINK_HEIGHT(filter) = height;
         
+        // crufty lump - we *always* accept *only* RGBX now.
+        /*
         filter->format = SLV_PF_UNKNOWN;
-        if (0 == strcmp(gst_structure_get_name(structure),
+        if (0 == strcmp(llgst_structure_get_name(structure),
                         "video/x-raw-rgb"))
         {
                 int red_mask;
                 int green_mask;
                 int blue_mask;
-                gst_structure_get_int(structure, "red_mask", &red_mask);
-                gst_structure_get_int(structure, "green_mask", &green_mask);
-                gst_structure_get_int(structure, "blue_mask", &blue_mask);
+                llgst_structure_get_int(structure, "red_mask", &red_mask);
+                llgst_structure_get_int(structure, "green_mask", &green_mask);
+                llgst_structure_get_int(structure, "blue_mask", &blue_mask);
                 if ((unsigned int)red_mask   == 0xFF000000 &&
                     (unsigned int)green_mask == 0x00FF0000 &&
                     (unsigned int)blue_mask  == 0x0000FF00)
@@ -282,8 +270,12 @@ gst_slvideo_set_caps (GstBaseSink * bsink, GstCaps * caps)
                         filter->format = SLV_PF_BGRX;
                         //fprintf(stderr, "\n\nPIXEL FORMAT BGR\n\n");
                 }
-        }
+                }*/
         
+        filter->format = SLV_PF_RGBX;
+
+        GST_OBJECT_UNLOCK(filter);
+
         return TRUE;
 }
 
@@ -317,6 +309,97 @@ gst_slvideo_stop (GstBaseSink * bsink)
 }
 
 
+static GstFlowReturn
+gst_slvideo_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size,
+                          GstCaps * caps, GstBuffer ** buf)
+{
+        gint width, height;
+        GstStructure *structure = NULL;
+        GstSLVideo *slvideo;
+        slvideo = GST_SLVIDEO(bsink);
+
+        // caps == requested caps
+        // we can ignore these and reverse-negotiate our preferred dimensions with
+        // the peer if we like - we need to do this to obey dynamic resize requests
+        // flowing in from the app.
+        structure = llgst_caps_get_structure (caps, 0);
+        if (!llgst_structure_get_int(structure, "width", &width) ||
+            !llgst_structure_get_int(structure, "height", &height))
+        {
+                GST_WARNING_OBJECT (slvideo, "no width/height in caps %" GST_PTR_FORMAT, caps);
+                return GST_FLOW_NOT_NEGOTIATED;
+        }
+
+        GstBuffer *newbuf = llgst_buffer_new();
+        bool made_bufferdata_ptr = false;
+#define MAXDEPTHHACK 4
+        
+        GST_OBJECT_LOCK(slvideo);
+        if (slvideo->resize_forced)
+        {
+                gint slwantwidth, slwantheight;
+                slwantwidth = slvideo->resize_try_width;
+                slwantheight = slvideo->resize_try_height;
+        
+                if (slwantwidth != width ||
+                    slwantheight != height)
+                {
+                        // don't like requested caps, we will issue our own suggestion - copy
+                        // the requested caps but substitute our own width and height and see
+                        // if our peer is happy with that.
+                
+                        GstCaps *desired_caps;
+                        GstStructure *desired_struct;
+                        desired_caps = llgst_caps_copy (caps);
+                        desired_struct = llgst_caps_get_structure (desired_caps, 0);
+                        
+                        GValue value = {0};
+                        g_value_init(&value, G_TYPE_INT);
+                        g_value_set_int(&value, slwantwidth);
+                        llgst_structure_set_value (desired_struct, "width", &value);
+                        g_value_unset(&value);
+                        g_value_init(&value, G_TYPE_INT);
+                        g_value_set_int(&value, slwantheight);
+                        llgst_structure_set_value (desired_struct, "height", &value);
+                        
+                        if (llgst_pad_peer_accept_caps (GST_VIDEO_SINK_PAD (slvideo),
+                                                        desired_caps))
+                        {
+                                // todo: re-use buffers from a pool?
+                                // todo: set MALLOCDATA to null, set DATA to point straight to shm?
+                                
+                                // peer likes our cap suggestion
+                                DEBUGMSG("peer loves us :)");
+                                GST_BUFFER_SIZE(newbuf) = slwantwidth * slwantheight * MAXDEPTHHACK;
+                                GST_BUFFER_MALLOCDATA(newbuf) = (guint8*)g_malloc(GST_BUFFER_SIZE(newbuf));
+                                GST_BUFFER_DATA(newbuf) = GST_BUFFER_MALLOCDATA(newbuf);
+                                llgst_buffer_set_caps (GST_BUFFER_CAST(newbuf), desired_caps);
+
+                                made_bufferdata_ptr = true;
+                        } else {
+                                // peer hates our cap suggestion
+                                INFOMSG("peer hates us :(");
+                                llgst_caps_unref(desired_caps);
+                        }
+                }
+        }
+
+        if (!made_bufferdata_ptr) // need to fallback to malloc at original size
+        {
+                GST_BUFFER_SIZE(newbuf) = width * height * MAXDEPTHHACK;
+                GST_BUFFER_MALLOCDATA(newbuf) = (guint8*)g_malloc(GST_BUFFER_SIZE(newbuf));
+                GST_BUFFER_DATA(newbuf) = GST_BUFFER_MALLOCDATA(newbuf);
+                llgst_buffer_set_caps (GST_BUFFER_CAST(newbuf), caps);
+        }
+
+        GST_OBJECT_UNLOCK(slvideo);
+
+        *buf = GST_BUFFER_CAST(newbuf);
+
+        return GST_FLOW_OK;
+}
+
+
 /* initialize the plugin's class */
 static void
 gst_slvideo_class_init (GstSLVideoClass * klass)
@@ -338,7 +421,7 @@ gst_slvideo_class_init (GstSLVideoClass * klass)
 #define LLGST_DEBUG_FUNCPTR(p) (p)
         gstbasesink_class->get_caps = LLGST_DEBUG_FUNCPTR (gst_slvideo_get_caps);
         gstbasesink_class->set_caps = LLGST_DEBUG_FUNCPTR( gst_slvideo_set_caps);
-        //gstbasesink_class->buffer_alloc=LLGST_DEBUG_FUNCPTR(gst_slvideo_buffer_alloc);
+        gstbasesink_class->buffer_alloc=LLGST_DEBUG_FUNCPTR(gst_slvideo_buffer_alloc);
         //gstbasesink_class->get_times = LLGST_DEBUG_FUNCPTR (gst_slvideo_get_times);
         gstbasesink_class->preroll = LLGST_DEBUG_FUNCPTR (gst_slvideo_show_frame);
         gstbasesink_class->render = LLGST_DEBUG_FUNCPTR (gst_slvideo_show_frame);
@@ -351,20 +434,6 @@ gst_slvideo_class_init (GstSLVideoClass * klass)
 }
 
 
-static void
-gst_slvideo_update_caps (GstSLVideo * slvideo)
-{
-        GstCaps *caps;
-
-        // GStreamer will automatically convert colourspace if necessary.
-        // GStreamer will automatically resize media to one of these enumerated
-        // powers-of-two that we ask for (yay GStreamer!)
-        caps = gst_caps_from_string (SLV_ALLCAPS);
-        
-        gst_caps_replace (&slvideo->caps, caps);
-}
-
-
 /* initialize the new element
  * instantiate pads and add them to element
  * set functions
@@ -374,6 +443,7 @@ static void
 gst_slvideo_init (GstSLVideo * filter,
                   GstSLVideoClass * gclass)
 {
+        filter->caps = NULL;
         filter->width = -1;
         filter->height = -1;
 
@@ -385,19 +455,24 @@ gst_slvideo_init (GstSLVideo * filter,
         filter->retained_frame_width = filter->width;
         filter->retained_frame_height = filter->height;
         filter->retained_frame_format = SLV_PF_UNKNOWN;
+        GstCaps *caps = llgst_caps_from_string (SLV_ALLCAPS);
+        llgst_caps_replace (&filter->caps, caps);
+        filter->resize_forced = false;
+        filter->resize_try_width = -1;
+        filter->resize_try_height = -1;
         GST_OBJECT_UNLOCK(filter);
-        
-        gst_slvideo_update_caps(filter);
 }
 
 static void
 gst_slvideo_set_property (GObject * object, guint prop_id,
                           const GValue * value, GParamSpec * pspec)
 {
-        g_return_if_fail (GST_IS_SLVIDEO (object));
+        llg_return_if_fail (GST_IS_SLVIDEO (object));
         
-        if (prop_id) {
+        switch (prop_id) {
+        default:
                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
         }
 }
 
@@ -405,10 +480,12 @@ static void
 gst_slvideo_get_property (GObject * object, guint prop_id,
                           GValue * value, GParamSpec * pspec)
 {
-        g_return_if_fail (GST_IS_SLVIDEO (object));
+        llg_return_if_fail (GST_IS_SLVIDEO (object));
 
-        if (prop_id) {
+        switch (prop_id) {
+        default:
                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
         }
 }
 
@@ -421,28 +498,35 @@ gst_slvideo_get_property (GObject * object, guint prop_id,
 static gboolean
 plugin_init (GstPlugin * plugin)
 {
-        //fprintf(stderr, "\n\n\nPLUGIN INIT\n\n\n");
+        DEBUGMSG("\n\n\nPLUGIN INIT\n\n\n");
 
         GST_DEBUG_CATEGORY_INIT (gst_slvideo_debug, (gchar*)"private-slvideo-plugin",
                                  0, (gchar*)"Second Life Video Sink");
 
-        return gst_element_register (plugin, "private-slvideo",
+        return llgst_element_register (plugin, (gchar*)"private-slvideo",
                                        GST_RANK_NONE, GST_TYPE_SLVIDEO);
 }
 
-
+/* this is the structure that gstreamer looks for to register plugins
+ */
+/* NOTE: Can't rely upon GST_PLUGIN_DEFINE_STATIC to self-register, since
+   some g++ versions buggily avoid __attribute__((constructor)) functions -
+   so we provide an explicit plugin init function.
+ */
 void gst_slvideo_init_class (void)
 {
-        gst_plugin_register_static( GST_VERSION_MAJOR,
-                                    GST_VERSION_MINOR,
-                                    (const gchar *)"private-slvideoplugin", 
-                                    (gchar *)"SL Video sink plugin",
-                                    plugin_init,
-                                    (const gchar *)"0.1",
-                                    GST_LICENSE_UNKNOWN,
-                                    (const gchar *)"Second Life",
-                                    (const gchar *)"Second Life",
-                                    (const gchar *)"http://www.secondlife.com/" );
+#define PACKAGE "packagehack"
+        // this macro quietly refers to PACKAGE internally
+        static GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+                                  GST_VERSION_MINOR,
+                                  (gchar*)"private-slvideoplugin",
+                                  (gchar*)"SL Video sink plugin",
+                                  plugin_init, (gchar*)"0.1", (gchar*)GST_LICENSE_UNKNOWN,
+                                  (gchar*)"Second Life",
+                                  (gchar*)"http://www.secondlife.com/");
+#undef PACKAGE
+        ll_gst_plugin_register_static (&gst_plugin_desc);
+        DEBUGMSG(stderr, "\n\n\nCLASS INIT\n\n\n");
 }
 
-///#endif // LL_GSTREAMER_ENABLED
+#endif // LL_GSTREAMER010_ENABLED
diff --git a/linden/indra/llmedia/llmediaimplgstreamervidplug.h b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.h
index 3a984a9..f6d55b8 100644
--- a/linden/indra/llmedia/llmediaimplgstreamervidplug.h
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.h
@@ -33,13 +33,12 @@
 #ifndef __GST_SLVIDEO_H__
 #define __GST_SLVIDEO_H__
 
-///#if LL_GSTREAMER_ENABLED
+#if LL_GSTREAMER010_ENABLED
 
 extern "C" {
 #include <gst/gst.h>
 #include <gst/video/video.h>
 #include <gst/video/gstvideosink.h>
-#include <glib/gthread.h>
 }
 
 G_BEGIN_DECLS
@@ -85,9 +84,13 @@ struct _GstSLVideo
         // when the retained frame is updated.)
         bool retained_frame_ready; // new frame ready since flag last reset. (*TODO: could get the writer to wait on a semaphore instead of having the reader poll, potentially making dropped frames somewhat cheaper.)
         unsigned char*  retained_frame_data;
-        int  retained_frame_allocbytes;
-        int  retained_frame_width, retained_frame_height;
+        int retained_frame_allocbytes;
+        int retained_frame_width, retained_frame_height;
         SLVPixelFormat retained_frame_format;
+        // sticky resize info
+        bool resize_forced;
+        int resize_try_width;
+        int resize_try_height;
 };
 
 struct _GstSLVideoClass 
@@ -101,6 +104,6 @@ void gst_slvideo_init_class (void);
 
 G_END_DECLS
 
-///#endif // LL_GSTREAMER_ENABLED
+#endif // LL_GSTREAMER010_ENABLED
 
 #endif /* __GST_SLVIDEO_H__ */
diff --git a/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
new file mode 100644
index 0000000..77b7c13
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
@@ -0,0 +1,1202 @@
+/** 
+ * @file media_plugin_gstreamer010.cpp
+ * @brief GStreamer-0.10 plugin for LLMedia API plugin system
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llgl.h"
+
+#include "llplugininstance.h"
+#include "llpluginmessage.h"
+#include "llpluginmessageclasses.h"
+#include "media_plugin_base.h"
+
+#if LL_GSTREAMER010_ENABLED
+
+extern "C" {
+#include <gst/gst.h>
+}
+
+#include "llmediaimplgstreamer.h"
+#include "llmediaimplgstreamertriviallogging.h"
+
+#include "llmediaimplgstreamervidplug.h"
+
+#include "llmediaimplgstreamer_syms.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//
+class MediaPluginGStreamer010 : public MediaPluginBase
+{
+public:
+        MediaPluginGStreamer010(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~MediaPluginGStreamer010();
+
+        /* virtual */ void receiveMessage(const char *message_string);
+
+        static bool startup();
+        static bool closedown();
+
+        gboolean processGSTEvents(GstBus     *bus,
+                                  GstMessage *message);
+
+private:
+        std::string getVersion();
+        bool navigateTo( const std::string urlIn );
+        bool seek( double time_sec );
+        bool setVolume( float volume );
+        
+        // misc
+        bool pause();
+        bool stop();
+        bool play(double rate);
+        bool getTimePos(double &sec_out);
+
+        static const double MIN_LOOP_SEC = 1.0F;
+
+        bool mIsLooping;
+
+        enum ECommand {
+                COMMAND_NONE,
+                COMMAND_STOP,
+                COMMAND_PLAY,
+                COMMAND_FAST_FORWARD,
+                COMMAND_FAST_REWIND,
+                COMMAND_PAUSE,
+                COMMAND_SEEK,
+        };
+        ECommand mCommand;
+
+private:
+        bool unload();
+        bool load();
+
+        bool update(int milliseconds);
+        void mouseDown( int x, int y );
+        void mouseUp( int x, int y );
+        void mouseMove( int x, int y );
+
+        bool sizeChanged();
+        
+        static bool mDoneInit;
+        
+        guint mBusWatchID;
+        
+        float mVolume;
+
+        int mDepth;
+
+        // media natural size
+        int mNaturalWidth;
+        int mNaturalHeight;
+        int mNaturalRowbytes;
+        // previous media natural size so we can detect changes
+        int mPreviousNaturalWidth;
+        int mPreviousNaturalHeight;
+        // desired render size from host
+        int mWidth;
+        int mHeight;
+        // padded texture size we need to write into
+        int mTextureWidth;
+        int mTextureHeight;
+        
+        int mTextureFormatPrimary;
+        int mTextureFormatType;
+
+        bool mSeekWanted;
+        double mSeekDestination;
+        
+        // Very GStreamer-specific
+        GMainLoop *mPump; // event pump for this media
+        GstElement *mPlaybin;
+        GstSLVideo *mVideoSink;
+};
+
+//static
+bool MediaPluginGStreamer010::mDoneInit = false;
+
+MediaPluginGStreamer010::MediaPluginGStreamer010(
+        LLPluginInstance::sendMessageFunction host_send_func,
+        void *host_user_data ) :
+        MediaPluginBase(host_send_func, host_user_data),
+        mBusWatchID ( 0 ),
+        mNaturalRowbytes ( 4 ),
+        mTextureFormatPrimary ( GL_RGBA ),
+        mTextureFormatType ( GL_UNSIGNED_INT_8_8_8_8_REV ),
+        mSeekWanted(false),
+        mSeekDestination(0.0),
+        mPump ( NULL ),
+        mPlaybin ( NULL ),
+        mVideoSink ( NULL ),
+        mCommand ( COMMAND_NONE )
+{
+        std::ostringstream str;
+        INFOMSG("MediaPluginGStreamer010 constructor - my PID=%u", U32(getpid()));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//#define LL_GST_REPORT_STATE_CHANGES
+#ifdef LL_GST_REPORT_STATE_CHANGES
+static char* get_gst_state_name(GstState state)
+{
+        switch (state) {
+        case GST_STATE_VOID_PENDING: return "VOID_PENDING";
+        case GST_STATE_NULL: return "NULL";
+        case GST_STATE_READY: return "READY";
+        case GST_STATE_PAUSED: return "PAUSED";
+        case GST_STATE_PLAYING: return "PLAYING";
+        }
+        return "(unknown)";
+}
+#endif // LL_GST_REPORT_STATE_CHANGES
+
+gboolean
+MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
+                                          GstMessage *message)
+{
+        if (!message) 
+                return TRUE; // shield against GStreamer bug
+
+        if (GST_MESSAGE_TYPE(message) != GST_MESSAGE_STATE_CHANGED &&
+            GST_MESSAGE_TYPE(message) != GST_MESSAGE_BUFFERING)
+        {
+                DEBUGMSG("Got GST message type: %s",
+                        LLGST_MESSAGE_TYPE_NAME (message));
+        }
+        else
+        {
+                DEBUGMSG("Got GST message type: %s",
+                         LLGST_MESSAGE_TYPE_NAME (message));
+        }
+
+        switch (GST_MESSAGE_TYPE (message)) {
+        case GST_MESSAGE_BUFFERING: {
+                // NEEDS GST 0.10.11+
+                if (llgst_message_parse_buffering)
+                {
+                        gint percent = 0;
+                        llgst_message_parse_buffering(message, &percent);
+                        DEBUGMSG("GST buffering: %d%%", percent);
+                }
+                break;
+        }
+        case GST_MESSAGE_STATE_CHANGED: {
+                GstState old_state;
+                GstState new_state;
+                GstState pending_state;
+                llgst_message_parse_state_changed(message,
+                                                &old_state,
+                                                &new_state,
+                                                &pending_state);
+#ifdef LL_GST_REPORT_STATE_CHANGES
+                // not generally very useful, and rather spammy.
+                DEBUGMSG("state change (old,<new>,pending): %s,<%s>,%s",
+                         get_gst_state_name(old_state),
+                         get_gst_state_name(new_state),
+                         get_gst_state_name(pending_state));
+#endif // LL_GST_REPORT_STATE_CHANGES
+
+                switch (new_state) {
+                case GST_STATE_VOID_PENDING:
+                        break;
+                case GST_STATE_NULL:
+                        break;
+                case GST_STATE_READY:
+                        setStatus(STATUS_LOADED);
+                        break;
+                case GST_STATE_PAUSED:
+                        setStatus(STATUS_PAUSED);
+                        break;
+                case GST_STATE_PLAYING:
+                        setStatus(STATUS_PLAYING);
+                        break;
+                }
+                break;
+        }
+        case GST_MESSAGE_ERROR: {
+                GError *err = NULL;
+                gchar *debug = NULL;
+
+                llgst_message_parse_error (message, &err, &debug);
+                WARNMSG("GST error: %s", err?err->message:"(unknown)");
+                if (err)
+                        g_error_free (err);
+                g_free (debug);
+
+                mCommand = COMMAND_STOP;
+
+                setStatus(STATUS_ERROR);
+
+                break;
+        }
+        case GST_MESSAGE_INFO: {
+                if (llgst_message_parse_info)
+                {
+                        GError *err = NULL;
+                        gchar *debug = NULL;
+                        
+                        llgst_message_parse_info (message, &err, &debug);
+                        INFOMSG("GST info: %s", err?err->message:"(unknown)");
+                        if (err)
+                                g_error_free (err);
+                        g_free (debug);
+                }
+                break;
+        }
+        case GST_MESSAGE_WARNING: {
+                GError *err = NULL;
+                gchar *debug = NULL;
+
+                llgst_message_parse_warning (message, &err, &debug);
+                WARNMSG("GST warning: %s", err?err->message:"(unknown)");
+                if (err)
+                        g_error_free (err);
+                g_free (debug);
+
+                break;
+        }
+        case GST_MESSAGE_EOS:
+                /* end-of-stream */
+                DEBUGMSG("GST end-of-stream.");
+                if (mIsLooping)
+                {
+                        DEBUGMSG("looping media...");
+                        double eos_pos_sec = 0.0F;
+                        bool got_eos_position = getTimePos(eos_pos_sec);
+
+                        if (got_eos_position && eos_pos_sec < MIN_LOOP_SEC)
+                        {
+                                // if we know that the movie is really short, don't
+                                // loop it else it can easily become a time-hog
+                                // because of GStreamer spin-up overhead
+                                DEBUGMSG("really short movie (%0.3fsec) - not gonna loop this, pausing instead.", eos_pos_sec);
+                                // inject a COMMAND_PAUSE
+                                mCommand = COMMAND_PAUSE;
+                        }
+                        else
+                        {
+#undef LLGST_LOOP_BY_SEEKING
+// loop with a stop-start instead of a seek, because it actually seems rather
+// faster than seeking on remote streams.
+#ifdef LLGST_LOOP_BY_SEEKING
+                                // first, try looping by an explicit rewind
+                                bool seeksuccess = seek(0.0);
+                                if (seeksuccess)
+                                {
+                                        play(1.0);
+                                }
+                                else
+#endif // LLGST_LOOP_BY_SEEKING
+                                {  // use clumsy stop-start to loop
+                                        DEBUGMSG("didn't loop by rewinding - stopping and starting instead...");
+                                        stop();
+                                        play(1.0);
+                                }
+                        }
+                }
+                else // not a looping media
+                {
+                        // inject a COMMAND_STOP
+                        mCommand = COMMAND_STOP;
+                }
+                break;
+        default:
+                /* unhandled message */
+                break;
+        }
+
+        /* we want to be notified again the next time there is a message
+         * on the bus, so return true (false means we want to stop watching
+         * for messages on the bus and our callback should not be called again)
+         */
+        return TRUE;
+}
+
+extern "C" {
+gboolean
+llmediaimplgstreamer_bus_callback (GstBus     *bus,
+                                   GstMessage *message,
+                                   gpointer    data)
+{
+        MediaPluginGStreamer010 *impl = (MediaPluginGStreamer010*)data;
+        return impl->processGSTEvents(bus, message);
+}
+} // extern "C"
+
+
+
+bool
+MediaPluginGStreamer010::navigateTo ( const std::string urlIn )
+{
+        if (!mDoneInit)
+                return false; // error
+
+        setStatus(STATUS_LOADING);
+
+        DEBUGMSG("Setting media URI: %s", urlIn.c_str());
+
+        mSeekWanted = false;
+
+        if (NULL == mPump ||
+            NULL == mPlaybin)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // set URI
+        g_object_set (G_OBJECT (mPlaybin), "uri", urlIn.c_str(), NULL);
+        //g_object_set (G_OBJECT (mPlaybin), "uri", "file:///tmp/movie", NULL);
+
+        // navigateTo implicitly plays, too.
+        play(1.0);
+
+        return true;
+}
+
+
+bool
+MediaPluginGStreamer010::update(int milliseconds)
+{
+        if (!mDoneInit)
+                return false; // error
+
+        DEBUGMSG("updating media...");
+        
+        // sanity check
+        if (NULL == mPump ||
+            NULL == mPlaybin)
+        {
+                DEBUGMSG("dead media...");
+                return false;
+        }
+
+        // see if there's an outstanding seek wanted
+        if (mSeekWanted &&
+            // bleh, GST has to be happy that the movie is really truly playing
+            // or it may quietly ignore the seek (with rtsp:// at least).
+            (GST_STATE(mPlaybin) == GST_STATE_PLAYING))
+        {
+                seek(mSeekDestination);
+                mSeekWanted = false;
+        }
+
+        // *TODO: time-limit - but there isn't a lot we can do here, most
+        // time is spent in gstreamer's own opaque worker-threads.  maybe
+        // we can do something sneaky like only unlock the video object
+        // for 'milliseconds' and otherwise hold the lock.
+        while (g_main_context_pending(g_main_loop_get_context(mPump)))
+        {
+               g_main_context_iteration(g_main_loop_get_context(mPump), FALSE);
+        }
+
+        // check for availability of a new frame
+        
+        if (mVideoSink)
+        {
+                GST_OBJECT_LOCK(mVideoSink);
+                if (mVideoSink->retained_frame_ready)
+                {
+                        DEBUGMSG("NEW FRAME READY");
+
+                        if (mVideoSink->retained_frame_width != mNaturalWidth ||
+                            mVideoSink->retained_frame_height != mNaturalHeight)
+                                // *TODO: also check for change in format
+                        {
+                                // just resize container, don't consume frame
+                                int neww = mVideoSink->retained_frame_width;
+                                int newh = mVideoSink->retained_frame_height;
+
+                                int newd = 4;
+                                mTextureFormatPrimary = GL_RGBA;
+                                mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+
+                                /*
+                                int newd = SLVPixelFormatBytes[mVideoSink->retained_frame_format];
+                                if (SLV_PF_BGRX == mVideoSink->retained_frame_format)
+                                {
+                                        mTextureFormatPrimary = GL_BGRA;
+                                        mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+                                }
+                                else
+                                {
+                                        mTextureFormatPrimary = GL_RGBA;
+                                        mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+                                }
+                                */
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+
+                                mNaturalRowbytes = neww * newd;
+                                DEBUGMSG("video container resized to %dx%d",
+                                         neww, newh);
+
+                                mDepth = newd;
+                                mNaturalWidth = neww;
+                                mNaturalHeight = newh;
+                                sizeChanged();
+                                return true;
+                        }
+
+                        if (mPixels &&
+                            mNaturalHeight <= mHeight &&
+                            mNaturalWidth <= mWidth &&
+                            !mTextureSegmentName.empty())
+                        {
+                                
+                                // we're gonna totally consume this frame - reset 'ready' flag
+                                mVideoSink->retained_frame_ready = FALSE;                               
+                                int destination_rowbytes = mWidth * mDepth;
+                                for (int row=0; row<mNaturalHeight; ++row)
+                                {
+                                        memcpy(&mPixels
+                                                [destination_rowbytes * row],
+                                               &mVideoSink->retained_frame_data
+                                                [mNaturalRowbytes * row],
+                                               mNaturalRowbytes);
+                                }
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+                                DEBUGMSG("NEW FRAME REALLY TRULY CONSUMED, TELLING HOST");
+
+                                setDirty(0,0,mNaturalWidth,mNaturalHeight);
+                        }
+                        else
+                        {
+                                // new frame ready, but we're not ready to
+                                // consume it.
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+
+                                DEBUGMSG("NEW FRAME not consumed, still waiting for a shm segment and/or shm resize");
+                        }
+
+                        return true;
+                }
+                else
+                {
+                        // nothing to do yet.
+                        GST_OBJECT_UNLOCK(mVideoSink);
+                        return true;
+                }
+        }
+
+        return true;
+}
+
+
+void
+MediaPluginGStreamer010::mouseDown( int x, int y )
+{
+  // do nothing
+}
+
+void
+MediaPluginGStreamer010::mouseUp( int x, int y )
+{
+  // do nothing
+}
+
+void
+MediaPluginGStreamer010::mouseMove( int x, int y )
+{
+  // do nothing
+}
+
+
+bool
+MediaPluginGStreamer010::pause()
+{
+        DEBUGMSG("pausing media...");
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_PAUSED);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::stop()
+{
+        DEBUGMSG("stopping media...");
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_READY);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::play(double rate)
+{
+        // NOTE: we don't actually support non-natural rate.
+
+        DEBUGMSG("playing media... rate=%f", rate);
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_PLAYING);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::setVolume( float volume )
+{
+        // we try to only update volume as conservatively as
+        // possible, as many gst-plugins-base versions up to at least
+        // November 2008 have critical race-conditions in setting volume - sigh
+        if (mVolume == volume)
+                return true; // nothing to do, everything's fine
+
+        mVolume = volume;
+        if (mDoneInit && mPlaybin)
+        {
+                g_object_set(mPlaybin, "volume", mVolume, NULL);
+                return true;
+        }
+
+        return false;
+}
+
+bool
+MediaPluginGStreamer010::seek(double time_sec)
+{
+        bool success = false;
+        if (mDoneInit && mPlaybin)
+        {
+                success = llgst_element_seek(mPlaybin, 1.0F, GST_FORMAT_TIME,
+                                GstSeekFlags(GST_SEEK_FLAG_FLUSH |
+                                             GST_SEEK_FLAG_KEY_UNIT),
+                                GST_SEEK_TYPE_SET, gint64(time_sec*GST_SECOND),
+                                GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+        }
+        DEBUGMSG("MEDIA SEEK REQUEST to %fsec result was %d",
+                 float(time_sec), int(success));
+        return success;
+}
+
+bool
+MediaPluginGStreamer010::getTimePos(double &sec_out)
+{
+        bool got_position = false;
+        if (mPlaybin)
+        {
+                gint64 pos;
+                GstFormat timefmt = GST_FORMAT_TIME;
+                got_position =
+                        llgst_element_query_position &&
+                        llgst_element_query_position(mPlaybin,
+                                                     &timefmt,
+                                                     &pos);
+                got_position = got_position
+                        && (timefmt == GST_FORMAT_TIME);
+                // GStreamer may have other ideas, but we consider the current position
+                // undefined if not PLAYING or PAUSED
+                got_position = got_position &&
+                        (GST_STATE(mPlaybin) == GST_STATE_PLAYING ||
+                         GST_STATE(mPlaybin) == GST_STATE_PAUSED);
+                if (got_position && !GST_CLOCK_TIME_IS_VALID(pos))
+                {
+                        if (GST_STATE(mPlaybin) == GST_STATE_PLAYING)
+                        {
+                                // if we're playing then we treat an invalid clock time
+                                // as 0, for complicated reasons (insert reason here)
+                                pos = 0;
+                        }
+                        else
+                        {
+                                got_position = false;
+                        }
+                        
+                }
+                // If all the preconditions succeeded... we can trust the result.
+                if (got_position)
+                {
+                        sec_out = double(pos) / double(GST_SECOND); // gst to sec
+                }
+        }
+        return got_position;
+}
+
+bool
+MediaPluginGStreamer010::load()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        setStatus(STATUS_LOADING);
+
+        DEBUGMSG("setting up media...");
+
+        mIsLooping = false;
+        mVolume = 0.1234567; // minor hack to force an initial volume update
+
+        // Create a pumpable main-loop for this media
+        mPump = g_main_loop_new (NULL, FALSE);
+        if (!mPump)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // instantiate a playbin element to do the hard work
+        mPlaybin = llgst_element_factory_make ("playbin", "play");
+        if (!mPlaybin)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // get playbin's bus
+        GstBus *bus = llgst_pipeline_get_bus (GST_PIPELINE (mPlaybin));
+        if (!bus)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+        mBusWatchID = llgst_bus_add_watch (bus,
+                                           llmediaimplgstreamer_bus_callback,
+                                           this);
+        llgst_object_unref (bus);
+
+        if (NULL == getenv("LL_GSTREAMER_EXTERNAL")) {
+                // instantiate a custom video sink
+                mVideoSink =
+                        GST_SLVIDEO(llgst_element_factory_make ("private-slvideo", "slvideo"));
+                if (!mVideoSink)
+                {
+                        WARNMSG("Could not instantiate private-slvideo element.");
+                        // todo: cleanup.
+                        setStatus(STATUS_ERROR);
+                        return false; // error
+                }
+
+                // connect the pieces
+                g_object_set(mPlaybin, "video-sink", mVideoSink, NULL);
+        }
+
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::unload ()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        DEBUGMSG("unloading media...");
+        
+        // stop getting callbacks for this bus
+        g_source_remove(mBusWatchID);
+        mBusWatchID = 0;
+
+        if (mPlaybin)
+        {
+                llgst_element_set_state (mPlaybin, GST_STATE_NULL);
+                llgst_object_unref (GST_OBJECT (mPlaybin));
+                mPlaybin = NULL;
+        }
+
+        if (mPump)
+        {
+                g_main_loop_quit(mPump);
+                mPump = NULL;
+        }
+
+        mVideoSink = NULL;
+
+        setStatus(STATUS_NONE);
+
+        return true;
+}
+
+
+//static
+bool
+MediaPluginGStreamer010::startup()
+{
+        // first - check if GStreamer is explicitly disabled
+        if (NULL != getenv("LL_DISABLE_GSTREAMER"))
+                return false;
+
+        // only do global GStreamer initialization once.
+        if (!mDoneInit)
+        {
+                g_thread_init(NULL);
+
+                // Init the glib type system - we need it.
+                g_type_init();
+
+                // Get symbols!
+#if LL_DARWIN
+                if (! grab_gst_syms("libgstreamer-0.10.dylib",
+                                    "libgstvideo-0.10.dylib") )
+#elseif LL_WINDOWS
+                if (! grab_gst_syms("libgstreamer-0.10.dll",
+                                    "libgstvideo-0.10.dll") )
+#else // linux or other ELFy unixoid
+                if (! grab_gst_syms("libgstreamer-0.10.so.0",
+                                    "libgstvideo-0.10.so.0") )
+#endif
+                {
+                        WARNMSG("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled.");
+                        return false;
+                }
+
+                if (llgst_segtrap_set_enabled)
+                {
+                        llgst_segtrap_set_enabled(FALSE);
+                }
+                else
+                {
+                        WARNMSG("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught.");
+                }
+
+#if LL_LINUX
+                // Gstreamer tries a fork during init, waitpid-ing on it,
+                // which conflicts with any installed SIGCHLD handler...
+                struct sigaction tmpact, oldact;
+                if (llgst_registry_fork_set_enabled) {
+                        // if we can disable SIGCHLD-using forking behaviour,
+                        // do it.
+                        llgst_registry_fork_set_enabled(false);
+                }
+                else {
+                        // else temporarily install default SIGCHLD handler
+                        // while GStreamer initialises
+                        tmpact.sa_handler = SIG_DFL;
+                        sigemptyset( &tmpact.sa_mask );
+                        tmpact.sa_flags = SA_SIGINFO;
+                        sigaction(SIGCHLD, &tmpact, &oldact);
+                }
+#endif // LL_LINUX
+
+                // Protect against GStreamer resetting the locale, yuck.
+                static std::string saved_locale;
+                saved_locale = setlocale(LC_ALL, NULL);
+
+                // finally, try to initialize GStreamer!
+                GError *err = NULL;
+                gboolean init_gst_success = llgst_init_check(NULL, NULL, &err);
+
+                // restore old locale
+                setlocale(LC_ALL, saved_locale.c_str() );
+
+#if LL_LINUX
+                // restore old SIGCHLD handler
+                if (!llgst_registry_fork_set_enabled)
+                        sigaction(SIGCHLD, &oldact, NULL);
+#endif // LL_LINUX
+
+                if (!init_gst_success) // fail
+                {
+                        if (err)
+                        {
+                                WARNMSG("GST init failed: %s", err->message);
+                                g_error_free(err);
+                        }
+                        else
+                        {
+                                WARNMSG("GST init failed for unspecified reason.");
+                        }
+                        return false;
+                }
+                
+                // Init our custom plugins - only really need do this once.
+                gst_slvideo_init_class();
+
+                mDoneInit = true;
+        }
+
+        return true;
+}
+
+
+bool
+MediaPluginGStreamer010::sizeChanged()
+{
+        // the shared writing space has possibly changed size/location/whatever
+
+        // Check to see whether the movie's natural size has updated
+        if (mNaturalWidth != mPreviousNaturalWidth ||
+            mNaturalHeight != mPreviousNaturalHeight)
+        {
+                mPreviousNaturalWidth = mNaturalWidth;
+                mPreviousNaturalHeight = mNaturalHeight;
+
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_request");
+                message.setValue("name", mTextureSegmentName);
+                message.setValueS32("width", mNaturalWidth);
+                message.setValueS32("height", mNaturalHeight);
+                DEBUGMSG("<--- Sending size change request to application with name: '%s' - size is %d x %d", mTextureSegmentName.c_str(), mNaturalWidth, mNaturalHeight);
+                sendMessage(message);
+        }
+        
+        return true;
+}
+
+
+
+//static
+bool
+MediaPluginGStreamer010::closedown()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        ungrab_gst_syms();
+
+        mDoneInit = false;
+
+        return true;
+}
+
+MediaPluginGStreamer010::~MediaPluginGStreamer010()
+{
+        DEBUGMSG("MediaPluginGStreamer010 destructor");
+
+        closedown();
+
+        DEBUGMSG("GStreamer010 closing down");
+}
+
+
+std::string
+MediaPluginGStreamer010::getVersion()
+{
+        std::string plugin_version = "GStreamer010 media plugin, GStreamer version ";
+        if (mDoneInit &&
+            llgst_version)
+        {
+                guint major, minor, micro, nano;
+                llgst_version(&major, &minor, &micro, &nano);
+                plugin_version += llformat("%u.%u.%u.%u (runtime), %u.%u.%u.%u (headers)", (unsigned int)major, (unsigned int)minor, (unsigned int)micro, (unsigned int)nano, (unsigned int)GST_VERSION_MAJOR, (unsigned int)GST_VERSION_MINOR, (unsigned int)GST_VERSION_MICRO, (unsigned int)GST_VERSION_NANO);
+        }
+        else
+        {
+                plugin_version += "(unknown)";
+        }
+        return plugin_version;
+}
+
+void MediaPluginGStreamer010::receiveMessage(const char *message_string)
+{
+        //std::cerr << "MediaPluginGStreamer010::receiveMessage: received message: \"" << message_string << "\"" << std::endl;
+
+        LLPluginMessage message_in;
+
+        if(message_in.parse(message_string) >= 0)
+        {
+                std::string message_class = message_in.getClass();
+                std::string message_name = message_in.getName();
+                if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
+                {
+                        if(message_name == "init")
+                        {
+                                LLPluginMessage message("base", "init_response");
+                                LLSD versions = LLSD::emptyMap();
+                                versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
+                                message.setValueLLSD("versions", versions);
+
+                                if ( load() )
+                                {
+                                        DEBUGMSG("GStreamer010 media instance set up");
+                                }
+                                else
+                                {
+                                        WARNMSG("GStreamer010 media instance failed to set up");
+                                }
+
+                                message.setValue("plugin_version", getVersion());
+                                sendMessage(message);
+
+                                // Plugin gets to decide the texture parameters to use.
+                                message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+                                // lame to have to decide this now, it depends on the movie.  Oh well.
+                                mDepth = 4;
+
+                                mNaturalWidth = 1;
+                                mNaturalHeight = 1;
+                                mPreviousNaturalWidth = 1;
+                                mPreviousNaturalHeight = 1;
+                                mWidth = 1;
+                                mHeight = 1;
+                                mTextureWidth = 1;
+                                mTextureHeight = 1;
+
+                                message.setValueU32("format", GL_RGBA);
+                                message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8_REV);
+
+                                message.setValueS32("depth", mDepth);
+                                message.setValueS32("default_width", mWidth);
+                                message.setValueS32("default_height", mHeight);
+                                message.setValueU32("internalformat", GL_RGBA8);
+                                message.setValueBoolean("coords_opengl", true); // true == use OpenGL-style coordinates, false == (0,0) is upper left.
+                                message.setValueBoolean("allow_downsample", true); // we respond with grace and performance if asked to downscale
+                                sendMessage(message);
+                        }
+                        else if(message_name == "idle")
+                        {
+                                // no response is necessary here.
+                                double time = message_in.getValueReal("time");
+                                
+                                // Convert time to milliseconds for update()
+                                update((int)(time * 1000.0f));
+                        }
+                        else if(message_name == "cleanup")
+                        {
+                                unload();
+                                closedown();
+                        }
+                        else if(message_name == "shm_added")
+                        {
+                                SharedSegmentInfo info;
+                                info.mAddress = message_in.getValuePointer("address");
+                                info.mSize = (size_t)message_in.getValueS32("size");
+                                std::string name = message_in.getValue("name");
+
+                                std::ostringstream str;
+                                INFOMSG("MediaPluginGStreamer010::receiveMessage: shared memory added, name: %s, size: %d, address: %p", name.c_str(), int(info.mSize), info.mAddress);
+
+                                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::string name = message_in.getValue("name");
+
+                                DEBUGMSG("MediaPluginGStreamer010::receiveMessage: shared memory remove, name = %s", name.c_str());
+                                
+                                SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+                                if(iter != mSharedSegments.end())
+                                {
+                                        if(mPixels == iter->second.mAddress)
+                                        {
+                                                // This is the currently active pixel buffer.  Make sure we stop drawing to it.
+                                                mPixels = NULL;
+                                                mTextureSegmentName.clear();
+                                                
+                                                // Make sure the movie decoder is no longer pointed at the shared segment.
+                                                sizeChanged();                                          
+                                        }
+                                        mSharedSegments.erase(iter);
+                                }
+                                else
+                                {
+                                        WARNMSG("MediaPluginGStreamer010::receiveMessage: unknown shared memory region!");
+                                }
+
+                                // Send the response so it can be cleaned up.
+                                LLPluginMessage message("base", "shm_remove_response");
+                                message.setValue("name", name);
+                                sendMessage(message);
+                        }
+                        else
+                        {
+                                std::ostringstream str;
+                                INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown base message: %s", message_name.c_str());
+                        }
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
+                {
+                        if(message_name == "size_change")
+                        {
+                                std::string name = message_in.getValue("name");
+                                S32 width = message_in.getValueS32("width");
+                                S32 height = message_in.getValueS32("height");
+                                S32 texture_width = message_in.getValueS32("texture_width");
+                                S32 texture_height = message_in.getValueS32("texture_height");
+
+                                std::ostringstream str;
+                                INFOMSG("---->Got size change instruction from application with shm name: %s - size is %d x %d", name.c_str(), width, height);
+
+                                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
+                                message.setValue("name", name);
+                                message.setValueS32("width", width);
+                                message.setValueS32("height", height);
+                                message.setValueS32("texture_width", texture_width);
+                                message.setValueS32("texture_height", texture_height);
+                                sendMessage(message);
+
+                                if(!name.empty())
+                                {
+                                        // Find the shared memory region with this name
+                                        SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+                                        if(iter != mSharedSegments.end())
+                                        {
+                                                INFOMSG("*** Got size change with matching shm, new size is %d x %d", width, height);
+                                                INFOMSG("*** Got size change with matching shm, texture size size is %d x %d", texture_width, texture_height);
+
+                                                mPixels = (unsigned char*)iter->second.mAddress;
+                                                mTextureSegmentName = name;
+                                                mWidth = width;
+                                                mHeight = height;
+
+                                                if (texture_width > 1 ||
+                                                    texture_height > 1) // not a dummy size from the app, a real explicit forced size
+                                                {
+                                                        INFOMSG("**** = REAL RESIZE REQUEST FROM APP");
+                                                        
+                                                        GST_OBJECT_LOCK(mVideoSink);
+                                                        mVideoSink->resize_forced = true;
+                                                        mVideoSink->resize_try_width = texture_width;
+                                                        mVideoSink->resize_try_height = texture_height;
+                                                        GST_OBJECT_UNLOCK(mVideoSink);
+                                                }
+
+                                                mTextureWidth = texture_width;
+                                                mTextureHeight = texture_height;
+                                        }
+                                }
+                        }
+                        else if(message_name == "load_uri")
+                        {
+                                std::string uri = message_in.getValue("uri");
+                                navigateTo( uri );
+                                sendStatus();           
+                        }
+                        else if(message_name == "mouse_event")
+                        {
+                                std::string event = message_in.getValue("event");
+                                S32 x = message_in.getValueS32("x");
+                                S32 y = message_in.getValueS32("y");
+                                
+                                if(event == "down")
+                                {
+                                        mouseDown(x, y);
+                                }
+                                else if(event == "up")
+                                {
+                                        mouseUp(x, y);
+                                }
+                                else if(event == "move")
+                                {
+                                        mouseMove(x, y);
+                                };
+                        };
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
+                {
+                        if(message_name == "stop")
+                        {
+                                stop();
+                        }
+                        else if(message_name == "start")
+                        {
+                                double rate = 0.0;
+                                if(message_in.hasValue("rate"))
+                                {
+                                        rate = message_in.getValueReal("rate");
+                                }
+                                // NOTE: we don't actually support rate.
+                                play(rate);
+                        }
+                        else if(message_name == "pause")
+                        {
+                                pause();
+                        }
+                        else if(message_name == "seek")
+                        {
+                                double time = message_in.getValueReal("time");
+                                // defer the actual seek in case we haven't
+                                // really truly started yet in which case there
+                                // is nothing to seek upon
+                                mSeekWanted = true;
+                                mSeekDestination = time;
+                        }
+                        else if(message_name == "set_loop")
+                        {
+                                bool loop = message_in.getValueBoolean("loop");
+                                mIsLooping = loop;
+                        }
+                        else if(message_name == "set_volume")
+                        {
+                                double volume = message_in.getValueReal("volume");
+                                setVolume(volume);
+                        }
+                }
+                else
+                {
+                        INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown message class: %s", message_class.c_str());
+                }
+        }
+}
+
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        if (MediaPluginGStreamer010::startup())
+        {
+                MediaPluginGStreamer010 *self = new MediaPluginGStreamer010(host_send_func, host_user_data);
+                *plugin_send_func = MediaPluginGStreamer010::staticReceiveMessage;
+                *plugin_user_data = (void*)self;
+                
+                return 0; // okay
+        }
+        else 
+        {
+                return -1; // failed to init
+        }
+}
+
+#else // LL_GSTREAMER010_ENABLED
+
+// Stubbed-out class with constructor/destructor (necessary or windows linker
+// will just think its dead code and optimize it all out)
+class MediaPluginGStreamer010 : public MediaPluginBase
+{
+public:
+        MediaPluginGStreamer010(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~MediaPluginGStreamer010();
+        /* virtual */ void receiveMessage(const char *message_string);
+};
+
+MediaPluginGStreamer010::MediaPluginGStreamer010(
+        LLPluginInstance::sendMessageFunction host_send_func,
+        void *host_user_data ) :
+        MediaPluginBase(host_send_func, host_user_data)
+{
+    // no-op
+}
+
+MediaPluginGStreamer010::~MediaPluginGStreamer010()
+{
+    // no-op
+}
+
+void MediaPluginGStreamer010::receiveMessage(const char *message_string)
+{
+    // no-op 
+}
+
+// We're building without GStreamer enabled.  Just refuse to initialize.
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+    return -1;
+}
+
+#endif // LL_GSTREAMER010_ENABLED
diff --git a/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp~ b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp~
new file mode 100755
index 0000000..7d34a1e
--- /dev/null
+++ b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp~
@@ -0,0 +1,1219 @@
+/** 
+ * @file media_plugin_gstreamer010.cpp
+ * @brief GStreamer-0.10 plugin for LLMedia API plugin system
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#include "linden_common.h"
+
+#include "llgl.h"
+
+#include "llplugininstance.h"
+#include "llpluginmessage.h"
+#include "llpluginmessageclasses.h"
+#include "media_plugin_base.h"
+
+#if LL_GSTREAMER010_ENABLED
+
+extern "C" {
+#include <gst/gst.h>
+}
+
+#include "llmediaimplgstreamer.h"
+#include "llmediaimplgstreamertriviallogging.h"
+
+#include "llmediaimplgstreamervidplug.h"
+
+#include "llmediaimplgstreamer_syms.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//
+class MediaPluginGStreamer010 : public MediaPluginBase
+{
+public:
+        MediaPluginGStreamer010(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~MediaPluginGStreamer010();
+
+        /* virtual */ void receiveMessage(const char *message_string);
+
+        static bool startup();
+        static bool closedown();
+
+        gboolean processGSTEvents(GstBus     *bus,
+                                  GstMessage *message);
+
+private:
+        std::string getVersion();
+        bool navigateTo( const std::string urlIn );
+        bool seek( double time_sec );
+        bool setVolume( float volume );
+        
+        // misc
+        bool pause();
+        bool stop();
+        bool play(double rate);
+        bool getTimePos(double &sec_out);
+
+        static const double MIN_LOOP_SEC = 1.0F;
+
+        bool mIsLooping;
+
+        enum ECommand {
+                COMMAND_NONE,
+                COMMAND_STOP,
+                COMMAND_PLAY,
+                COMMAND_FAST_FORWARD,
+                COMMAND_FAST_REWIND,
+                COMMAND_PAUSE,
+                COMMAND_SEEK,
+        };
+        ECommand mCommand;
+
+private:
+        bool unload();
+        bool load();
+
+        bool update(int milliseconds);
+        void mouseDown( int x, int y );
+        void mouseUp( int x, int y );
+        void mouseMove( int x, int y );
+
+        void sizeChanged();
+        
+        static bool mDoneInit;
+        
+        guint mBusWatchID;
+        
+        float mVolume;
+
+        int mDepth;
+
+        // media NATURAL size
+        int mNaturalWidth;
+        int mNaturalHeight;
+        // media current size
+        int mCurrentWidth;
+        int mCurrentHeight;
+        int mCurrentRowbytes;
+          // previous media size so we can detect changes
+          int mPreviousWidth;
+          int mPreviousHeight;
+        // desired render size from host
+        int mWidth;
+        int mHeight;
+        // padded texture size we need to write into
+        int mTextureWidth;
+        int mTextureHeight;
+        
+        int mTextureFormatPrimary;
+        int mTextureFormatType;
+
+        bool mSeekWanted;
+        double mSeekDestination;
+        
+        // Very GStreamer-specific
+        GMainLoop *mPump; // event pump for this media
+        GstElement *mPlaybin;
+        GstSLVideo *mVideoSink;
+};
+
+//static
+bool MediaPluginGStreamer010::mDoneInit = false;
+
+MediaPluginGStreamer010::MediaPluginGStreamer010(
+        LLPluginInstance::sendMessageFunction host_send_func,
+        void *host_user_data ) :
+        MediaPluginBase(host_send_func, host_user_data),
+        mBusWatchID ( 0 ),
+        mCurrentRowbytes ( 4 ),
+        mTextureFormatPrimary ( GL_RGBA ),
+        mTextureFormatType ( GL_UNSIGNED_INT_8_8_8_8_REV ),
+        mSeekWanted(false),
+        mSeekDestination(0.0),
+        mPump ( NULL ),
+        mPlaybin ( NULL ),
+        mVideoSink ( NULL ),
+        mCommand ( COMMAND_NONE )
+{
+        std::ostringstream str;
+        INFOMSG("MediaPluginGStreamer010 constructor - my PID=%u", U32(getpid()));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//#define LL_GST_REPORT_STATE_CHANGES
+#ifdef LL_GST_REPORT_STATE_CHANGES
+static char* get_gst_state_name(GstState state)
+{
+        switch (state) {
+        case GST_STATE_VOID_PENDING: return "VOID_PENDING";
+        case GST_STATE_NULL: return "NULL";
+        case GST_STATE_READY: return "READY";
+        case GST_STATE_PAUSED: return "PAUSED";
+        case GST_STATE_PLAYING: return "PLAYING";
+        }
+        return "(unknown)";
+}
+#endif // LL_GST_REPORT_STATE_CHANGES
+
+gboolean
+MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
+                                          GstMessage *message)
+{
+        if (!message) 
+                return TRUE; // shield against GStreamer bug
+
+        if (GST_MESSAGE_TYPE(message) != GST_MESSAGE_STATE_CHANGED &&
+            GST_MESSAGE_TYPE(message) != GST_MESSAGE_BUFFERING)
+        {
+                DEBUGMSG("Got GST message type: %s",
+                        LLGST_MESSAGE_TYPE_NAME (message));
+        }
+        else
+        {
+                // TODO: grok 'duration' message type
+                DEBUGMSG("Got GST message type: %s",
+                         LLGST_MESSAGE_TYPE_NAME (message));
+        }
+
+        switch (GST_MESSAGE_TYPE (message)) {
+        case GST_MESSAGE_BUFFERING: {
+                // NEEDS GST 0.10.11+
+                if (llgst_message_parse_buffering)
+                {
+                        gint percent = 0;
+                        llgst_message_parse_buffering(message, &percent);
+                        DEBUGMSG("GST buffering: %d%%", percent);
+                }
+                break;
+        }
+        case GST_MESSAGE_STATE_CHANGED: {
+                GstState old_state;
+                GstState new_state;
+                GstState pending_state;
+                llgst_message_parse_state_changed(message,
+                                                &old_state,
+                                                &new_state,
+                                                &pending_state);
+#ifdef LL_GST_REPORT_STATE_CHANGES
+                // not generally very useful, and rather spammy.
+                DEBUGMSG("state change (old,<new>,pending): %s,<%s>,%s",
+                         get_gst_state_name(old_state),
+                         get_gst_state_name(new_state),
+                         get_gst_state_name(pending_state));
+#endif // LL_GST_REPORT_STATE_CHANGES
+
+                switch (new_state) {
+                case GST_STATE_VOID_PENDING:
+                        break;
+                case GST_STATE_NULL:
+                        break;
+                case GST_STATE_READY:
+                        setStatus(STATUS_LOADED);
+                        break;
+                case GST_STATE_PAUSED:
+                        setStatus(STATUS_PAUSED);
+                        break;
+                case GST_STATE_PLAYING:
+                        setStatus(STATUS_PLAYING);
+                        break;
+                }
+                break;
+        }
+        case GST_MESSAGE_ERROR: {
+                GError *err = NULL;
+                gchar *debug = NULL;
+
+                llgst_message_parse_error (message, &err, &debug);
+                WARNMSG("GST error: %s", err?err->message:"(unknown)");
+                if (err)
+                        g_error_free (err);
+                g_free (debug);
+
+                mCommand = COMMAND_STOP;
+
+                setStatus(STATUS_ERROR);
+
+                break;
+        }
+        case GST_MESSAGE_INFO: {
+                if (llgst_message_parse_info)
+                {
+                        GError *err = NULL;
+                        gchar *debug = NULL;
+                        
+                        llgst_message_parse_info (message, &err, &debug);
+                        INFOMSG("GST info: %s", err?err->message:"(unknown)");
+                        if (err)
+                                g_error_free (err);
+                        g_free (debug);
+                }
+                break;
+        }
+        case GST_MESSAGE_WARNING: {
+                GError *err = NULL;
+                gchar *debug = NULL;
+
+                llgst_message_parse_warning (message, &err, &debug);
+                WARNMSG("GST warning: %s", err?err->message:"(unknown)");
+                if (err)
+                        g_error_free (err);
+                g_free (debug);
+
+                break;
+        }
+        case GST_MESSAGE_EOS:
+                /* end-of-stream */
+                DEBUGMSG("GST end-of-stream.");
+                if (mIsLooping)
+                {
+                        DEBUGMSG("looping media...");
+                        double eos_pos_sec = 0.0F;
+                        bool got_eos_position = getTimePos(eos_pos_sec);
+
+                        if (got_eos_position && eos_pos_sec < MIN_LOOP_SEC)
+                        {
+                                // if we know that the movie is really short, don't
+                                // loop it else it can easily become a time-hog
+                                // because of GStreamer spin-up overhead
+                                DEBUGMSG("really short movie (%0.3fsec) - not gonna loop this, pausing instead.", eos_pos_sec);
+                                // inject a COMMAND_PAUSE
+                                mCommand = COMMAND_PAUSE;
+                        }
+                        else
+                        {
+#undef LLGST_LOOP_BY_SEEKING
+// loop with a stop-start instead of a seek, because it actually seems rather
+// faster than seeking on remote streams.
+#ifdef LLGST_LOOP_BY_SEEKING
+                                // first, try looping by an explicit rewind
+                                bool seeksuccess = seek(0.0);
+                                if (seeksuccess)
+                                {
+                                        play(1.0);
+                                }
+                                else
+#endif // LLGST_LOOP_BY_SEEKING
+                                {  // use clumsy stop-start to loop
+                                        DEBUGMSG("didn't loop by rewinding - stopping and starting instead...");
+                                        stop();
+                                        play(1.0);
+                                }
+                        }
+                }
+                else // not a looping media
+                {
+                        // inject a COMMAND_STOP
+                        mCommand = COMMAND_STOP;
+                }
+                break;
+        default:
+                /* unhandled message */
+                break;
+        }
+
+        /* we want to be notified again the next time there is a message
+         * on the bus, so return true (false means we want to stop watching
+         * for messages on the bus and our callback should not be called again)
+         */
+        return TRUE;
+}
+
+extern "C" {
+gboolean
+llmediaimplgstreamer_bus_callback (GstBus     *bus,
+                                   GstMessage *message,
+                                   gpointer    data)
+{
+        MediaPluginGStreamer010 *impl = (MediaPluginGStreamer010*)data;
+        return impl->processGSTEvents(bus, message);
+}
+} // extern "C"
+
+
+
+bool
+MediaPluginGStreamer010::navigateTo ( const std::string urlIn )
+{
+        if (!mDoneInit)
+                return false; // error
+
+        setStatus(STATUS_LOADING);
+
+        DEBUGMSG("Setting media URI: %s", urlIn.c_str());
+
+        mSeekWanted = false;
+
+        if (NULL == mPump ||
+            NULL == mPlaybin)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // set URI
+        g_object_set (G_OBJECT (mPlaybin), "uri", urlIn.c_str(), NULL);
+        //g_object_set (G_OBJECT (mPlaybin), "uri", "file:///tmp/movie", NULL);
+
+        // navigateTo implicitly plays, too.
+        play(1.0);
+
+        return true;
+}
+
+
+bool
+MediaPluginGStreamer010::update(int milliseconds)
+{
+        if (!mDoneInit)
+                return false; // error
+
+        DEBUGMSG("updating media...");
+        
+        // sanity check
+        if (NULL == mPump ||
+            NULL == mPlaybin)
+        {
+                DEBUGMSG("dead media...");
+                return false;
+        }
+
+        // see if there's an outstanding seek wanted
+        if (mSeekWanted &&
+            // bleh, GST has to be happy that the movie is really truly playing
+            // or it may quietly ignore the seek (with rtsp:// at least).
+            (GST_STATE(mPlaybin) == GST_STATE_PLAYING))
+        {
+                seek(mSeekDestination);
+                mSeekWanted = false;
+        }
+
+        // *TODO: time-limit - but there isn't a lot we can do here, most
+        // time is spent in gstreamer's own opaque worker-threads.  maybe
+        // we can do something sneaky like only unlock the video object
+        // for 'milliseconds' and otherwise hold the lock.
+        while (g_main_context_pending(g_main_loop_get_context(mPump)))
+        {
+               g_main_context_iteration(g_main_loop_get_context(mPump), FALSE);
+        }
+
+        // check for availability of a new frame
+        
+        if (mVideoSink)
+        {
+                GST_OBJECT_LOCK(mVideoSink);
+                if (mVideoSink->retained_frame_ready)
+                {
+                        DEBUGMSG("NEW FRAME READY");
+
+                        if (mVideoSink->retained_frame_width != mCurrentWidth ||
+                            mVideoSink->retained_frame_height != mCurrentHeight)
+                                // *TODO: also check for change in format
+                        {
+                                // just resize container, don't consume frame
+                                int neww = mVideoSink->retained_frame_width;
+                                int newh = mVideoSink->retained_frame_height;
+
+                                int newd = 4;
+                                mTextureFormatPrimary = GL_RGBA;
+                                mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+
+                                /*
+                                int newd = SLVPixelFormatBytes[mVideoSink->retained_frame_format];
+                                if (SLV_PF_BGRX == mVideoSink->retained_frame_format)
+                                {
+                                        mTextureFormatPrimary = GL_BGRA;
+                                        mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+                                }
+                                else
+                                {
+                                        mTextureFormatPrimary = GL_RGBA;
+                                        mTextureFormatType = GL_UNSIGNED_INT_8_8_8_8_REV;
+                                }
+                                */
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+
+                                mCurrentRowbytes = neww * newd;
+                                DEBUGMSG("video container resized to %dx%d",
+                                         neww, newh);
+
+                                mDepth = newd;
+                                mCurrentWidth = neww;
+                                mCurrentHeight = newh;
+                                sizeChanged();
+                                return true;
+                        }
+
+                        if (mPixels &&
+                            mCurrentHeight <= mHeight &&
+                            mCurrentWidth <= mWidth &&
+                            !mTextureSegmentName.empty())
+                        {
+                                // we're gonna totally consume this frame - reset 'ready' flag
+                                mVideoSink->retained_frame_ready = FALSE;
+                                int destination_rowbytes = mWidth * mDepth;
+                                for (int row=0; row<mCurrentHeight; ++row)
+                                {
+                                        memcpy(&mPixels
+                                                [destination_rowbytes * row],
+                                               &mVideoSink->retained_frame_data
+                                                [mCurrentRowbytes * row],
+                                               mCurrentRowbytes);
+                                }
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+                                DEBUGMSG("NEW FRAME REALLY TRULY CONSUMED, TELLING HOST");
+
+                                setDirty(0,0,mCurrentWidth,mCurrentHeight);
+                        }
+                        else
+                        {
+                                // new frame ready, but we're not ready to
+                                // consume it.
+
+                                GST_OBJECT_UNLOCK(mVideoSink);
+
+                                DEBUGMSG("NEW FRAME not consumed, still waiting for a shm segment and/or shm resize");
+                        }
+
+                        return true;
+                }
+                else
+                {
+                        // nothing to do yet.
+                        GST_OBJECT_UNLOCK(mVideoSink);
+                        return true;
+                }
+        }
+
+        return true;
+}
+
+
+void
+MediaPluginGStreamer010::mouseDown( int x, int y )
+{
+  // do nothing
+}
+
+void
+MediaPluginGStreamer010::mouseUp( int x, int y )
+{
+  // do nothing
+}
+
+void
+MediaPluginGStreamer010::mouseMove( int x, int y )
+{
+  // do nothing
+}
+
+
+bool
+MediaPluginGStreamer010::pause()
+{
+        DEBUGMSG("pausing media...");
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_PAUSED);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::stop()
+{
+        DEBUGMSG("stopping media...");
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_READY);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::play(double rate)
+{
+        // NOTE: we don't actually support non-natural rate.
+
+        DEBUGMSG("playing media... rate=%f", rate);
+        // todo: error-check this?
+        llgst_element_set_state(mPlaybin, GST_STATE_PLAYING);
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::setVolume( float volume )
+{
+        // we try to only update volume as conservatively as
+        // possible, as many gst-plugins-base versions up to at least
+        // November 2008 have critical race-conditions in setting volume - sigh
+        if (mVolume == volume)
+                return true; // nothing to do, everything's fine
+
+        mVolume = volume;
+        if (mDoneInit && mPlaybin)
+        {
+                g_object_set(mPlaybin, "volume", mVolume, NULL);
+                return true;
+        }
+
+        return false;
+}
+
+bool
+MediaPluginGStreamer010::seek(double time_sec)
+{
+        bool success = false;
+        if (mDoneInit && mPlaybin)
+        {
+                success = llgst_element_seek(mPlaybin, 1.0F, GST_FORMAT_TIME,
+                                GstSeekFlags(GST_SEEK_FLAG_FLUSH |
+                                             GST_SEEK_FLAG_KEY_UNIT),
+                                GST_SEEK_TYPE_SET, gint64(time_sec*GST_SECOND),
+                                GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+        }
+        DEBUGMSG("MEDIA SEEK REQUEST to %fsec result was %d",
+                 float(time_sec), int(success));
+        return success;
+}
+
+bool
+MediaPluginGStreamer010::getTimePos(double &sec_out)
+{
+        bool got_position = false;
+        if (mPlaybin)
+        {
+                gint64 pos;
+                GstFormat timefmt = GST_FORMAT_TIME;
+                got_position =
+                        llgst_element_query_position &&
+                        llgst_element_query_position(mPlaybin,
+                                                     &timefmt,
+                                                     &pos);
+                got_position = got_position
+                        && (timefmt == GST_FORMAT_TIME);
+                // GStreamer may have other ideas, but we consider the current position
+                // undefined if not PLAYING or PAUSED
+                got_position = got_position &&
+                        (GST_STATE(mPlaybin) == GST_STATE_PLAYING ||
+                         GST_STATE(mPlaybin) == GST_STATE_PAUSED);
+                if (got_position && !GST_CLOCK_TIME_IS_VALID(pos))
+                {
+                        if (GST_STATE(mPlaybin) == GST_STATE_PLAYING)
+                        {
+                                // if we're playing then we treat an invalid clock time
+                                // as 0, for complicated reasons (insert reason here)
+                                pos = 0;
+                        }
+                        else
+                        {
+                                got_position = false;
+                        }
+                        
+                }
+                // If all the preconditions succeeded... we can trust the result.
+                if (got_position)
+                {
+                        sec_out = double(pos) / double(GST_SECOND); // gst to sec
+                }
+        }
+        return got_position;
+}
+
+bool
+MediaPluginGStreamer010::load()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        setStatus(STATUS_LOADING);
+
+        DEBUGMSG("setting up media...");
+
+        mIsLooping = false;
+        mVolume = 0.1234567; // minor hack to force an initial volume update
+
+        // Create a pumpable main-loop for this media
+        mPump = g_main_loop_new (NULL, FALSE);
+        if (!mPump)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // instantiate a playbin element to do the hard work
+        mPlaybin = llgst_element_factory_make ("playbin", "play");
+        if (!mPlaybin)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+
+        // get playbin's bus
+        GstBus *bus = llgst_pipeline_get_bus (GST_PIPELINE (mPlaybin));
+        if (!bus)
+        {
+                setStatus(STATUS_ERROR);
+                return false; // error
+        }
+        mBusWatchID = llgst_bus_add_watch (bus,
+                                           llmediaimplgstreamer_bus_callback,
+                                           this);
+        llgst_object_unref (bus);
+
+        if (NULL == getenv("LL_GSTREAMER_EXTERNAL")) {
+                // instantiate a custom video sink
+                mVideoSink =
+                        GST_SLVIDEO(llgst_element_factory_make ("private-slvideo", "slvideo"));
+                if (!mVideoSink)
+                {
+                        WARNMSG("Could not instantiate private-slvideo element.");
+                        // todo: cleanup.
+                        setStatus(STATUS_ERROR);
+                        return false; // error
+                }
+
+                // connect the pieces
+                g_object_set(mPlaybin, "video-sink", mVideoSink, NULL);
+        }
+
+        return true;
+}
+
+bool
+MediaPluginGStreamer010::unload ()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        DEBUGMSG("unloading media...");
+        
+        // stop getting callbacks for this bus
+        g_source_remove(mBusWatchID);
+        mBusWatchID = 0;
+
+        if (mPlaybin)
+        {
+                llgst_element_set_state (mPlaybin, GST_STATE_NULL);
+                llgst_object_unref (GST_OBJECT (mPlaybin));
+                mPlaybin = NULL;
+        }
+
+        if (mPump)
+        {
+                g_main_loop_quit(mPump);
+                mPump = NULL;
+        }
+
+        mVideoSink = NULL;
+
+        setStatus(STATUS_NONE);
+
+        return true;
+}
+
+
+//static
+bool
+MediaPluginGStreamer010::startup()
+{
+        // first - check if GStreamer is explicitly disabled
+        if (NULL != getenv("LL_DISABLE_GSTREAMER"))
+                return false;
+
+        // only do global GStreamer initialization once.
+        if (!mDoneInit)
+        {
+                g_thread_init(NULL);
+
+                // Init the glib type system - we need it.
+                g_type_init();
+
+                // Get symbols!
+#if LL_DARWIN
+                if (! grab_gst_syms("libgstreamer-0.10.dylib",
+                                    "libgstvideo-0.10.dylib") )
+#elseif LL_WINDOWS
+                if (! grab_gst_syms("libgstreamer-0.10.dll",
+                                    "libgstvideo-0.10.dll") )
+#else // linux or other ELFy unixoid
+                if (! grab_gst_syms("libgstreamer-0.10.so.0",
+                                    "libgstvideo-0.10.so.0") )
+#endif
+                {
+                        WARNMSG("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled.");
+                        return false;
+                }
+
+                if (llgst_segtrap_set_enabled)
+                {
+                        llgst_segtrap_set_enabled(FALSE);
+                }
+                else
+                {
+                        WARNMSG("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught.");
+                }
+
+#if LL_LINUX
+                // Gstreamer tries a fork during init, waitpid-ing on it,
+                // which conflicts with any installed SIGCHLD handler...
+                struct sigaction tmpact, oldact;
+                if (llgst_registry_fork_set_enabled) {
+                        // if we can disable SIGCHLD-using forking behaviour,
+                        // do it.
+                        llgst_registry_fork_set_enabled(false);
+                }
+                else {
+                        // else temporarily install default SIGCHLD handler
+                        // while GStreamer initialises
+                        tmpact.sa_handler = SIG_DFL;
+                        sigemptyset( &tmpact.sa_mask );
+                        tmpact.sa_flags = SA_SIGINFO;
+                        sigaction(SIGCHLD, &tmpact, &oldact);
+                }
+#endif // LL_LINUX
+
+                // Protect against GStreamer resetting the locale, yuck.
+                static std::string saved_locale;
+                saved_locale = setlocale(LC_ALL, NULL);
+
+                // finally, try to initialize GStreamer!
+                GError *err = NULL;
+                gboolean init_gst_success = llgst_init_check(NULL, NULL, &err);
+
+                // restore old locale
+                setlocale(LC_ALL, saved_locale.c_str() );
+
+#if LL_LINUX
+                // restore old SIGCHLD handler
+                if (!llgst_registry_fork_set_enabled)
+                        sigaction(SIGCHLD, &oldact, NULL);
+#endif // LL_LINUX
+
+                if (!init_gst_success) // fail
+                {
+                        if (err)
+                        {
+                                WARNMSG("GST init failed: %s", err->message);
+                                g_error_free(err);
+                        }
+                        else
+                        {
+                                WARNMSG("GST init failed for unspecified reason.");
+                        }
+                        return false;
+                }
+                
+                // Init our custom plugins - only really need do this once.
+                gst_slvideo_init_class();
+
+                mDoneInit = true;
+        }
+
+        return true;
+}
+
+
+void
+MediaPluginGStreamer010::sizeChanged()
+{
+        // the shared writing space has possibly changed size/location/whatever
+
+        // Check to see whether the movie's NATURAL size has been set yet
+        if (1 == mNaturalWidth &&
+            1 == mNaturalHeight)
+        {
+                mNaturalWidth = mCurrentWidth;
+                mNaturalHeight = mCurrentHeight;
+                DEBUGMSG("Media NATURAL size better detected as %dx%d",
+                         mNaturalWidth, mNaturalHeight);
+        }
+
+        // if the size has changed then the shm has changed and the app needs telling
+        if (mCurrentWidth != mPreviousWidth ||
+            mCurrentHeight != mPreviousHeight)
+        {
+                mPreviousWidth = mCurrentWidth;
+                mPreviousHeight = mCurrentHeight;
+
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_request");
+                message.setValue("name", mTextureSegmentName);
+                message.setValueS32("width", mNaturalWidth);
+                message.setValueS32("height", mNaturalHeight);
+                DEBUGMSG("<--- Sending size change request to application with name: '%s' - natural size is %d x %d", mTextureSegmentName.c_str(), mNaturalWidth, mNaturalHeight);
+                sendMessage(message);
+        }
+}
+
+
+
+//static
+bool
+MediaPluginGStreamer010::closedown()
+{
+        if (!mDoneInit)
+                return false; // error
+
+        ungrab_gst_syms();
+
+        mDoneInit = false;
+
+        return true;
+}
+
+MediaPluginGStreamer010::~MediaPluginGStreamer010()
+{
+        DEBUGMSG("MediaPluginGStreamer010 destructor");
+
+        closedown();
+
+        DEBUGMSG("GStreamer010 closing down");
+}
+
+
+std::string
+MediaPluginGStreamer010::getVersion()
+{
+        std::string plugin_version = "GStreamer010 media plugin, GStreamer version ";
+        if (mDoneInit &&
+            llgst_version)
+        {
+                guint major, minor, micro, nano;
+                llgst_version(&major, &minor, &micro, &nano);
+                plugin_version += llformat("%u.%u.%u.%u (runtime), %u.%u.%u.%u (headers)", (unsigned int)major, (unsigned int)minor, (unsigned int)micro, (unsigned int)nano, (unsigned int)GST_VERSION_MAJOR, (unsigned int)GST_VERSION_MINOR, (unsigned int)GST_VERSION_MICRO, (unsigned int)GST_VERSION_NANO);
+        }
+        else
+        {
+                plugin_version += "(unknown)";
+        }
+        return plugin_version;
+}
+
+void MediaPluginGStreamer010::receiveMessage(const char *message_string)
+{
+        //std::cerr << "MediaPluginGStreamer010::receiveMessage: received message: \"" << message_string << "\"" << std::endl;
+
+        LLPluginMessage message_in;
+
+        if(message_in.parse(message_string) >= 0)
+        {
+                std::string message_class = message_in.getClass();
+                std::string message_name = message_in.getName();
+                if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
+                {
+                        if(message_name == "init")
+                        {
+                                LLPluginMessage message("base", "init_response");
+                                LLSD versions = LLSD::emptyMap();
+                                versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
+                                message.setValueLLSD("versions", versions);
+
+                                if ( load() )
+                                {
+                                        DEBUGMSG("GStreamer010 media instance set up");
+                                }
+                                else
+                                {
+                                        WARNMSG("GStreamer010 media instance failed to set up");
+                                }
+
+                                message.setValue("plugin_version", getVersion());
+                                sendMessage(message);
+                        }
+                        else if(message_name == "idle")
+                        {
+                                // no response is necessary here.
+                                double time = message_in.getValueReal("time");
+                                
+                                // Convert time to milliseconds for update()
+                                update((int)(time * 1000.0f));
+                        }
+                        else if(message_name == "cleanup")
+                        {
+                                unload();
+                                closedown();
+                        }
+                        else if(message_name == "shm_added")
+                        {
+                                SharedSegmentInfo info;
+                                info.mAddress = message_in.getValuePointer("address");
+                                info.mSize = (size_t)message_in.getValueS32("size");
+                                std::string name = message_in.getValue("name");
+
+                                std::ostringstream str;
+                                INFOMSG("MediaPluginGStreamer010::receiveMessage: shared memory added, name: %s, size: %d, address: %p", name.c_str(), int(info.mSize), info.mAddress);
+
+                                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::string name = message_in.getValue("name");
+
+                                DEBUGMSG("MediaPluginGStreamer010::receiveMessage: shared memory remove, name = %s", name.c_str());
+                                
+                                SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+                                if(iter != mSharedSegments.end())
+                                {
+                                        if(mPixels == iter->second.mAddress)
+                                        {
+                                                // This is the currently active pixel buffer.  Make sure we stop drawing to it.
+                                                mPixels = NULL;
+                                                mTextureSegmentName.clear();
+                                                
+                                                // Make sure the movie decoder is no longer pointed at the shared segment.
+                                                sizeChanged();                                          
+                                        }
+                                        mSharedSegments.erase(iter);
+                                }
+                                else
+                                {
+                                        WARNMSG("MediaPluginGStreamer010::receiveMessage: unknown shared memory region!");
+                                }
+
+                                // Send the response so it can be cleaned up.
+                                LLPluginMessage message("base", "shm_remove_response");
+                                message.setValue("name", name);
+                                sendMessage(message);
+                        }
+                        else
+                        {
+                                std::ostringstream str;
+                                INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown base message: %s", message_name.c_str());
+                        }
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
+                {
+                        if(message_name == "init")
+                        {
+                                // Plugin gets to decide the texture parameters to use.
+                                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+                                // lame to have to decide this now, it depends on the movie.  Oh well.
+                                mDepth = 4;
+
+                                mCurrentWidth = 1;
+                                mCurrentHeight = 1;
+                                mPreviousWidth = 1;
+                                mPreviousHeight = 1;
+                                mNaturalWidth = 1;
+                                mNaturalHeight = 1;
+                                mWidth = 1;
+                                mHeight = 1;
+                                mTextureWidth = 1;
+                                mTextureHeight = 1;
+
+                                message.setValueU32("format", GL_RGBA);
+                                message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8_REV);
+
+                                message.setValueS32("depth", mDepth);
+                                message.setValueS32("default_width", mWidth);
+                                message.setValueS32("default_height", mHeight);
+                                message.setValueU32("internalformat", GL_RGBA8);
+                                message.setValueBoolean("coords_opengl", true); // true == use OpenGL-style coordinates, false == (0,0) is upper left.
+                                message.setValueBoolean("allow_downsample", true); // we respond with grace and performance if asked to downscale
+                                sendMessage(message);
+                        }
+                        else if(message_name == "size_change")
+                        {
+                                std::string name = message_in.getValue("name");
+                                S32 width = message_in.getValueS32("width");
+                                S32 height = message_in.getValueS32("height");
+                                S32 texture_width = message_in.getValueS32("texture_width");
+                                S32 texture_height = message_in.getValueS32("texture_height");
+
+                                std::ostringstream str;
+                                INFOMSG("---->Got size change instruction from application with shm name: %s - size is %d x %d", name.c_str(), width, height);
+
+                                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
+                                message.setValue("name", name);
+                                message.setValueS32("width", width);
+                                message.setValueS32("height", height);
+                                message.setValueS32("texture_width", texture_width);
+                                message.setValueS32("texture_height", texture_height);
+                                sendMessage(message);
+
+                                if(!name.empty())
+                                {
+                                        // Find the shared memory region with this name
+                                        SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+                                        if(iter != mSharedSegments.end())
+                                        {
+                                                INFOMSG("*** Got size change with matching shm, new size is %d x %d", width, height);
+                                                INFOMSG("*** Got size change with matching shm, texture size size is %d x %d", texture_width, texture_height);
+
+                                                mPixels = (unsigned char*)iter->second.mAddress;
+                                                mTextureSegmentName = name;
+                                                mWidth = width;
+                                                mHeight = height;
+
+                                                if (texture_width > 1 ||
+                                                    texture_height > 1) // not a dummy size from the app, a real explicit forced size
+                                                {
+                                                        INFOMSG("**** = REAL RESIZE REQUEST FROM APP");
+                                                        
+                                                        GST_OBJECT_LOCK(mVideoSink);
+                                                        mVideoSink->resize_forced_always = true;
+                                                        mVideoSink->resize_try_width = texture_width;
+                                                        mVideoSink->resize_try_height = texture_height;
+                                                        GST_OBJECT_UNLOCK(mVideoSink);
+                                                }
+
+                                                mTextureWidth = texture_width;
+                                                mTextureHeight = texture_height;
+                                        }
+                                }
+                        }
+                        else if(message_name == "load_uri")
+                        {
+                                std::string uri = message_in.getValue("uri");
+                                navigateTo( uri );
+                                sendStatus();           
+                        }
+                        else if(message_name == "mouse_event")
+                        {
+                                std::string event = message_in.getValue("event");
+                                S32 x = message_in.getValueS32("x");
+                                S32 y = message_in.getValueS32("y");
+                                
+                                if(event == "down")
+                                {
+                                        mouseDown(x, y);
+                                }
+                                else if(event == "up")
+                                {
+                                        mouseUp(x, y);
+                                }
+                                else if(event == "move")
+                                {
+                                        mouseMove(x, y);
+                                };
+                        };
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
+                {
+                        if(message_name == "stop")
+                        {
+                                stop();
+                        }
+                        else if(message_name == "start")
+                        {
+                                double rate = 0.0;
+                                if(message_in.hasValue("rate"))
+                                {
+                                        rate = message_in.getValueReal("rate");
+                                }
+                                // NOTE: we don't actually support rate.
+                                play(rate);
+                        }
+                        else if(message_name == "pause")
+                        {
+                                pause();
+                        }
+                        else if(message_name == "seek")
+                        {
+                                double time = message_in.getValueReal("time");
+                                // defer the actual seek in case we haven't
+                                // really truly started yet in which case there
+                                // is nothing to seek upon
+                                mSeekWanted = true;
+                                mSeekDestination = time;
+                        }
+                        else if(message_name == "set_loop")
+                        {
+                                bool loop = message_in.getValueBoolean("loop");
+                                mIsLooping = loop;
+                        }
+                        else if(message_name == "set_volume")
+                        {
+                                double volume = message_in.getValueReal("volume");
+                                setVolume(volume);
+                        }
+                }
+                else
+                {
+                        INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown message class: %s", message_class.c_str());
+                }
+        }
+}
+
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        if (MediaPluginGStreamer010::startup())
+        {
+                MediaPluginGStreamer010 *self = new MediaPluginGStreamer010(host_send_func, host_user_data);
+                *plugin_send_func = MediaPluginGStreamer010::staticReceiveMessage;
+                *plugin_user_data = (void*)self;
+                
+                return 0; // okay
+        }
+        else 
+        {
+                return -1; // failed to init
+        }
+}
+
+#else // LL_GSTREAMER010_ENABLED
+
+// Stubbed-out class with constructor/destructor (necessary or windows linker
+// will just think its dead code and optimize it all out)
+class MediaPluginGStreamer010 : public MediaPluginBase
+{
+public:
+        MediaPluginGStreamer010(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~MediaPluginGStreamer010();
+        /* virtual */ void receiveMessage(const char *message_string);
+};
+
+MediaPluginGStreamer010::MediaPluginGStreamer010(
+        LLPluginInstance::sendMessageFunction host_send_func,
+        void *host_user_data ) :
+        MediaPluginBase(host_send_func, host_user_data)
+{
+    // no-op
+}
+
+MediaPluginGStreamer010::~MediaPluginGStreamer010()
+{
+    // no-op
+}
+
+void MediaPluginGStreamer010::receiveMessage(const char *message_string)
+{
+    // no-op 
+}
+
+// We're building without GStreamer enabled.  Just refuse to initialize.
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+    return -1;
+}
+
+#endif // LL_GSTREAMER010_ENABLED