llmediaplugins first step

12 files changed, 5319 insertions, 0 deletions

diff --git a/linden/indra/test_apps/llplugintest/CMakeLists.txt b/linden/indra/test_apps/llplugintest/CMakeLists.txt
new file mode 100644
index 0000000..a6cb740
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/CMakeLists.txt
@@ -0,0 +1,378 @@
+# -*- cmake -*-
+
+project(llplugintest)
+
+include(00-Common)
+include(FindOpenGL)
+include(LLCommon)
+include(LLPlugin)
+include(Linking)
+include(PluginAPI)
+include(LLImage)
+include(LLMath)
+include(LLMessage)
+include(LLRender)
+include(LLWindow)
+include(Glut)
+include(Glui)
+
+include_directories(
+    ${LLPLUGIN_INCLUDE_DIRS}
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LLIMAGE_INCLUDE_DIRS}
+    ${LLMATH_INCLUDE_DIRS}
+    ${LLMESSAGE_INCLUDE_DIRS}
+    ${LLRENDER_INCLUDE_DIRS}
+    ${LLWINDOW_INCLUDE_DIRS}
+)
+
+if (DARWIN)
+    include(CMakeFindFrameworks)
+    find_library(COREFOUNDATION_LIBRARY CoreFoundation)
+endif (DARWIN)
+
+### demo_plugin
+
+#set(demo_plugin_SOURCE_FILES
+#    demo_plugin.cpp
+#    )
+#
+#add_library(demo_plugin
+#    SHARED
+#    ${demo_plugin_SOURCE_FILES}
+#)
+#
+#target_link_libraries(demo_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(demo_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+#
+#if (DARWIN)
+#  # Don't prepend 'lib' to the executable name, and don't embed a full path in the library's install name
+#  set_target_properties(
+#    demo_plugin
+#    PROPERTIES
+#    PREFIX ""
+#    BUILD_WITH_INSTALL_RPATH 1
+#    INSTALL_NAME_DIR "@executable_path"
+#  )
+#endif (DARWIN)
+
+### plugin_host
+
+#set(plugin_host_SOURCE_FILES
+#    plugin_host.cpp
+#    )
+#
+#add_executable(plugin_host
+#    WIN32
+#    ${plugin_host_SOURCE_FILES}
+#)
+#
+#set_target_properties(plugin_host
+#    PROPERTIES
+#    WIN32_EXECUTABLE
+#    FALSE
+#)
+#
+#target_link_libraries(plugin_host
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(plugin_host
+#  demo_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+
+### plugin_process_launcher
+
+#set(plugin_process_launcher_SOURCE_FILES
+#    plugin_process_launcher.cpp
+#    )
+#
+#add_executable(plugin_process_launcher
+#    WIN32
+#    ${plugin_process_launcher_SOURCE_FILES}
+#)
+#
+#set_target_properties(plugin_process_launcher
+#    PROPERTIES
+#    WIN32_EXECUTABLE
+#    FALSE
+#)
+#
+#target_link_libraries(plugin_process_launcher
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLMESSAGE_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(plugin_process_launcher
+#  SLPlugin
+#  demo_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLMESSAGE_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+
+### media_simple_test
+
+#set(media_simple_test_SOURCE_FILES
+#    media_simple_test.cpp
+#    )
+#
+#add_executable(media_simple_test
+#    WIN32
+#    ${media_simple_test_SOURCE_FILES}
+#)
+#
+#add_dependencies(media_simple_test copy_win_libs)
+#
+#set_target_properties(media_simple_test
+#    PROPERTIES
+#    WIN32_EXECUTABLE
+#    FALSE
+#)
+#
+#target_link_libraries(media_simple_test
+#  ${GLUT_LIBRARY}
+#  ${OPENGL_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+
+### media_plugin_test
+
+#set(media_plugin_test_SOURCE_FILES
+#    media_plugin_test.cpp
+#    )
+#
+#add_executable(media_plugin_test
+#    WIN32
+#    ${media_plugin_test_SOURCE_FILES}
+#)
+#
+#set_target_properties(media_plugin_test
+#    PROPERTIES
+#    WIN32_EXECUTABLE
+#    FALSE
+#)
+#
+#target_link_libraries(media_plugin_test
+#  ${GLUT_LIBRARY}
+#  ${OPENGL_LIBRARIES}
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLMESSAGE_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(media_plugin_test
+#  copy_win_libs
+#  SLPlugin
+#  demo_media_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLMESSAGE_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+
+### demo_media_plugin
+
+#set(demo_media_plugin_SOURCE_FILES
+#    demo_media_plugin.cpp
+#    )
+#
+#add_library(demo_media_plugin
+#    SHARED
+#    ${demo_media_plugin_SOURCE_FILES}
+#)
+#
+#target_link_libraries(demo_media_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(demo_media_plugin
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+#
+#if (DARWIN)
+#  # Don't prepend 'lib' to the executable name, and don't embed a full path in the library's install name
+#  set_target_properties(
+#    demo_media_plugin
+#    PROPERTIES
+#    PREFIX ""
+#    BUILD_WITH_INSTALL_RPATH 1
+#    INSTALL_NAME_DIR "@executable_path"
+#  )
+#endif (DARWIN)
+
+### demo_media_plugin_2
+
+#set(demo_media_plugin_2_SOURCE_FILES
+#    demo_media_plugin_2.cpp
+#    )
+#
+#add_library(demo_media_plugin_2
+#    SHARED
+#    ${demo_media_plugin_2_SOURCE_FILES}
+#)
+#
+#target_link_libraries(demo_media_plugin_2
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#  ${PLUGIN_API_WINDOWS_LIBRARIES}
+#)
+#
+#add_dependencies(demo_media_plugin_2
+#  ${LLPLUGIN_LIBRARIES}
+#  ${LLCOMMON_LIBRARIES}
+#)
+#
+#if (DARWIN)
+#  # Don't prepend 'lib' to the executable name, and don't embed a full path in the library's install name
+#  set_target_properties(
+#    demo_media_plugin_2
+#    PROPERTIES
+#    PREFIX ""
+#    BUILD_WITH_INSTALL_RPATH 1
+#    INSTALL_NAME_DIR "@executable_path"
+#  )
+#endif (DARWIN)
+
+### llmediaplugintest
+
+set(llmediaplugintest_SOURCE_FILES
+    llmediaplugintest.cpp
+    llmediaplugintest.h
+    bookmarks.txt
+    )
+
+add_executable(llmediaplugintest
+    WIN32
+    ${llmediaplugintest_SOURCE_FILES}
+)
+
+set_target_properties(llmediaplugintest
+    PROPERTIES
+    WIN32_EXECUTABLE
+    FALSE
+)
+
+target_link_libraries(llmediaplugintest
+  ${GLUT_LIBRARY}
+  ${GLUI_LIBRARY}
+  ${OPENGL_LIBRARIES}
+  ${LLPLUGIN_LIBRARIES}
+  ${LLMESSAGE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+  ${PLUGIN_API_WINDOWS_LIBRARIES}
+)
+
+if (DARWIN)
+  # The testbed needs to use a couple of CoreFoundation calls now, to deal with being a bundled app.
+  target_link_libraries(llmediaplugintest
+    ${COREFOUNDATION_LIBRARY}
+  )
+endif (DARWIN)
+
+add_dependencies(llmediaplugintest
+  copy_win_libs
+  SLPlugin
+  media_plugin_quicktime
+  media_plugin_webkit
+  media_plugin_example
+  ${LLPLUGIN_LIBRARIES}
+  ${LLMESSAGE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+)
+
+# turn off weird GLUI pragma 
+add_definitions(-DGLUI_NO_LIB_PRAGMA)
+
+if (DARWIN OR LINUX)
+  # glui.h contains code that triggers the "overloaded-virtual" warning in gcc.  
+  set_source_files_properties(llmediaplugintest.cpp PROPERTIES COMPILE_FLAGS "-Wno-overloaded-virtual")
+endif (DARWIN OR LINUX)
+
+# Gather build products of the various dependencies into the build directory for the testbed.
+
+if (DARWIN)
+  # path inside the app bundle where we'll need to copy plugins and other related files
+  set(PLUGINS_DESTINATION_DIR
+    ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/llmediaplugintest.app/Contents/Resources
+  )
+  
+  # create the Contents/Resources directory
+  add_custom_command(
+    TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND}
+    ARGS
+      -E
+      make_directory
+      ${PLUGINS_DESTINATION_DIR}
+    COMMENT "Creating Resources directory in app bundle."
+  ) 
+else (DARWIN)
+  set(PLUGINS_DESTINATION_DIR
+    ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/
+  )
+endif (DARWIN)
+
+get_target_property(BUILT_SLPLUGIN SLPlugin LOCATION)
+add_custom_command(TARGET llmediaplugintest POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy ${BUILT_SLPLUGIN}  ${PLUGINS_DESTINATION_DIR}
+  DEPENDS ${BUILT_SLPLUGIN}
+)
+
+if (DARWIN OR WINDOWS)
+  get_target_property(BUILT_WEBKIT_PLUGIN media_plugin_webkit LOCATION)
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${BUILT_WEBKIT_PLUGIN}  ${PLUGINS_DESTINATION_DIR}
+    DEPENDS ${BUILT_WEBKIT_PLUGIN}
+  )
+
+  get_target_property(BUILT_QUICKTIME_PLUGIN media_plugin_quicktime LOCATION)
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${BUILT_QUICKTIME_PLUGIN}  ${PLUGINS_DESTINATION_DIR}
+    DEPENDS ${BUILT_QUICKTIME_PLUGIN}
+  )
+  
+  get_target_property(BUILT_EXAMPLE_PLUGIN media_plugin_example LOCATION)
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${BUILT_EXAMPLE_PLUGIN}  ${PLUGINS_DESTINATION_DIR}
+    DEPENDS ${BUILT_EXAMPLE_PLUGIN}
+  )
+  
+  # copy over bookmarks file if llmediaplugintest gets built
+  get_target_property(BUILT_LLMEDIAPLUGINTEST llmediaplugintest LOCATION)
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/bookmarks.txt ${CMAKE_CURRENT_BINARY_DIR}/
+    DEPENDS ${BUILT_LLMEDIAPLUGINTEST}
+  )
+  # also copy it to the same place as SLPlugin, which is what the mac wants...
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/bookmarks.txt ${PLUGINS_DESTINATION_DIR}
+    DEPENDS ${BUILT_LLMEDIAPLUGINTEST}
+  )
+endif (DARWIN OR WINDOWS)
+
+if (DARWIN)
+  add_custom_command(TARGET llmediaplugintest POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib_release/libllqtwebkit.dylib ${PLUGINS_DESTINATION_DIR}
+    DEPENDS ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib_release/libllqtwebkit.dylib
+  )
+endif (DARWIN)
+
+
diff --git a/linden/indra/test_apps/llplugintest/bookmarks.txt b/linden/indra/test_apps/llplugintest/bookmarks.txt
new file mode 100644
index 0000000..796cc5d
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/bookmarks.txt
@@ -0,0 +1,28 @@
+# format is description, url (don't put ',' chars in description :)
+# if no ',' found, whole line is used for both description and url
+(WK) Google Home Page,http://www.google.com
+(WK) BBC News Home Page,http://news.bbc.co.uk
+(WK) Second Life,http://secondlife.com
+(WK) WebKit Home ,http://www.webkit.org
+(WK) Yahoo News,http://news.yahoo.com
+(WK) Canvas Paint (DHTML version of MS Paint),http://www.canvaspaint.org
+(WK) DHTML Lemmings!,http://www.elizium.nu/scripts/lemmings/
+(WK) DHTML graphics demos,http://www.dhteumeuleu.com/
+(WK) Neat Javascript 3D,http://gyu.que.jp/jscloth/
+(QT) Local sample,file:///C|/Program Files/QuickTime/Sample.mov
+(QT) Movie - Watchmen Trailer,http://movies.apple.com/movies/wb/watchmen/watchmen-tlr2_480p.mov
+(QT) Movie - Transformers - Revenge of the Fallen,http://movies.apple.com/movies/paramount/transformers2/transformersrevengeofthefallen-tlr1_h.320.mov
+(QT) Movie - Terminator Salvation,http://movies.apple.com/movies/wb/terminatorsalvation/terminatorsalvation-tlr3_h.320.mov
+(QT) Movie - Angels and Demons,http://movies.apple.com/movies/sony_pictures/angelsanddemons/angelsanddemons-video_h.320.mov
+(QT) Movie - Sin City Trailer,http://movies.apple.com/movies/miramax/sin_city/sin_city_480.mov
+(QT) Movie - The Incredibles Trailer,http://movies.apple.com/movies/disney/the_incredibles/the_incredibles-tlr_a480.mov
+(QT) Movie - Streaming Apple Event,http://stream.qtv.apple.com/events/mar/0903lajkszg/m_090374535329zdwg_650_ref.mov
+(QT) Movie - MPEG-4 from Amazon S3,http://s3.amazonaws.com/callum-linden/flashdemo/interactive_flash_demo.mp4
+(QT) Movie - Star Trek,http://movies.apple.com/movies/paramount/star_trek/startrek-tlr3_h.320.mov
+(QT) Movie - Ice Age 3,http://movies.apple.com/movies/fox/ice_age_iii/iceage3-tlrd_h.320.mov
+(QT) Movie - AstroBoy,http://movies.apple.com/movies/summit/astroboy/astroboy-tsr_h.320.mov
+(QT) Movie - Ante Up,http://movies.apple.com/movies/independent/anteup/anteup_h.320.mov
+(QT) Movie - Every Little Step,http://movies.apple.com/movies/sony/everylittlestep/everylittlestep-clip_h.320.mov
+(QT) Movie - The Informers,http://movies.apple.com/movies/independent/theinformers/theinformers_h.320.mov
+(QT) Animated GIF,http://upload.wikimedia.org/wikipedia/commons/4/44/Optical.greysquares.arp-animated.gif
+(QT) Apple Text Descriptors,http://ubrowser.com/tmp/apple_text.txt
diff --git a/linden/indra/test_apps/llplugintest/demo_media_plugin.cpp b/linden/indra/test_apps/llplugintest/demo_media_plugin.cpp
new file mode 100644
index 0000000..89e15fd
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/demo_media_plugin.cpp
@@ -0,0 +1,472 @@
+/** 
+ * @file demo_plugin.cpp
+ * @brief Test plugin to be loaded by the llplugin testbed.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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"
+
+// TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
+
+class DemoMediaPlugin
+{
+public:
+
+        static int init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+
+private:
+        DemoMediaPlugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~DemoMediaPlugin();
+
+        static void staticReceiveMessage(const char *message_string, void **user_data);
+        void receiveMessage(const char *message_string);
+        void sendMessage(const LLPluginMessage &message);
+        void setDirty(int left, int top, int right, int bottom);
+        
+        LLPluginInstance::sendMessageFunction mHostSendFunction;
+        void *mHostUserData;
+        bool mDeleteMe;
+        
+        class SharedSegmentInfo
+        {
+        public:
+                void *mAddress;
+                size_t mSize;
+        };
+        
+        typedef std::map<std::string, SharedSegmentInfo> SharedSegmentMap;
+        
+        SharedSegmentMap mSharedSegments;
+
+public:
+        
+        void clear(void)
+        {               
+//              return;
+
+                if(mPixels != NULL)
+                {
+                        for( int y = 0; y < mHeight; ++y )
+                        {
+                                unsigned char *row = mPixels + ( y * mTextureWidth * mDepth);
+                                for(int x = 0; x < mWidth; ++x)
+                                {
+                                        unsigned char *pixel = row + (x * mDepth);
+                                        if(0)
+                                        {
+                                                pixel[0] = 0x20;
+                                                pixel[1] = 0x20;
+                                                pixel[2] = 0x20;
+                                        }
+                                        else
+                                        {
+                                                pixel[0] = rand() % 0x40;
+                                                pixel[1] = rand() % 0x40;
+                                                pixel[2] = rand() % 0x40;
+                                        }
+                                }
+                        }
+                        
+                        setDirty(0, 0, mWidth, mHeight);
+                }
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void update()
+        {
+                const time_t interval = 5;
+                static time_t last_time = time( NULL );
+                time_t cur_time = time( NULL );
+
+                if ( cur_time - last_time > interval )
+                {
+                        clear();
+
+                        last_time = cur_time;
+                };
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
+        {
+                // make sure we don't write outside the buffer
+                if((x < 0) || (x >= mWidth) || (y < 0) || (y >= mHeight))
+                        return;
+                        
+                if(mPixels != NULL)
+                {
+                        unsigned char *pixel = mPixels;
+                        pixel += y * mTextureWidth * mDepth;    // row offset
+                        pixel += (x * mDepth);                                                          // columm offset
+                        pixel[0] = b;
+                        pixel[1] = g;
+                        pixel[2] = r;
+
+                        setDirty(x, y, x+1, y+1);
+                }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseDown( int x, int y )
+        {
+                write_pixel( x, y, 0xff, 0x00, 0x00 );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseUp( int x, int y )
+        {
+                write_pixel( x, y, 0xff, 0xff, 0x00 );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseMove( int x, int y )
+        {
+                write_pixel( x  , y  , 0xff, 0x00, 0xff );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void keyPress( unsigned char key )
+        {
+        };
+
+private:
+        unsigned char* mPixels;
+        int mWidth;
+        int mHeight;
+        int mTextureWidth;
+        int mTextureHeight;
+        int mDepth;
+};
+
+int DemoMediaPlugin::init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        DemoMediaPlugin *self = new DemoMediaPlugin(host_send_func, host_user_data);
+        *plugin_send_func = staticReceiveMessage;
+        *plugin_user_data = (void*)self;
+
+        return 0;
+}
+
+
+DemoMediaPlugin::DemoMediaPlugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data)
+{
+        std::cerr << "DemoMediaPlugin constructor" << std::endl;
+
+        mHostSendFunction = host_send_func;
+        mHostUserData = host_user_data;
+        mDeleteMe = false;
+}
+
+DemoMediaPlugin::~DemoMediaPlugin()
+{
+        std::cerr << "DemoMediaPlugin destructor" << std::endl;
+}
+
+void DemoMediaPlugin::staticReceiveMessage(const char *message_string, void **user_data)
+{
+        DemoMediaPlugin *self = (DemoMediaPlugin*)*user_data;
+        
+        if(self != NULL)
+        {
+                self->receiveMessage(message_string);
+        
+                // If the plugin has processed the delete message, delete it.
+                if(self->mDeleteMe)
+                {
+                        delete self;
+                        *user_data = NULL;
+                }
+        }
+}
+
+void DemoMediaPlugin::receiveMessage(const char *message_string)
+{
+//      std::cerr << "DemoMediaPlugin::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;
+                                // Normally a plugin would only specify one of these two subclasses, but this is a demo...
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
+                                message.setValueLLSD("versions", versions);
+                                sendMessage(message);
+                                
+                                // Plugin gets to decide the texture parameters to use.
+                                mDepth = 3;
+                                
+                                message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+                                message.setValueS32("depth", mDepth);
+                                message.setValueU32("internalformat", GL_RGB);
+                                message.setValueU32("format", GL_RGB);
+                                message.setValueU32("type", GL_UNSIGNED_BYTE);
+                                message.setValueBoolean("coords_opengl", false);        // true == use OpenGL-style coordinates, false == (0,0) is upper left.
+                                sendMessage(message);
+                        }
+                        else if(message_name == "idle")
+                        {
+                                // no response is necessary here.
+                                update();
+                        }
+                        else if(message_name == "shutdown")
+                        {
+                                sendMessage(LLPluginMessage("base", "shutdown_response"));
+                                
+                                mDeleteMe = true;
+                        }
+                        else if(message_name == "shm_added")
+                        {
+                                SharedSegmentInfo info;
+                                info.mAddress =  (void*)message_in.getValueU32("address");
+                                info.mSize = (size_t)message_in.getValueS32("size");
+                                std::string name = message_in.getValue("name");
+                                
+                                
+                                std::cerr << "DemoMediaPlugin::receiveMessage: shared memory added, name: " << name 
+                                        << ", size: " << info.mSize 
+                                        << ", address: " << info.mAddress 
+                                        << std::endl;
+
+                                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+                        
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::string name = message_in.getValue("name");
+                                
+                                std::cerr << "DemoMediaPlugin::receiveMessage: shared memory remove, name = " << name << std::endl;
+
+                                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;
+                                        }
+                                        mSharedSegments.erase(iter);
+                                }
+                                else
+                                {
+                                        std::cerr << "DemoMediaPlugin::receiveMessage: unknown shared memory region!" << std::endl;
+                                }
+
+                                // Send the response so it can be cleaned up.
+                                LLPluginMessage message("base", "shm_remove_response");
+                                message.setValue("name", name);
+                                sendMessage(message);
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin::receiveMessage: unknown base message: " << message_name << std::endl;
+                        }
+                }
+                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");
+                                
+                                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())
+                                        {
+                                                std::cerr << "Got size change, new size is " << width << " by " << height << std::endl;
+                                                std::cerr << "    texture size is " << texture_width << " by " << texture_height << std::endl;
+                                                
+                                                mPixels = (unsigned char*)iter->second.mAddress;
+                                                mWidth = width;
+                                                mHeight = height;
+                                                mTextureWidth = texture_width;
+                                                mTextureHeight = texture_height;
+                                                
+                                                clear();
+                                        }
+                                }
+                        }
+                        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");
+//                              std::string modifiers = message.getValue("modifiers");
+
+//                              std::cerr << "DemoMediaPlugin::receiveMessage: mouse event \"" << event 
+//                                      << "\", coords " << x << ", " << y
+//                                      << std::endl;
+                                
+                                if(event == "down")
+                                {
+                                        mouseDown(x, y);
+                                }
+                                else if(event == "up")
+                                {
+                                        mouseUp(x, y);
+                                }
+                                else if(event == "move")
+                                {
+                                        mouseMove(x, y);
+                                }
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin::receiveMessage: unknown media message: " << message_string << std::endl;
+                        }
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
+                {
+                        if(message_name == "focus")
+                        {
+                                // foo = message_in.getValueBoolean("focused");
+                        }
+                        else if(message_name == "clear_cache")
+                        {
+                        }
+                        else if(message_name == "clear_cookies")
+                        {
+                        }
+                        else if(message_name == "enable_cookies")
+                        {
+                                // foo = message_in.getValueBoolean("enable");
+                        }
+                        else if(message_name == "proxy_setup")
+                        {
+                                // foo = message_in.getValueBoolean("enable");
+                                // bar = message_in.getValue("host");
+                                // baz = message_in.getValueS32("port");
+                        }
+                        else if(message_name == "browse_stop")
+                        {
+                        }
+                        else if(message_name == "browse_reload")
+                        {
+                                // foo = message_in.getValueBoolean("ignore_cache");
+                        }
+                        else if(message_name == "browse_forward")
+                        {
+                        }
+                        else if(message_name == "browse_back")
+                        {
+                        }
+                        else if(message_name == "set_status_redirect")
+                        {
+                                // foo = message_in.getValueS32("code");
+                                // bar = message_in.getValue("url");
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin::receiveMessage: unknown media_browser message: " << message_string << std::endl;
+                        }
+                }
+                else
+                {
+                        std::cerr << "DemoMediaPlugin::receiveMessage: unknown message class: " << message_class << std::endl;
+                }
+
+        }
+}
+
+void DemoMediaPlugin::sendMessage(const LLPluginMessage &message)
+{
+        std::string output = message.generate();
+        mHostSendFunction(output.c_str(), &mHostUserData);
+}
+
+void DemoMediaPlugin::setDirty(int left, int top, int right, int bottom)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "updated");
+        
+        message.setValueS32("left", left);
+        message.setValueS32("top", top);
+        message.setValueS32("right", right);
+        message.setValueS32("bottom", bottom);
+        
+        sendMessage(message);
+}
+
+
+extern "C"
+{
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+                int LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+}
+
+int 
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+        LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        return DemoMediaPlugin::init(host_send_func, host_user_data, plugin_send_func, plugin_user_data);
+}
+
+#ifdef WIN32
+int WINAPI DllEntryPoint( HINSTANCE hInstance, unsigned long reason, void* params )
+{
+        return 1;
+}
+#endif
diff --git a/linden/indra/test_apps/llplugintest/demo_media_plugin_2.cpp b/linden/indra/test_apps/llplugintest/demo_media_plugin_2.cpp
new file mode 100644
index 0000000..7a76f74
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/demo_media_plugin_2.cpp
@@ -0,0 +1,578 @@
+/** 
+ * @file demo_plugin.cpp
+ * @brief Test plugin to be loaded by the llplugin testbed.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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"
+
+// TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
+
+class DemoMediaPlugin2
+{
+public:
+
+        static int init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+
+private:
+        DemoMediaPlugin2(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~DemoMediaPlugin2();
+
+        static void staticReceiveMessage(const char *message_string, void **user_data);
+        void receiveMessage(const char *message_string);
+        void sendMessage(const LLPluginMessage &message);
+        void setDirty(int left, int top, int right, int bottom);
+        
+        LLPluginInstance::sendMessageFunction mHostSendFunction;
+        void *mHostUserData;
+        bool mDeleteMe;
+        
+        class SharedSegmentInfo
+        {
+        public:
+                void *mAddress;
+                size_t mSize;
+        };
+        
+        typedef std::map<std::string, SharedSegmentInfo> SharedSegmentMap;
+        
+        SharedSegmentMap mSharedSegments;
+
+public:
+        void updatePixels(void)
+        {
+                if ( mWidth < 1 || mWidth > 2048 || mHeight < 1 || mHeight > 2048 )
+                        return;
+
+                if ( mPixels == 0 )
+                                return;
+
+                if ( mFirstTime )
+                {
+                        // now we have a valid width/height - we can initialize positions
+                        for( int n = 0; n < NumObjects; ++n )
+                        {
+                                mXpos[ n ] = ( mWidth / 2 ) + rand() % ( mWidth / 16 ) - ( mWidth / 32 );
+                                mYpos[ n ] = ( mHeight / 2 ) + rand() % ( mHeight / 16 ) - ( mHeight / 32 );
+
+                                mColorR[ n ] = rand() % 0xa0 + 0x60;
+                                mColorG[ n ] = rand() % 0xa0 + 0x60;
+                                mColorB[ n ] = rand() % 0xa0 + 0x60;
+
+                                mXInc[ n ] = 0;
+                                while ( mXInc[ n ] == 0 )
+                                        mXInc[ n ] = rand() % 7 - 3;
+
+                                mYInc[ n ] = 0;
+                                while ( mYInc[ n ] == 0 )
+                                        mYInc[ n ] = rand() % 9 - 4;
+
+                                mBlockSize[ n ] = rand() % 0x16 + 0x04;
+                        };
+
+                        delete [] mBackgroundPixels;
+                                
+                        mBackgroundPixels = new unsigned char[ mWidth * mHeight * mDepth ];
+
+                        mFirstTime = false;
+                };
+
+                if ( time( NULL ) > mLastUpdateTime + 3 )
+                {
+                        const int num_squares = rand() % 20 + 4;
+                        int sqr1_r = rand() % 0x80 + 0x20;
+                        int sqr1_g = rand() % 0x80 + 0x20;
+                        int sqr1_b = rand() % 0x80 + 0x20;
+                        int sqr2_r = rand() % 0x80 + 0x20;
+                        int sqr2_g = rand() % 0x80 + 0x20;
+                        int sqr2_b = rand() % 0x80 + 0x20;
+
+                        for ( int y1 = 0; y1 < num_squares; ++y1 )
+                        {
+                                for ( int x1 = 0; x1 < num_squares; ++x1 )
+                                {
+                                        int px_start = mWidth * x1 / num_squares;
+                                        int px_end = ( mWidth * ( x1 + 1 ) ) / num_squares;
+                                        int py_start = mHeight * y1 / num_squares;
+                                        int py_end = ( mHeight * ( y1 + 1 ) ) / num_squares;
+
+                                        for( int y2 = py_start; y2 < py_end; ++y2 )
+                                        {
+                                                for( int x2 = px_start; x2 < px_end; ++x2 )
+                                                {
+                                                        int rowspan = mWidth * mDepth;
+
+                                                        if ( ( y1 % 2 ) ^ ( x1 % 2 ) )
+                                                        {
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr1_r;
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr1_g;
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr1_b;
+                                                        }
+                                                        else
+                                                        {
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr2_r;
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr2_g;
+                                                                mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr2_b;
+                                                        };
+                                                };
+                                        };
+                                };
+                        };
+
+                        time( &mLastUpdateTime );
+                };
+
+                memcpy( mPixels, mBackgroundPixels, mWidth * mHeight * mDepth );
+
+                for( int n = 0; n < NumObjects; ++n )
+                {
+                        if ( rand() % 50 == 0 )
+                        {
+                                        mXInc[ n ] = 0;
+                                        while ( mXInc[ n ] == 0 )
+                                                mXInc[ n ] = rand() % 7 - 3;
+
+                                        mYInc[ n ] = 0;
+                                        while ( mYInc[ n ] == 0 )
+                                                mYInc[ n ] = rand() % 9 - 4;
+                        };
+
+                        if ( mXpos[ n ] + mXInc[ n ] < 0 || mXpos[ n ] + mXInc[ n ] >= mWidth - mBlockSize[ n ] )
+                                mXInc[ n ] =- mXInc[ n ];
+
+                        if ( mYpos[ n ] + mYInc[ n ] < 0 || mYpos[ n ] + mYInc[ n ] >= mHeight - mBlockSize[ n ] )
+                                mYInc[ n ] =- mYInc[ n ];
+
+                        mXpos[ n ] += mXInc[ n ];
+                        mYpos[ n ] += mYInc[ n ];
+
+                        for( int y = 0; y < mBlockSize[ n ]; ++y )
+                        {
+                                for( int x = 0; x < mBlockSize[ n ]; ++x )
+                                {
+                                        mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 0 ] = mColorR[ n ];
+                                        mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 1 ] = mColorG[ n ];
+                                        mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 2 ] = mColorB[ n ];
+                                };
+                        };
+                };
+                
+                // TODO: experiment with setDirty to just follow block position
+                setDirty( 0, 0, mWidth, mHeight );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void update()
+        {
+                updatePixels();
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
+        {
+                // make sure we don't write outside the buffer
+                if((x < 0) || (x >= mWidth) || (y < 0) || (y >= mHeight))
+                        return;
+                        
+                if( mBackgroundPixels != NULL)
+                {
+                        unsigned char *pixel = mBackgroundPixels;
+                        pixel += y * mWidth * mDepth;   // row offset
+                        pixel += (x * mDepth);                                  // columm offset
+                        pixel[0] = b;
+                        pixel[1] = g;
+                        pixel[2] = r;
+
+                        setDirty(x, y, x+1, y+1);
+                }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseDown( int x, int y )
+        {
+                write_pixel( x, y, 0xff, 0x00, 0x00 );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseUp( int x, int y )
+        {
+                write_pixel( x, y, 0xff, 0xff, 0x00 );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void mouseMove( int x, int y )
+        {
+                write_pixel( x  , y  , 0xff, 0x00, 0xff );
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        void keyPress( unsigned char key )
+        {
+        };
+
+private:
+        unsigned char* mPixels;
+        int mWidth;
+        int mHeight;
+        int mTextureWidth;
+        int mTextureHeight;
+        int mDepth;
+        time_t mLastUpdateTime;
+        bool mFirstTime;
+        unsigned char* mBackgroundPixels;
+        enum Constants2 { NumObjects = 20 };
+        int mColorR[ NumObjects ];
+        int mColorG[ NumObjects ];
+        int mColorB[ NumObjects ];
+        int mXpos[ NumObjects ];
+        int mYpos[ NumObjects ];
+        int mXInc[ NumObjects ];
+        int mYInc[ NumObjects ];
+        int mBlockSize[ NumObjects ];
+};
+
+int DemoMediaPlugin2::init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        DemoMediaPlugin2 *self = new DemoMediaPlugin2(host_send_func, host_user_data);
+        *plugin_send_func = staticReceiveMessage;
+        *plugin_user_data = (void*)self;
+
+        return 0;
+}
+
+
+DemoMediaPlugin2::DemoMediaPlugin2(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data)
+{
+        std::cerr << "DemoMediaPlugin2 constructor" << std::endl;
+
+        mHostSendFunction = host_send_func;
+        mHostUserData = host_user_data;
+        mDeleteMe = false;
+
+        mLastUpdateTime = 0;
+        mFirstTime = true;
+        mLastUpdateTime = 0;
+        mWidth = 0;
+        mHeight = 0;
+        mDepth = 0;
+        mPixels = 0;
+        mBackgroundPixels = 0;
+
+        srand( get_clock_count() ) ;
+}
+
+DemoMediaPlugin2::~DemoMediaPlugin2()
+{
+        std::cerr << "DemoMediaPlugin2 destructor" << std::endl;
+}
+
+void DemoMediaPlugin2::staticReceiveMessage(const char *message_string, void **user_data)
+{
+        DemoMediaPlugin2 *self = (DemoMediaPlugin2*)*user_data;
+        
+        if(self != NULL)
+        {
+                self->receiveMessage(message_string);
+        
+                // If the plugin has processed the delete message, delete it.
+                if(self->mDeleteMe)
+                {
+                        delete self;
+                        *user_data = NULL;
+                }
+        }
+}
+
+void DemoMediaPlugin2::receiveMessage(const char *message_string)
+{
+//      std::cerr << "DemoMediaPlugin2::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;
+                                // Normally a plugin would only specify one of these two subclasses, but this is a demo...
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
+                                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
+                                message.setValueLLSD("versions", versions);
+                                sendMessage(message);
+                                
+                                // Plugin gets to decide the texture parameters to use.
+                                mDepth = 3;
+
+                                message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+                                message.setValueS32("depth", mDepth);
+                                message.setValueU32("internalformat", GL_RGB);
+                                message.setValueU32("format", GL_RGB);
+                                message.setValueU32("type", GL_UNSIGNED_BYTE);
+                                message.setValueBoolean("coords_opengl", false);        // true == use OpenGL-style coordinates, false == (0,0) is upper left.
+                                sendMessage(message);
+                        }
+                        else if(message_name == "idle")
+                        {
+                                // no response is necessary here.
+                                update();
+                        }
+                        else if(message_name == "shutdown")
+                        {
+                                sendMessage(LLPluginMessage("base", "shutdown_response"));
+                                
+                                mDeleteMe = true;
+                        }
+                        else if(message_name == "shm_added")
+                        {
+                                SharedSegmentInfo info;
+                                info.mAddress =  (void*)message_in.getValueU32("address");
+                                info.mSize = (size_t)message_in.getValueS32("size");
+                                std::string name = message_in.getValue("name");
+                                
+                                
+                                std::cerr << "DemoMediaPlugin2::receiveMessage: shared memory added, name: " << name 
+                                        << ", size: " << info.mSize 
+                                        << ", address: " << info.mAddress 
+                                        << std::endl;
+
+                                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+                        
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::string name = message_in.getValue("name");
+                                
+                                std::cerr << "DemoMediaPlugin2::receiveMessage: shared memory remove, name = " << name << std::endl;
+
+                                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;
+                                        }
+                                        mSharedSegments.erase(iter);
+                                }
+                                else
+                                {
+                                        std::cerr << "DemoMediaPlugin2::receiveMessage: unknown shared memory region!" << std::endl;
+                                }
+
+                                // Send the response so it can be cleaned up.
+                                LLPluginMessage message("base", "shm_remove_response");
+                                message.setValue("name", name);
+                                sendMessage(message);
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin2::receiveMessage: unknown base message: " << message_name << std::endl;
+                        }
+                }
+                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");
+                                
+                                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())
+                                        {
+                                                std::cerr << "Got size change, new size is " << width << " by " << height << std::endl;
+                                                std::cerr << "    texture size is " << texture_width << " by " << texture_height << std::endl;
+                                                
+                                                mPixels = (unsigned char*)iter->second.mAddress;
+                                                mWidth = width;
+                                                mHeight = height;
+
+                                                mTextureWidth = texture_width;
+                                                mTextureHeight = texture_height;
+                                                
+                                                mFirstTime = true;
+                                                updatePixels();
+                                        }
+                                }
+                        }
+                        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");
+//                              std::string modifiers = message.getValue("modifiers");
+
+//                              std::cerr << "DemoMediaPlugin2::receiveMessage: mouse event \"" << event 
+//                                      << "\", coords " << x << ", " << y
+//                                      << std::endl;
+                                
+                                if(event == "down")
+                                {
+                                        mouseDown(x, y);
+                                }
+                                else if(event == "up")
+                                {
+                                        mouseUp(x, y);
+                                }
+                                else if(event == "move")
+                                {
+                                        mouseMove(x, y);
+                                }
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin2::receiveMessage: unknown media message: " << message_string << std::endl;
+                        }
+                }
+                else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
+                {
+                        if(message_name == "focus")
+                        {
+                                // foo = message_in.getValueBoolean("focused");
+                        }
+                        else if(message_name == "clear_cache")
+                        {
+                        }
+                        else if(message_name == "clear_cookies")
+                        {
+                        }
+                        else if(message_name == "enable_cookies")
+                        {
+                                // foo = message_in.getValueBoolean("enable");
+                        }
+                        else if(message_name == "proxy_setup")
+                        {
+                                // foo = message_in.getValueBoolean("enable");
+                                // bar = message_in.getValue("host");
+                                // baz = message_in.getValueS32("port");
+                        }
+                        else if(message_name == "browse_stop")
+                        {
+                        }
+                        else if(message_name == "browse_reload")
+                        {
+                                // foo = message_in.getValueBoolean("ignore_cache");
+                        }
+                        else if(message_name == "browse_forward")
+                        {
+                        }
+                        else if(message_name == "browse_back")
+                        {
+                        }
+                        else if(message_name == "set_status_redirect")
+                        {
+                                // foo = message_in.getValueS32("code");
+                                // bar = message_in.getValue("url");
+                        }
+                        else
+                        {
+                                std::cerr << "DemoMediaPlugin2::receiveMessage: unknown media_browser message: " << message_string << std::endl;
+                        }
+                }
+                else
+                {
+                        std::cerr << "DemoMediaPlugin2::receiveMessage: unknown message class: " << message_class << std::endl;
+                }
+
+        }
+}
+
+void DemoMediaPlugin2::sendMessage(const LLPluginMessage &message)
+{
+        std::string output = message.generate();
+        mHostSendFunction(output.c_str(), &mHostUserData);
+}
+
+void DemoMediaPlugin2::setDirty(int left, int top, int right, int bottom)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "updated");
+        
+        message.setValueS32("left", left);
+        message.setValueS32("top", top);
+        message.setValueS32("right", right);
+        message.setValueS32("bottom", bottom);
+        
+        sendMessage(message);
+}
+
+
+extern "C"
+{
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+                int LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+}
+
+int 
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+        LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        return DemoMediaPlugin2::init(host_send_func, host_user_data, plugin_send_func, plugin_user_data);
+}
+
+#ifdef WIN32
+int WINAPI DllEntryPoint( HINSTANCE hInstance, unsigned long reason, void* params )
+{
+        return 1;
+}
+#endif
diff --git a/linden/indra/test_apps/llplugintest/demo_plugin.cpp b/linden/indra/test_apps/llplugintest/demo_plugin.cpp
new file mode 100644
index 0000000..772fa16
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/demo_plugin.cpp
@@ -0,0 +1,220 @@
+/** 
+ * @file demo_plugin.cpp
+ * @brief Test plugin to be loaded by the llplugin testbed.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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"
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include "llplugininstance.h"
+#include "llpluginmessage.h"
+#include "llpluginmessageclasses.h"
+
+// TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
+
+class DemoPlugin
+{
+public:
+
+        static int init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+
+private:
+        DemoPlugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+        ~DemoPlugin();
+
+        static void staticReceiveMessage(const char *message_string, void **user_data);
+        void receiveMessage(const char *message_string);
+        void sendMessage(const LLPluginMessage &message);
+
+        LLPluginInstance::sendMessageFunction mHostSendFunction;
+        void *mHostUserData;
+        bool mDeleteMe;
+        
+        int mSharedSegmentFillValue;
+        void *mSharedSegmentBase;
+        size_t mSharedSegmentSize;
+};
+
+int DemoPlugin::init(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        DemoPlugin *self = new DemoPlugin(host_send_func, host_user_data);
+        *plugin_send_func = staticReceiveMessage;
+        *plugin_user_data = (void*)self;
+
+        return 0;
+}
+
+DemoPlugin::DemoPlugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data)
+{
+        std::cerr << "DemoPlugin constructor" << std::endl;
+
+        mHostSendFunction = host_send_func;
+        mHostUserData = host_user_data;
+        mDeleteMe = false;
+        mSharedSegmentBase = NULL;
+        mSharedSegmentSize = 0;
+        mSharedSegmentFillValue = 0;
+}
+
+DemoPlugin::~DemoPlugin()
+{
+        std::cerr << "DemoPlugin destructor" << std::endl;
+}
+
+void DemoPlugin::staticReceiveMessage(const char *message_string, void **user_data)
+{
+        DemoPlugin *self = (DemoPlugin*)*user_data;
+        
+        if(self != NULL)
+        {
+                self->receiveMessage(message_string);
+        
+                // If the plugin has processed the delete message, delete it.
+                if(self->mDeleteMe)
+                {
+                        delete self;
+                        *user_data = NULL;
+                }
+        }
+}
+
+void DemoPlugin::receiveMessage(const char *message_string)
+{
+//      std::cerr << "DemoPlugin::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 == "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;
+                                message.setValueLLSD("versions", versions);
+                                sendMessage(message);
+                        }
+                        else if(message_name == "idle")
+                        {
+                                // no response is necessary here.
+//                              std::cerr << "DemoPlugin::receiveMessage: idle processing" << std::endl;
+                                if(mSharedSegmentBase != NULL)
+                                {
+                                        // Fill the shared memory segment
+                                        memset(mSharedSegmentBase, mSharedSegmentFillValue, mSharedSegmentSize);
+                                        // and increment the fill value
+                                        mSharedSegmentFillValue++;
+                                }
+                        }
+                        else if(message_name == "shutdown")
+                        {
+                                sendMessage(LLPluginMessage("base", "shutdown_response"));
+                                
+                                mDeleteMe = true;
+                        }
+                        else if(message_name == "shm_added")
+                        {
+                                // Normally, we would check the name and match it up with something from another message.
+                                // For this test, just fill any segment that comes in.
+                                mSharedSegmentSize = (size_t)message_in.getValueS32("size");
+                                mSharedSegmentBase = (void*)message_in.getValueU32("address");
+                                
+                                std::cerr << "DemoPlugin::receiveMessage: shared memory added, name: " << message_in.getValue("name") 
+                                        << ", size: " << mSharedSegmentSize 
+                                        << ", address: " << mSharedSegmentBase 
+                                        << std::endl;
+
+                                memset(mSharedSegmentBase, mSharedSegmentFillValue, mSharedSegmentSize);
+                        
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::cerr << "DemoPlugin::receiveMessage: shared memory remove" << std::endl;
+                                
+                                // Normally, we would check the name and match it up with something from another message.
+                                // For this test, just stop filling the only segment we track.
+
+                                mSharedSegmentBase = NULL;
+
+                                // Send the response so it can be cleaned up.
+                                LLPluginMessage message("base", "shm_remove_response");
+                                message.setValue("name", message_in.getValue("name"));
+                                sendMessage(message);
+                        }
+                        else
+                        {
+                                std::cerr << "DemoPlugin::receiveMessage: unknown base message: " << message_name << std::endl;
+                        }
+                }
+                else
+                {
+                        std::cerr << "DemoPlugin::receiveMessage: unknown message class: " << message_class << std::endl;
+                }
+
+        }
+}
+
+void DemoPlugin::sendMessage(const LLPluginMessage &message)
+{
+        std::string output = message.generate();
+        mHostSendFunction(output.c_str(), &mHostUserData);
+}
+
+
+extern "C"
+{
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+                int LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
+}
+
+int 
+#ifdef WIN32
+        __declspec(dllexport)
+#endif
+        LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
+{
+        return DemoPlugin::init(host_send_func, host_user_data, plugin_send_func, plugin_user_data);
+}
+
+#ifdef WIN32
+int WINAPI DllEntryPoint( HINSTANCE hInstance, unsigned long reason, void* params )
+{
+        return 1;
+}
+#endif
diff --git a/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp b/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp
new file mode 100644
index 0000000..27cb52a
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp
@@ -0,0 +1,2179 @@
+/**
+ * @file LLMediaPluginTest.cpp
+ * @brief Primary test application for LLMedia (Separate Process) Plugin system
+ *
+ * $LicenseInfo:firstyear=2008&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://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$
+ */
+
+#include "linden_common.h"
+#include "indra_constants.h"
+
+#include "llapr.h"
+#include "llerrorcontrol.h"
+
+#include <math.h>
+#include <iomanip>
+#include <sstream>
+#include <ctime>
+
+#include "llmediaplugintest.h"
+
+#if __APPLE__
+        #include <GLUT/glut.h>
+        #include <CoreFoundation/CoreFoundation.h>
+#else
+        #define FREEGLUT_STATIC
+        #include "GL/freeglut.h"
+        #define GLUI_FREEGLUT
+#endif
+
+#if LL_WINDOWS
+#pragma warning(disable: 4263)
+#pragma warning(disable: 4264)
+#endif
+#include "glui.h"
+
+
+LLMediaPluginTest* gApplication = 0;
+static void gluiCallbackWrapper( int control_id );
+
+////////////////////////////////////////////////////////////////////////////////
+//
+static bool isTexture( GLuint texture )
+{
+        bool result = false;
+        
+        // glIsTexture will sometimes return false for real textures... do this instead.
+        if(texture != 0)
+                result = true;
+        
+        return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+mediaPanel::mediaPanel()
+{
+        mMediaTextureHandle = 0;
+        mPickTextureHandle = 0;
+        mMediaSource = NULL;
+        mPickTexturePixels = NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+mediaPanel::~mediaPanel()
+{
+        // delete OpenGL texture handles
+        if ( isTexture( mPickTextureHandle ) )
+        {
+                std::cerr << "remMediaPanel: deleting pick texture " << mPickTextureHandle << std::endl;
+                glDeleteTextures( 1, &mPickTextureHandle );
+                mPickTextureHandle = 0;
+        }
+        
+        if ( isTexture( mMediaTextureHandle ) )
+        {
+                std::cerr << "remMediaPanel: deleting media texture " << mMediaTextureHandle << std::endl;
+                glDeleteTextures( 1, &mMediaTextureHandle );
+                mMediaTextureHandle = 0;
+        }
+        
+        if(mPickTexturePixels)
+        {
+                delete mPickTexturePixels;
+        }
+        
+        if(mMediaSource)
+        {
+                delete mMediaSource;
+        }
+        
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+LLMediaPluginTest::LLMediaPluginTest( int app_window, int window_width, int window_height ) :
+        mVersionMajor( 2 ),
+        mVersionMinor( 0 ),
+        mVersionPatch( 0 ),
+        mMaxPanels( 25 ),
+        mViewportAspect( 0 ),
+        mAppWindow( app_window ),
+        mCurMouseX( 0 ),
+        mCurMouseY( 0 ),
+        mFuzzyMedia( true ),
+        mSelectedPanel( 0 ),
+        mMediaBrowserControlEnableCookies( 0 ),
+        mMediaBrowserControlBackButton( 0 ),
+        mMediaBrowserControlForwardButton( 0 ),
+        mMediaTimeControlVolume( 100 ),
+        mMediaTimeControlSeekSeconds( 0 ),
+        mGluiMediaTimeControlWindowFlag( true ),
+        mGluiMediaBrowserControlWindowFlag( true ),
+        mMediaBrowserControlBackButtonFlag( true ),
+        mMediaBrowserControlForwardButtonFlag( true ),
+        mHomeWebUrl( "http://www.google.com/" )
+{
+        // debugging spam
+        std::cout << std::endl << "             GLUT version: " << "3.7.6" << std::endl;        // no way to get real version from GLUT
+        std::cout << std::endl << "             GLUI version: " << GLUI_Master.get_version() << std::endl;
+        std::cout << std::endl << "Media Plugin Test version: " << mVersionMajor << "." << mVersionMinor << "." << mVersionPatch << std::endl;
+
+        // bookmark title
+        mBookmarks.push_back( std::pair< std::string, std::string >( "--- Bookmarks ---", "" ) );
+
+        // insert hardcoded URLs here as required for testing
+        //mBookmarks.push_back( std::pair< std::string, std::string >( "description", "url" ) );
+
+        // read bookmarks from file.
+        // note: uses command in ./CmakeLists.txt which copies bookmmarks file from source directory 
+        //       to app directory (WITHOUT build configuration dir) (this is cwd in Windows within MSVC)
+        //               For example, test_apps\llplugintest and not test_apps\llplugintest\Release
+        //               This may need to be changed for Mac/Linux builds.
+        // See https://jira.lindenlab.com/browse/DEV-31350 for large list of media URLs from AGNI
+        const std::string bookmarks_filename( "bookmarks.txt" );
+        std::ifstream file_handle( bookmarks_filename.c_str() );
+        if ( file_handle.is_open() )
+        {
+                std::cout << "Reading bookmarks for test" << std::endl;
+                while( ! file_handle.eof() )
+                {
+                        std::string line;
+                        std::getline( file_handle, line );
+                        if ( file_handle.eof() )
+                                break;
+
+                        if ( line.substr( 0, 1 ) != "#" )
+                        {
+                                size_t comma_pos = line.find_first_of( ',' );
+                                if ( comma_pos != std::string::npos )
+                                {
+                                        std::string description = line.substr( 0, comma_pos );
+                                        std::string url = line.substr( comma_pos + 1 );
+                                        mBookmarks.push_back( std::pair< std::string, std::string >( description, url ) );
+                                }
+                                else
+                                {
+                                        mBookmarks.push_back( std::pair< std::string, std::string >( line, line ) );
+                                };
+                        };
+                };
+                std::cout << "Read " << mBookmarks.size() << " bookmarks" << std::endl;
+        }
+        else
+        {
+                std::cout << "Unable to read bookmarks from file: " << bookmarks_filename << std::endl;
+        };
+
+        // initialize linden lab APR module
+        ll_init_apr();
+
+        // Set up llerror logging 
+        {
+                LLError::initForApplication(".");
+                LLError::setDefaultLevel(LLError::LEVEL_INFO);
+                //LLError::setTagLevel("Plugin", LLError::LEVEL_DEBUG);
+        }
+
+        // lots of randomness in this app
+        srand( ( unsigned int )time( 0 ) );
+
+        // build GUI
+        makeChrome();
+
+        // OpenGL initialilzation
+        glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+        glClearDepth( 1.0f );
+        glEnable( GL_DEPTH_TEST );
+        glEnable( GL_COLOR_MATERIAL );
+        glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );
+        glDepthFunc( GL_LEQUAL );
+        glEnable( GL_TEXTURE_2D );
+        glDisable( GL_BLEND );
+        glColor3f( 1.0f, 1.0f, 1.0f );
+        glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0 );
+
+        // start with a sane view
+        resetView();
+
+        // initial media panel
+        const int num_initial_panels = 1;
+        for( int i = 0; i < num_initial_panels; ++i )
+        {
+                //addMediaPanel( mBookmarks[ rand() % ( mBookmarks.size() - 1 ) + 1 ].second );
+                addMediaPanel( mHomeWebUrl );
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+LLMediaPluginTest::~LLMediaPluginTest()
+{
+        // delete all media panels
+        for( int i = 0; i < (int)mMediaPanels.size(); ++i )
+        {
+                remMediaPanel( mMediaPanels[ i ] );
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::reshape( int width, int height )
+{
+        // update viewport (the active window inside the chrome)
+        int viewport_x, viewport_y;
+        int viewport_height, viewport_width;
+        GLUI_Master.get_viewport_area( &viewport_x, &viewport_y, &viewport_width, &viewport_height );
+        mViewportAspect = (float)( viewport_width ) / (float)( viewport_height );
+        glViewport( viewport_x, viewport_y, viewport_width, viewport_height );
+
+        // save these as we'll need them later
+        mWindowWidth = width;
+        mWindowHeight = height;
+
+        // adjust size of URL bar so it doesn't get clipped
+        mUrlEdit->set_w( mWindowWidth - 360 );
+
+        // GLUI requires this
+        if ( glutGetWindow() != mAppWindow )
+                glutSetWindow( mAppWindow );
+
+        // trigger re-display
+        glutPostRedisplay();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::bindTexture(GLuint texture, GLint row_length, GLint alignment)
+{
+        glEnable( GL_TEXTURE_2D );
+        
+        glBindTexture( GL_TEXTURE_2D, texture );
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, row_length );
+        glPixelStorei( GL_UNPACK_ALIGNMENT, alignment );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+bool LLMediaPluginTest::checkGLError(const char *name)
+{
+        bool result = false;
+        GLenum error = glGetError();
+        
+        if(error != GL_NO_ERROR)
+        {
+                // For some reason, glGenTextures is returning GL_INVALID_VALUE...
+                std::cout << name << " ERROR 0x" << std::hex << error << std::dec << std::endl;
+                result = true;
+        }
+        
+        return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::drawGeometry( int panel )
+{
+        // texture coordinates for each panel
+        GLfloat non_opengl_texture_coords[ 8 ] = { 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f };
+        GLfloat opengl_texture_coords[ 8 ] =     { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f };
+        
+        GLfloat *texture_coords = mMediaPanels[ panel ]->mAppTextureCoordsOpenGL?opengl_texture_coords:non_opengl_texture_coords;
+        
+        // base coordinates for each panel
+        GLfloat base_vertex_pos[ 8 ] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f };
+
+        // calculate posiitons
+        const int num_panels = (int)mMediaPanels.size();
+        const int num_rows = (int)sqrt( (float)num_panels );
+        const int num_cols = num_panels / num_rows;
+        const int panel_x = ( panel / num_rows );
+        const int panel_y = ( panel % num_rows );
+
+        const float spacing = 0.1f;
+        const GLfloat offset_x = num_cols * ( 1.0 + spacing ) / 2;
+        const GLfloat offset_y = num_rows * ( 1.0 + spacing ) / 2;
+        
+        // Adjust for media aspect ratios
+        {               
+                float aspect = 1.0f;
+
+                if(mMediaPanels[ panel ]->mMediaHeight != 0)
+                {
+                        aspect = (float)mMediaPanels[ panel ]->mMediaWidth / (float)mMediaPanels[ panel ]->mMediaHeight;
+                }
+                
+                if(aspect > 1.0f)
+                {
+                        // media is wider than it is high -- adjust the top and bottom in
+                        for( int corner = 0; corner < 4; ++corner )
+                        {
+                                float temp = base_vertex_pos[corner * 2 + 1];
+                                
+                                if(temp < 0.5f)
+                                        temp += 0.5 - (0.5f / aspect);
+                                else
+                                        temp -= 0.5 - (0.5f / aspect);
+                                
+                                base_vertex_pos[corner * 2 + 1] = temp;
+                        }
+                }
+                else if(aspect < 1.0f)
+                {
+                        // media is higher than it is wide -- adjust the left and right sides in
+                        for( int corner = 0; corner < 4; ++corner )
+                        {
+                                float temp = base_vertex_pos[corner * 2];
+                                
+                                if(temp < 0.5f)
+                                        temp += 0.5f - (0.5f * aspect);
+                                else
+                                        temp -= 0.5f - (0.5f * aspect);
+
+                                base_vertex_pos[corner * 2] = temp;
+                        }
+                }
+        }
+
+        glBegin( GL_QUADS );
+        for( int corner = 0; corner < 4; ++corner )
+        {
+                glTexCoord2f( texture_coords[ corner * 2 ], texture_coords[ corner * 2 + 1 ] );
+                GLfloat x = base_vertex_pos[ corner * 2 ] + panel_x * ( 1.0 + spacing ) - offset_x + spacing / 2.0f;
+                GLfloat y = base_vertex_pos[ corner * 2 + 1 ] + panel_y * ( 1.0 + spacing ) - offset_y + spacing / 2.0f;
+
+                glVertex3f( x, y, 0.0f );
+        };
+        glEnd();
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::startPanelHighlight( float red, float green, float blue, float line_width )
+{
+        glPushAttrib( GL_ALL_ATTRIB_BITS );
+        glEnable( GL_POLYGON_OFFSET_FILL );
+        glPolygonOffset( -2.5f, -2.5f );
+        glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+        glLineWidth( line_width );
+        glColor3f( red, green, blue );
+        glDisable( GL_TEXTURE_2D );
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::endPanelHighlight()
+{
+        glPopAttrib();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::draw( int draw_type )
+{
+        for( int panel = 0; panel < (int)mMediaPanels.size(); ++panel )
+        {
+                // drawing pick texture
+                if ( draw_type == DrawTypePickTexture )
+                {
+                        // only bother with pick if we have something to render
+                        // Actually, we need to pick even if we're not ready to render.  
+                        // Otherwise you can't select and remove a panel which has gone bad.
+                        //if ( mMediaPanels[ panel ]->mReadyToRender )
+                        {
+                                glMatrixMode( GL_TEXTURE );
+                                glPushMatrix();
+
+                                // pick texture is a power of 2 so no need to scale
+                                glLoadIdentity();
+
+                                // bind to media texture
+                                glLoadIdentity();
+                                bindTexture( mMediaPanels[ panel ]->mPickTextureHandle );
+                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+
+                                // draw geometry using pick texture
+                                drawGeometry( panel );
+
+                                glMatrixMode( GL_TEXTURE );
+                                glPopMatrix();
+                        };
+                }
+                else
+                if ( draw_type == DrawTypeMediaTexture )
+                {
+                        bool texture_valid = false;
+                        bool plugin_exited = false;
+                        
+                        if(mMediaPanels[ panel ]->mMediaSource)
+                        {
+                                texture_valid = mMediaPanels[ panel ]->mMediaSource->textureValid();
+                                plugin_exited = mMediaPanels[ panel ]->mMediaSource->isPluginExited();
+                        }
+                        
+                        // save texture matrix (changes for each panel)
+                        glMatrixMode( GL_TEXTURE );
+                        glPushMatrix();
+
+                        // only process texture if the media is ready to draw
+                        // (we still want to draw the geometry)
+                        if ( mMediaPanels[ panel ]->mReadyToRender && texture_valid )
+                        {
+                                // bind to media texture
+                                bindTexture( mMediaPanels[ panel ]->mMediaTextureHandle );
+
+                                if ( mFuzzyMedia )
+                                {
+                                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+                                }
+                                else
+                                {
+                                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+                                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+                                }
+
+                                // scale to fit panel
+                                glScalef( mMediaPanels[ panel ]->mTextureScaleX,
+                                                        mMediaPanels[ panel ]->mTextureScaleY,
+                                                                1.0f );
+                        };
+                        
+                        float intensity = plugin_exited?0.25f:1.0f;
+                        
+                        // highlight the selected panel
+                        if ( mSelectedPanel && ( mMediaPanels[ panel ]->mId == mSelectedPanel->mId ) )
+                        {
+                                startPanelHighlight( intensity, intensity, 0.0f, 5.0f );
+                                drawGeometry( panel );
+                                endPanelHighlight();
+                        }
+                        else
+                        // this panel not able to render yet since it
+                        // doesn't have enough information
+                        if ( !mMediaPanels[ panel ]->mReadyToRender )
+                        {
+                                startPanelHighlight( intensity, 0.0f, 0.0f, 2.0f );
+                                drawGeometry( panel );
+                                endPanelHighlight();
+                        }
+                        else
+                        // just display a border around the media 
+                        {
+                                startPanelHighlight( 0.0f, intensity, 0.0f, 2.0f );
+                                drawGeometry( panel );
+                                endPanelHighlight();
+                        };
+                        
+                        if ( mMediaPanels[ panel ]->mReadyToRender && texture_valid )
+                        {
+                                // draw visual geometry
+                                drawGeometry( panel );
+                        }
+
+                        // restore texture matrix (changes for each panel)
+                        glMatrixMode( GL_TEXTURE );
+                        glPopMatrix();
+                };
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::display()
+{
+        // GLUI requires this
+        if ( glutGetWindow() != mAppWindow )
+                glutSetWindow( mAppWindow );
+
+        // start with a clean slate
+        glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+        // set up OpenGL view
+        glMatrixMode( GL_PROJECTION );
+        glLoadIdentity();
+        glFrustum( -mViewportAspect * 0.04f, mViewportAspect * 0.04f, -0.04f, 0.04f, 0.1f, 50.0f );
+        glMatrixMode( GL_MODELVIEW );
+        glLoadIdentity();
+        glTranslatef( 0.0, 0.0, 0.0f );
+        glTranslatef( mViewPos[ 0 ], mViewPos[ 1 ], -mViewPos[ 2 ] );
+        glMultMatrixf( mViewRotation );
+
+        // draw pick texture
+        draw( DrawTypePickTexture );
+
+        // read colors and get coordinate values
+        glReadPixels( mCurMouseX, mCurMouseY, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, mPixelReadColor );
+
+        // clear the pick render (otherwise it may depth-fight with the textures rendered later)
+        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+        // draw visible geometry
+        draw( DrawTypeMediaTexture );
+
+        glutSwapBuffers();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::idle()
+{
+//      checkGLError("LLMediaPluginTest::idle");
+
+        // GLUI requires this
+        if ( glutGetWindow() != mAppWindow )
+                glutSetWindow( mAppWindow );
+        
+        // random creation/destruction of panels enabled?
+        const time_t panel_timeout_time = 5;
+        if ( mRandomPanelCount )
+        {
+                // time for a change
+                static time_t last_panel_time = 0;
+                if ( time( NULL ) - last_panel_time > panel_timeout_time )
+                {
+                        if ( rand() % 2 == 0 )
+                        {
+                                if ( mMediaPanels.size() < 16 )
+                                {
+                                        std::cout << "Randomly adding new panel" << std::endl;
+                                        addMediaPanel( mBookmarks[ rand() % ( mBookmarks.size() - 1 ) + 1 ].second );
+                                };
+                        }
+                        else
+                        {
+                                if ( mMediaPanels.size() > 0 )
+                                {
+                                        std::cout << "Deleting selected panel" << std::endl;
+                                        remMediaPanel( mSelectedPanel );
+                                };
+                        };
+                        time( &last_panel_time );
+                };
+        };
+
+        // random selection of bookmarks enabled?
+        const time_t bookmark_timeout_time = 5;
+        if ( mRandomBookmarks )
+        {
+                // time for a change
+                static time_t last_bookmark_time = 0;
+                if ( time( NULL ) - last_bookmark_time > bookmark_timeout_time )
+                {
+                        // go to a different random bookmark on each panel
+                        for( int panel = 0; panel < (int)mMediaPanels.size(); ++panel )
+                        {
+                                std::string uri = mBookmarks[ rand() % ( mBookmarks.size() - 1 ) + 1 ].second;
+
+                                std::cout << "Random: navigating to : " << uri << std::endl;
+
+                                std::string mime_type = mimeTypeFromUrl( uri );
+
+                                if ( mime_type != mMediaPanels[ panel ]->mMimeType )
+                                {
+                                        replaceMediaPanel( mMediaPanels[ panel ], uri );
+                                }
+                                else
+                                {
+                                        mMediaPanels[ panel ]->mMediaSource->loadURI( uri );
+                                        mMediaPanels[ panel ]->mMediaSource->start();
+                                };
+                        };
+
+                        time( &last_bookmark_time );
+                };
+        };
+
+        // update UI
+        if ( mSelectedPanel )
+        {
+                // set volume based on slider if we have time media
+                //if ( mGluiMediaTimeControlWindowFlag )
+                //{
+                //      mSelectedPanel->mMediaSource->setVolume( (float)mMediaTimeControlVolume / 100.0f );
+                //};
+
+                // NOTE: it is absurd that we need cache the state of GLUI controls
+                //       but enabling/disabling controls drags framerate from 500+
+                //               down to 15. Not a problem for plugin system - only this test
+                // enable/disable time based UI controls based on type of plugin
+                if ( mSelectedPanel->mMediaSource->pluginSupportsMediaTime() )
+                {
+                        if ( ! mGluiMediaTimeControlWindowFlag )
+                        {
+                                mGluiMediaTimeControlWindow->enable();
+                                mGluiMediaTimeControlWindowFlag = true;
+                        };
+                }
+                else
+                {
+                        if ( mGluiMediaTimeControlWindowFlag )
+                        {
+                                mGluiMediaTimeControlWindow->disable();
+                                mGluiMediaTimeControlWindowFlag = false;
+                        };
+                };
+
+                // enable/disable browser based UI controls based on type of plugin
+                if ( mSelectedPanel->mMediaSource->pluginSupportsMediaBrowser() )
+                {
+                        if ( ! mGluiMediaBrowserControlWindowFlag )
+                        {
+                                mGluiMediaBrowserControlWindow->enable();
+                                mGluiMediaBrowserControlWindowFlag = true;
+                        };
+                }
+                else
+                {
+                        if ( mGluiMediaBrowserControlWindowFlag )
+                        {
+                                mGluiMediaBrowserControlWindow->disable();
+                                mGluiMediaBrowserControlWindowFlag = false;
+                        };
+                };
+
+                // enable/disable browser back button depending on browser history
+                if ( mSelectedPanel->mMediaSource->getHistoryBackAvailable()  )
+                {
+                        if ( ! mMediaBrowserControlBackButtonFlag )
+                        {
+                                mMediaBrowserControlBackButton->enable();
+                                mMediaBrowserControlBackButtonFlag = true;
+                        };
+                }
+                else
+                {
+                        if ( mMediaBrowserControlBackButtonFlag )
+                        {
+                                mMediaBrowserControlBackButton->disable();
+                                mMediaBrowserControlBackButtonFlag = false;
+                        };
+                };
+
+                // enable/disable browser forward button depending on browser history
+                if ( mSelectedPanel->mMediaSource->getHistoryForwardAvailable()  )
+                {
+                        if ( ! mMediaBrowserControlForwardButtonFlag )
+                        {
+                                mMediaBrowserControlForwardButton->enable();
+                                mMediaBrowserControlForwardButtonFlag = true;
+                        };
+                }
+                else
+                {
+                        if ( mMediaBrowserControlForwardButtonFlag )
+                        {
+                                mMediaBrowserControlForwardButton->disable();
+                                mMediaBrowserControlForwardButtonFlag = false;
+                        };
+                };
+
+                // NOTE: This is *very* slow and not worth optimising
+                updateStatusBar();
+        };
+
+        // update all the panels
+        for( int panel_index = 0; panel_index < (int)mMediaPanels.size(); ++panel_index )
+        {
+                mediaPanel *panel = mMediaPanels[ panel_index ];
+                
+                // call plugins idle function so it can potentially update itself
+                panel->mMediaSource->idle();
+
+                // update each media panel
+                updateMediaPanel( panel );
+
+                LLRect dirty_rect;
+                if ( ! panel->mMediaSource->textureValid() )
+                {
+                        //std::cout << "texture invalid, skipping update..." << std::endl;
+                }
+                else
+                if ( panel && 
+                         ( panel->mMediaWidth != panel->mMediaSource->getWidth() ||
+                           panel->mMediaHeight != panel->mMediaSource->getHeight() ) )
+                {
+                        //std::cout << "Resize in progress, skipping update..." << std::endl;
+                }
+                else
+                if ( panel->mMediaSource->getDirty( &dirty_rect ) )
+                {
+                        const unsigned char* pixels = panel->mMediaSource->getBitsData();
+                        if ( pixels && isTexture(panel->mMediaTextureHandle))
+                        {
+                                int x_offset = dirty_rect.mLeft;
+                                int y_offset = dirty_rect.mBottom;
+                                int width = dirty_rect.mRight - dirty_rect.mLeft;
+                                int height = dirty_rect.mTop - dirty_rect.mBottom;
+                                
+                                if((dirty_rect.mRight <= panel->mTextureWidth) && (dirty_rect.mTop <= panel->mTextureHeight))
+                                {
+                                        // Offset the pixels pointer properly
+                                        pixels += ( y_offset * panel->mMediaSource->getTextureDepth() * panel->mMediaSource->getBitsWidth() );
+                                        pixels += ( x_offset * panel->mMediaSource->getTextureDepth() );
+
+                                        // set up texture
+                                        bindTexture( panel->mMediaTextureHandle, panel->mMediaSource->getBitsWidth() );
+                                        if ( mFuzzyMedia )
+                                        {
+                                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+                                        }
+                                        else
+                                        {
+                                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+                                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+                                        };
+                                        
+                                        checkGLError("glTexParameteri");
+                                        
+                                        if(panel->mMediaSource->getTextureFormatSwapBytes())
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                                                checkGLError("glPixelStorei");
+                                        }
+                                        
+                                        // draw portion that changes into texture
+                                        glTexSubImage2D( GL_TEXTURE_2D, 0, 
+                                                x_offset, 
+                                                y_offset,
+                                                width, 
+                                                height,
+                                                panel->mMediaSource->getTextureFormatPrimary(), 
+                                                panel->mMediaSource->getTextureFormatType(), 
+                                                pixels );
+
+                                        if(checkGLError("glTexSubImage2D"))
+                                        {
+                                                std::cerr << "    panel ID=" << panel->mId << std::endl;
+                                                std::cerr << "    texture size = " << panel->mTextureWidth << " x " << panel->mTextureHeight << std::endl;
+                                                std::cerr << "    media size = " << panel->mMediaWidth << " x " << panel->mMediaHeight << std::endl;
+                                                std::cerr << "    dirty rect = " << dirty_rect.mLeft << ", " << dirty_rect.mBottom << ", " << dirty_rect.mRight << ", " << dirty_rect.mTop << std::endl;
+                                                std::cerr << "    texture width = " << panel->mMediaSource->getBitsWidth() << std::endl;
+                                                std::cerr << "    format primary = 0x" << std::hex << panel->mMediaSource->getTextureFormatPrimary() << std::dec << std::endl;
+                                                std::cerr << "    format type = 0x" << std::hex << panel->mMediaSource->getTextureFormatType() << std::dec << std::endl;
+                                                std::cerr << "    pixels = " << (void*)pixels << std::endl;
+                                        }
+
+                                        if(panel->mMediaSource->getTextureFormatSwapBytes())
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                                                checkGLError("glPixelStorei");
+                                        }
+                                        
+                                        panel->mMediaSource->resetDirty();
+                                        
+                                        panel->mReadyToRender = true;
+                                }
+                                else
+                                {
+                                        std::cerr << "dirty rect is outside current media size, skipping update" << std::endl;
+                                }
+                        };
+                };
+        };
+
+        // GLUI requires this
+        if ( glutGetWindow() != mAppWindow )
+                glutSetWindow( mAppWindow );
+
+        // trigger re-display
+        glutPostRedisplay();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::windowPosToTexturePos( int window_x, int window_y, 
+                                                                                           int& media_x, int& media_y, 
+                                                                                           int& id )
+{
+        if ( ! mSelectedPanel )
+        {
+                media_x = 0;
+                media_y = 0;
+                id = 0;
+                return;
+        };
+
+        // record cursor poisiton for a readback next frame
+        mCurMouseX = window_x;
+        // OpenGL app == coordinate system this way
+        // NOTE: unrelated to settings in plugin - this
+        // is just for this app
+        mCurMouseY = mWindowHeight - window_y;  
+
+        // extract x (0..1023, y (0..1023) and id (0..15) from RGB components
+        unsigned long pixel_read_color_bits = ( mPixelReadColor[ 0 ] << 16 ) | ( mPixelReadColor[ 1 ] << 8 ) | mPixelReadColor[ 2 ];
+        int texture_x = pixel_read_color_bits & 0x3ff;
+        int texture_y = ( pixel_read_color_bits >> 10 ) & 0x3ff;
+        id = ( pixel_read_color_bits >> 20 ) & 0x0f;
+
+        // scale to size of media (1024 because we use 10 bits for X and Y from 24)
+        media_x = (int)( ( (float)mSelectedPanel->mMediaWidth * (float)texture_x ) / 1024.0f );
+        media_y = (int)( ( (float)mSelectedPanel->mMediaHeight * (float)texture_y ) / 1024.0f );
+
+        // we assume the plugin uses an inverted coordinate scheme like OpenGL
+        // if not, the plugin code inverts the Y coordinate for us - we don't need to
+        media_y = mSelectedPanel->mMediaHeight - media_y;
+
+        if ( media_x > 0 && media_y > 0 )
+        {
+                //std::cout << "      mouse coords: " << mCurMouseX << " x " << mCurMouseY << " and id = " << id  << std::endl;
+                //std::cout << "raw texture coords: " << texture_x << " x " << texture_y << " and id = " << id  << std::endl;
+                //std::cout << "      media coords: " << media_x << " x " << media_y << " and id = " << id  << std::endl;
+                //std::cout << std::endl;
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::selectPanelById( int id )
+{
+        for( int panel = 0; panel < (int)mMediaPanels.size(); ++panel )
+        {
+                if ( mMediaPanels[ panel ]->mId == id )
+                {
+                        selectPanel(mMediaPanels[ panel ]);
+                        return;
+                };
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::selectPanel( mediaPanel* panel )
+{
+        if( mSelectedPanel == panel )
+                return;
+
+        // turn off volume before we delete it
+        if( mSelectedPanel && mSelectedPanel->mMediaSource )
+        {
+                mSelectedPanel->mMediaSource->setVolume( 0.0f );
+                mSelectedPanel->mMediaSource->setPriority( LLPluginClassMedia::PRIORITY_LOW );
+        };
+                
+        mSelectedPanel = panel;
+
+        if( mSelectedPanel && mSelectedPanel->mMediaSource )
+        {
+                mSelectedPanel->mMediaSource->setVolume( (float)mMediaTimeControlVolume / 100.0f );
+                mSelectedPanel->mMediaSource->setPriority( LLPluginClassMedia::PRIORITY_NORMAL );
+                
+                if(!mSelectedPanel->mStartUrl.empty())
+                {
+                        mUrlEdit->set_text(const_cast<char*>(mSelectedPanel->mStartUrl.c_str()) );
+                }
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+mediaPanel*  LLMediaPluginTest::findMediaPanel( LLPluginClassMedia* source )
+{
+        mediaPanel *result = NULL;
+        
+        for( int panel = 0; panel < (int)mMediaPanels.size(); ++panel )
+        {
+                if ( mMediaPanels[ panel ]->mMediaSource == source )
+                {
+                        result = mMediaPanels[ panel ];
+                }
+        }
+        
+        return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::navigateToNewURI( std::string uri )
+{
+        if ( uri.length() )
+        {
+                std::string mime_type = mimeTypeFromUrl( uri );
+
+                if ( !mSelectedPanel->mMediaSource->isPluginExited() && (mime_type == mSelectedPanel->mMimeType) )
+                {
+                        std::cout << "MIME type is the same" << std::endl;
+                        mSelectedPanel->mMediaSource->loadURI( uri );
+                        mSelectedPanel->mMediaSource->start();
+                        mBookmarkList->do_selection( 0 );
+                }
+                else
+                {
+                        std::cout << "MIME type changed or plugin had exited" << std::endl;
+                        replaceMediaPanel( mSelectedPanel, uri );
+                        mBookmarkList->do_selection( 0 );
+                }
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::initUrlHistory( std::string uris )
+{
+        if ( uris.length() > 0 )
+        {
+                std::cout << "init URL : " << uris << std::endl;
+                LLSD historySD;
+
+                char *cstr, *p;
+                cstr = new char[uris.size()+1];
+                strcpy(cstr, uris.c_str());
+                const char *DELIMS = " ,;";
+                p = strtok(cstr, DELIMS);
+                while (p != NULL) {
+                        historySD.insert(0, p);
+                        p = strtok(NULL, DELIMS);
+                }
+                mSelectedPanel->mMediaSource->initializeUrlHistory(historySD);
+                delete[] cstr;
+        }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::gluiCallback( int control_id )
+{
+        if ( control_id == mIdBookmarks )
+        {
+                std::string uri = mBookmarks[ mSelBookmark ].second;
+
+                navigateToNewURI( uri );
+        }
+        else
+    if ( control_id == mIdUrlEdit)
+        {
+                std::string uri = mUrlEdit->get_text();
+
+                navigateToNewURI( uri );
+        }
+        else
+        if ( control_id == mIdUrlInitHistoryEdit )
+        {
+                std::string uri = mUrlInitHistoryEdit->get_text();
+
+                initUrlHistory( uri );
+        }
+        else
+        if ( control_id == mIdControlAddPanel )
+        {
+                addMediaPanel( mBookmarks[ rand() % ( mBookmarks.size() - 1 ) + 1 ].second );
+        }
+        else
+        if ( control_id == mIdControlRemPanel )
+        {
+                remMediaPanel( mSelectedPanel );
+        }
+        else
+        if ( control_id == mIdDisableTimeout )
+        {
+                // Set the "disable timeout" flag for all active plugins.
+                for( int i = 0; i < (int)mMediaPanels.size(); ++i )
+                {
+                        mMediaPanels[ i ]->mMediaSource->setDisableTimeout(mDisableTimeout);
+                }
+        }
+        else
+        if ( control_id == mIdControlCrashPlugin )
+        {
+                // send message to plugin and ask it to crash
+                // (switch out for ReleaseCandidate version :) )
+                if(mSelectedPanel && mSelectedPanel->mMediaSource)
+                {
+                        mSelectedPanel->mMediaSource->crashPlugin();
+                }
+        }
+        else
+        if ( control_id == mIdControlHangPlugin )
+        {
+                // send message to plugin and ask it to hang
+                // (switch out for ReleaseCandidate version :) )
+                if(mSelectedPanel && mSelectedPanel->mMediaSource)
+                {
+                        mSelectedPanel->mMediaSource->hangPlugin();
+                }
+        }
+        else
+        if ( control_id == mIdControlExitApp )
+        {
+                // text for exiting plugin system cleanly
+                delete this;    // clean up
+                exit( 0 );
+        }
+        else
+        if ( control_id == mIdMediaTimeControlPlay )
+        {
+                if ( mSelectedPanel )
+                {
+                        mSelectedPanel->mMediaSource->setLoop( false );
+                        mSelectedPanel->mMediaSource->start();
+                };
+        }
+        else
+        if ( control_id == mIdMediaTimeControlLoop )
+        {
+                if ( mSelectedPanel )
+                {
+                        mSelectedPanel->mMediaSource->setLoop( true );
+                        mSelectedPanel->mMediaSource->start();
+                };
+        }
+        else
+        if ( control_id == mIdMediaTimeControlPause )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->pause();
+        }
+        else
+        if ( control_id == mIdMediaTimeControlStop )
+        {
+                if ( mSelectedPanel )
+                {
+                        mSelectedPanel->mMediaSource->stop();
+                };
+        }
+        else
+        if ( control_id == mIdMediaTimeControlSeek )
+        {
+                if ( mSelectedPanel )
+                {
+                        // get value from spinner       
+                        float seconds_to_seek = mMediaTimeControlSeekSeconds;
+                        mSelectedPanel->mMediaSource->seek( seconds_to_seek );
+                        mSelectedPanel->mMediaSource->start();
+                };
+        }
+        else
+        if ( control_id == mIdMediaTimeControlRewind )
+        {
+                if ( mSelectedPanel )
+                {
+                        mSelectedPanel->mMediaSource->setLoop( false );
+                        mSelectedPanel->mMediaSource->start(-2.0f);
+                };
+        }
+        else
+        if ( control_id == mIdMediaTimeControlFastForward )
+        {
+                if ( mSelectedPanel )
+                {
+                        mSelectedPanel->mMediaSource->setLoop( false );
+                        mSelectedPanel->mMediaSource->start(2.0f);
+                };
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlBack )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->browse_back();
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlStop )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->browse_stop();
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlForward )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->browse_forward();
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlHome )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->loadURI( mHomeWebUrl );
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlReload )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->browse_reload( true );
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlClearCache )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->clear_cache();
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlClearCookies )
+        {
+                if ( mSelectedPanel )
+                        mSelectedPanel->mMediaSource->clear_cookies();
+        }
+        else
+        if ( control_id == mIdMediaBrowserControlEnableCookies )
+        {
+                if ( mSelectedPanel )
+                {
+                        if ( mMediaBrowserControlEnableCookies )
+                        {
+                                mSelectedPanel->mMediaSource->enable_cookies( true );
+                        }
+                        else
+                        {
+                                mSelectedPanel->mMediaSource->enable_cookies( false );
+                        }
+                };
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::keyboard( int key )
+{
+        //if ( key == 'a' || key == 'A' )
+        //      addMediaPanel( mBookmarks[ rand() % ( mBookmarks.size() - 1 ) + 1 ].second );
+        //else
+        //if ( key == 'r' || key == 'R' )
+        //      remMediaPanel( mSelectedPanel );
+        //else
+        //if ( key == 'd' || key == 'D' )
+        //      dumpPanelInfo();
+        //else
+        if ( key == 27 )
+        {
+                std::cout << "Application finished - exiting..." << std::endl;
+                delete this;
+                exit( 0 );
+        };
+
+        mSelectedPanel->mMediaSource->keyEvent( LLPluginClassMedia::KEY_EVENT_DOWN, key, 0 );
+        mSelectedPanel->mMediaSource->keyEvent( LLPluginClassMedia::KEY_EVENT_UP, key, 0 );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::mouseButton( int button, int state, int x, int y )
+{
+        if ( button == GLUT_LEFT_BUTTON )
+        {
+                if ( state == GLUT_DOWN )
+                {
+                        int media_x, media_y, id;
+                        windowPosToTexturePos( x, y, media_x, media_y, id );
+
+                        if ( mSelectedPanel )
+                                mSelectedPanel->mMediaSource->mouseEvent( LLPluginClassMedia::MOUSE_EVENT_DOWN, 0, media_x, media_y, 0 );
+                }
+                else
+                if ( state == GLUT_UP )
+                {
+                        int media_x, media_y, id;
+                        windowPosToTexturePos( x, y, media_x, media_y, id );
+
+                        // only select a panel if we're on a panel
+                        // (HACK: strictly speaking this rules out clicking on 
+                        // the origin of a panel but that's very unlikely)
+                        if ( media_x > 0 && media_y > 0 )
+                        {
+                                selectPanelById( id );
+
+                                if ( mSelectedPanel )
+                                        mSelectedPanel->mMediaSource->mouseEvent( LLPluginClassMedia::MOUSE_EVENT_UP, 0, media_x, media_y, 0 );
+                        };
+                };
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::mousePassive( int x, int y )
+{
+        int media_x, media_y, id;
+        windowPosToTexturePos( x, y, media_x, media_y, id );
+
+        if ( mSelectedPanel )
+                mSelectedPanel->mMediaSource->mouseEvent( LLPluginClassMedia::MOUSE_EVENT_MOVE, 0, media_x, media_y, 0 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::mouseMove( int x, int y )
+{
+        int media_x, media_y, id;
+        windowPosToTexturePos( x, y, media_x, media_y, id );
+
+        if ( mSelectedPanel )
+                mSelectedPanel->mMediaSource->mouseEvent( LLPluginClassMedia::MOUSE_EVENT_MOVE, 0, media_x, media_y, 0 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::makeChrome()
+{
+        // IDs used by GLUI
+        int start_id = 0x1000;
+
+        // right side window - geometry manipulators
+#if __APPLE__
+        // the Apple GLUT implementation doesn't seem to set the graphic offset of subwindows correctly when they overlap in certain ways.
+        // Use a separate controls window in this case.
+        // GLUI window at right containing manipulation controls and other buttons
+        int x = glutGet(GLUT_WINDOW_X) + glutGet(GLUT_WINDOW_WIDTH) + 4;
+        int y = glutGet(GLUT_WINDOW_Y);
+        GLUI* right_glui_window = GLUI_Master.create_glui( "", 0, x, y );
+#else
+        GLUI* right_glui_window = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_RIGHT );
+#endif
+        mViewRotationCtrl = right_glui_window->add_rotation( "Rotation", mViewRotation );
+        mViewTranslationCtrl = right_glui_window->add_translation( "Translate", GLUI_TRANSLATION_XY, mViewPos );
+        mViewTranslationCtrl->set_speed( 0.01f );
+        mViewScaleCtrl = right_glui_window->add_translation( "Scale", GLUI_TRANSLATION_Z, &mViewPos[ 2 ] );
+        mViewScaleCtrl->set_speed( 0.05f );
+        right_glui_window->set_main_gfx_window( mAppWindow );
+
+        // right side window - app controls
+        mIdControlAddPanel = start_id++;
+        right_glui_window->add_statictext( "" );
+        right_glui_window->add_separator();
+        right_glui_window->add_statictext( "" );
+        right_glui_window->add_button( "Add panel", mIdControlAddPanel, gluiCallbackWrapper );
+        right_glui_window->add_statictext( "" );
+        mIdControlRemPanel = start_id++;
+        right_glui_window->add_button( "Rem panel", mIdControlRemPanel, gluiCallbackWrapper );
+        right_glui_window->add_statictext( "" );
+        right_glui_window->add_separator();
+        right_glui_window->add_statictext( "" );
+        mIdControlCrashPlugin = start_id++;
+        right_glui_window->add_button( "Crash plugin", mIdControlCrashPlugin, gluiCallbackWrapper );
+        mIdControlHangPlugin = start_id++;
+        right_glui_window->add_button( "Hang plugin", mIdControlHangPlugin, gluiCallbackWrapper );
+
+        right_glui_window->add_statictext( "" );
+        right_glui_window->add_separator();
+        right_glui_window->add_statictext( "" );
+        mIdControlExitApp = start_id++;
+        right_glui_window->add_button( "Exit app", mIdControlExitApp, gluiCallbackWrapper );
+
+        //// top window - holds bookmark UI
+        mIdBookmarks = start_id++;
+        mSelBookmark = 0;
+        GLUI* glui_window_top = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_TOP );
+        mBookmarkList = glui_window_top->add_listbox( "", &mSelBookmark, mIdBookmarks, gluiCallbackWrapper );
+        // only add the first 50 bookmarks - list can be very long sometimes (30,000+)
+        // when testing list of media URLs from AGNI for example
+        for( unsigned int each = 0; each < mBookmarks.size() && each < 50; ++each )
+                mBookmarkList->add_item( each, const_cast< char* >( mBookmarks[ each ].first.c_str() ) );
+        glui_window_top->set_main_gfx_window( mAppWindow );
+
+        glui_window_top->add_column( false );
+        mIdUrlEdit = start_id++;
+        mUrlEdit = glui_window_top->add_edittext( "Url:", GLUI_EDITTEXT_TEXT, 0, mIdUrlEdit, gluiCallbackWrapper );
+        mUrlEdit->set_w( 600 );
+        GLUI* glui_window_top2 = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_TOP );
+        mIdUrlInitHistoryEdit = start_id++;
+        mUrlInitHistoryEdit = glui_window_top2->add_edittext( "Init History (separate by commas or semicolons):",
+                GLUI_EDITTEXT_TEXT, 0, mIdUrlInitHistoryEdit, gluiCallbackWrapper );
+        mUrlInitHistoryEdit->set_w( 800 );
+
+        // top window - media controls for "time" media types (e.g. movies)
+        mGluiMediaTimeControlWindow = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_TOP );
+        mGluiMediaTimeControlWindow->set_main_gfx_window( mAppWindow );
+        mIdMediaTimeControlPlay = start_id++;
+        mGluiMediaTimeControlWindow->add_button( "PLAY", mIdMediaTimeControlPlay, gluiCallbackWrapper );
+        mGluiMediaTimeControlWindow->add_column( false );
+        mIdMediaTimeControlLoop = start_id++;
+        mGluiMediaTimeControlWindow->add_button( "LOOP", mIdMediaTimeControlLoop, gluiCallbackWrapper );
+        mGluiMediaTimeControlWindow->add_column( false );
+        mIdMediaTimeControlPause = start_id++;
+        mGluiMediaTimeControlWindow->add_button( "PAUSE", mIdMediaTimeControlPause, gluiCallbackWrapper );
+        mGluiMediaTimeControlWindow->add_column( false );
+
+        GLUI_Button  *button;
+        mIdMediaTimeControlRewind = start_id++;
+        button = mGluiMediaTimeControlWindow->add_button( "<<", mIdMediaTimeControlRewind, gluiCallbackWrapper );
+        button->set_w(30);
+        mGluiMediaTimeControlWindow->add_column( false );
+        mIdMediaTimeControlFastForward = start_id++;
+        button = mGluiMediaTimeControlWindow->add_button( ">>", mIdMediaTimeControlFastForward, gluiCallbackWrapper );
+        button->set_w(30);
+
+        mGluiMediaTimeControlWindow->add_column( true );
+
+        mIdMediaTimeControlStop = start_id++;
+        mGluiMediaTimeControlWindow->add_button( "STOP", mIdMediaTimeControlStop, gluiCallbackWrapper );
+        mGluiMediaTimeControlWindow->add_column( false );
+        mIdMediaTimeControlVolume = start_id++;
+        GLUI_Spinner* spinner = mGluiMediaTimeControlWindow->add_spinner( "Volume", 2, &mMediaTimeControlVolume, mIdMediaTimeControlVolume, gluiCallbackWrapper);
+        spinner->set_float_limits( 0, 100 );            
+        mGluiMediaTimeControlWindow->add_column( true );
+        mIdMediaTimeControlSeekSeconds = start_id++;
+        spinner = mGluiMediaTimeControlWindow->add_spinner( "", 2, &mMediaTimeControlSeekSeconds, mIdMediaTimeControlSeekSeconds, gluiCallbackWrapper);
+        spinner->set_float_limits( 0, 200 );            
+        spinner->set_w( 32 );
+        spinner->set_speed( 0.025f );
+        mGluiMediaTimeControlWindow->add_column( false );
+        mIdMediaTimeControlSeek = start_id++;
+        mGluiMediaTimeControlWindow->add_button( "SEEK", mIdMediaTimeControlSeek, gluiCallbackWrapper );
+        mGluiMediaTimeControlWindow->add_column( false );
+        
+
+        // top window - media controls for "browser" media types (e.g. web browser)
+        mGluiMediaBrowserControlWindow = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_TOP );
+        mGluiMediaBrowserControlWindow->set_main_gfx_window( mAppWindow );
+        mIdMediaBrowserControlBack = start_id++;
+        mMediaBrowserControlBackButton = mGluiMediaBrowserControlWindow->add_button( "BACK", mIdMediaBrowserControlBack, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlStop = start_id++;
+        mGluiMediaBrowserControlWindow->add_button( "STOP", mIdMediaBrowserControlStop, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlForward = start_id++;
+        mMediaBrowserControlForwardButton = mGluiMediaBrowserControlWindow->add_button( "FORWARD", mIdMediaBrowserControlForward, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlHome = start_id++;
+        mGluiMediaBrowserControlWindow->add_button( "HOME", mIdMediaBrowserControlHome, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlReload = start_id++;
+        mGluiMediaBrowserControlWindow->add_button( "RELOAD", mIdMediaBrowserControlReload, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlClearCache = start_id++;
+        mGluiMediaBrowserControlWindow->add_button( "CLEAR CACHE", mIdMediaBrowserControlClearCache, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlClearCookies = start_id++;
+        mGluiMediaBrowserControlWindow->add_button( "CLEAR COOKIES", mIdMediaBrowserControlClearCookies, gluiCallbackWrapper );
+        mGluiMediaBrowserControlWindow->add_column( false );
+        mIdMediaBrowserControlEnableCookies = start_id++;
+        mMediaBrowserControlEnableCookies = 0;
+        mGluiMediaBrowserControlWindow->add_checkbox( "Enable Cookies", &mMediaBrowserControlEnableCookies, mIdMediaBrowserControlEnableCookies, gluiCallbackWrapper );
+
+        // top window - misc controls
+        GLUI* glui_window_misc_control = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_TOP );
+        mIdRandomPanelCount = start_id++;
+        mRandomPanelCount = 0;
+        glui_window_misc_control->add_checkbox( "Randomize panel count", &mRandomPanelCount, mIdRandomPanelCount, gluiCallbackWrapper );
+        glui_window_misc_control->set_main_gfx_window( mAppWindow );
+        glui_window_misc_control->add_column( true );
+        mIdRandomBookmarks = start_id++;
+        mRandomBookmarks = 0;
+        glui_window_misc_control->add_checkbox( "Randomize bookmarks", &mRandomBookmarks, mIdRandomBookmarks, gluiCallbackWrapper );
+        glui_window_misc_control->set_main_gfx_window( mAppWindow );
+        glui_window_misc_control->add_column( true );
+
+        mIdDisableTimeout = start_id++;
+        mDisableTimeout = 0;
+        glui_window_misc_control->add_checkbox( "Disable plugin timeout", &mDisableTimeout, mIdDisableTimeout, gluiCallbackWrapper );
+        glui_window_misc_control->set_main_gfx_window( mAppWindow );
+
+        // bottom window - status
+        mBottomGLUIWindow = GLUI_Master.create_glui_subwindow( mAppWindow, GLUI_SUBWINDOW_BOTTOM );
+        mStatusText = mBottomGLUIWindow->add_statictext( "" );
+        mBottomGLUIWindow->set_main_gfx_window( mAppWindow );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::resetView()
+{
+        mViewRotationCtrl->reset();
+
+        mViewScaleCtrl->set_x( 0.0f );
+        mViewScaleCtrl->set_y( 0.0f );
+        mViewScaleCtrl->set_z( 3.0f );
+
+        mViewTranslationCtrl->set_x( 0.0f );
+        mViewTranslationCtrl->set_y( 0.0f );
+        mViewTranslationCtrl->set_z( 0.0f );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::makePickTexture( int id, GLuint* texture_handle, unsigned char** texture_pixels )
+{
+        int pick_texture_width = 1024;
+        int pick_texture_height = 1024;
+        int pick_texture_depth = 3;
+        unsigned char* ptr = new unsigned char[ pick_texture_width * pick_texture_height * pick_texture_depth ];
+        for( int y = 0; y < pick_texture_height; ++y )
+        {
+                for( int x = 0; x < pick_texture_width * pick_texture_depth ; x += pick_texture_depth )
+                {
+                        unsigned long bits = 0L;
+                        bits |= ( id << 20 ) | ( y << 10 ) | ( x / 3 );
+                        unsigned char r_component = ( bits >> 16 ) & 0xff;
+                        unsigned char g_component = ( bits >> 8 ) & 0xff;
+                        unsigned char b_component = bits & 0xff;
+
+                        ptr[ y * pick_texture_width * pick_texture_depth + x + 0 ] = r_component;
+                        ptr[ y * pick_texture_width * pick_texture_depth + x + 1 ] = g_component;
+                        ptr[ y * pick_texture_width * pick_texture_depth + x + 2 ] = b_component;
+                };
+        };
+
+        glGenTextures( 1, texture_handle );
+
+        checkGLError("glGenTextures");
+        std::cout << "glGenTextures returned " << *texture_handle << std::endl;
+
+        bindTexture( *texture_handle );
+        glTexImage2D( GL_TEXTURE_2D, 0,
+                                        GL_RGB,
+                                                pick_texture_width, pick_texture_height,
+                                                        0, GL_RGB, GL_UNSIGNED_BYTE, ptr );
+
+        *texture_pixels = ptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+std::string LLMediaPluginTest::mimeTypeFromUrl( std::string& url )
+{
+        // default to web 
+        std::string mime_type = "text/html";
+
+        // we may need a more advanced MIME type accessor later :-)
+        if ( url.find( ".mov" ) != std::string::npos )  // Movies
+                mime_type = "video/quicktime";
+        else
+        if ( url.find( ".txt" ) != std::string::npos )  // Apple Text descriptors
+                mime_type = "video/quicktime";
+        else
+        if ( url.find( ".mp3" ) != std::string::npos )  // Apple Text descriptors
+                mime_type = "video/quicktime";
+        else
+        if ( url.find( "example://" ) != std::string::npos )    // Example plugin
+                mime_type = "example/example";
+
+        return mime_type;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+std::string LLMediaPluginTest::pluginNameFromMimeType( std::string& mime_type )
+{
+#if LL_DARWIN
+        std::string plugin_name( "media_plugin_null.dylib" );
+        if ( mime_type == "video/quicktime" )
+                plugin_name = "media_plugin_quicktime.dylib";
+        else
+        if ( mime_type == "text/html" )
+                plugin_name = "media_plugin_webkit.dylib";
+        
+#elif LL_WINDOWS
+        std::string plugin_name( "media_plugin_null.dll" );
+
+        if ( mime_type == "video/quicktime" )
+                plugin_name = "media_plugin_quicktime.dll";
+        else
+        if ( mime_type == "text/html" )
+                plugin_name = "media_plugin_webkit.dll";
+        else
+        if ( mime_type == "example/example" )
+                plugin_name = "media_plugin_example.dll";
+
+#elif LL_LINUX
+        std::string plugin_name( "libmedia_plugin_null.so" );
+
+        if ( mime_type == "video/quicktime" )
+                plugin_name = "libmedia_plugin_quicktime.so";
+        else
+        if ( mime_type == "text/html" )
+                plugin_name = "libmedia_plugin_webkit.so";
+#endif
+        return plugin_name;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::addMediaPanel( std::string url )
+{
+        // Get the plugin filename using the URL
+        std::string mime_type = mimeTypeFromUrl( url );
+        std::string plugin_name = pluginNameFromMimeType( mime_type );
+
+        // create a random size for the new media
+        int media_width;
+        int media_height;
+        getRandomMediaSize( media_width, media_height, mime_type );
+
+        // make a new plugin
+        LLPluginClassMedia* media_source = new LLPluginClassMedia(this);
+
+        // tell the plugin what size we asked for
+        media_source->setSize( media_width, media_height );
+
+        // Use the launcher start and initialize the plugin 
+#if LL_DARWIN || LL_LINUX
+        std::string launcher_name( "SLPlugin" );
+#elif LL_WINDOWS
+        std::string launcher_name( "SLPlugin.exe" );
+#endif
+        media_source->init( launcher_name, plugin_name );
+        media_source->setDisableTimeout(mDisableTimeout);
+
+        // make a new panel and save parameters
+        mediaPanel* panel = new mediaPanel;
+        panel->mMediaSource = media_source;
+        panel->mStartUrl = url;
+        panel->mMimeType = mime_type;
+        panel->mMediaWidth = media_width;
+        panel->mMediaHeight = media_height;
+        panel->mTextureWidth = 0;
+        panel->mTextureHeight = 0;
+        panel->mTextureScaleX = 0;
+        panel->mTextureScaleY = 0;
+        panel->mMediaTextureHandle = 0;
+        panel->mPickTextureHandle = 0;
+        panel->mAppTextureCoordsOpenGL = false; // really need an 'undefined' state here too
+        panel->mReadyToRender = false;
+
+        // look through current media panels to find an unused index number
+        bool id_exists = true;
+        for( int nid = 0; nid < mMaxPanels; ++nid )
+        {
+                // does this id exist already?
+                id_exists = false;
+                for( int pid = 0; pid < (int)mMediaPanels.size(); ++pid )
+                {
+                        if ( nid == mMediaPanels[ pid ]->mId )
+                        {
+                                id_exists = true;
+                                break;
+                        };
+                };
+
+                // id wasn't found so we can use it
+                if ( ! id_exists )
+                {
+                        panel->mId = nid; 
+                        break;
+                };
+        };
+
+        // if we get here and this flag is set, there is no room for any more panels
+        if ( id_exists )
+        {
+                std::cout << "No room for any more panels" << std::endl;
+        }
+        else
+        {
+                // now we have the ID we can use it to make the 
+                // pick texture (id is baked into texture pixels)
+                makePickTexture( panel->mId, &panel->mPickTextureHandle, &panel->mPickTexturePixels );
+
+                // save this in the list of panels
+                mMediaPanels.push_back( panel );
+
+                // select the panel that was just created
+                selectPanel( panel );
+
+                // load and start the URL
+                panel->mMediaSource->loadURI( url );
+                panel->mMediaSource->start();
+
+                std::cout << "Adding new media panel for " << url << "(" << media_width << "x" << media_height << ") with index " << panel->mId << " - total panels = " << mMediaPanels.size() << std::endl;
+        }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::updateMediaPanel( mediaPanel* panel )
+{
+//      checkGLError("LLMediaPluginTest::updateMediaPanel");
+        
+        if ( ! panel ) 
+                return;
+        
+        if(!panel->mMediaSource || !panel->mMediaSource->textureValid())
+        {
+                panel->mReadyToRender = false;
+                return;
+        }
+                
+        // take a reference copy of the plugin values since they 
+        // might change during this lifetime of this function
+        int plugin_media_width = panel->mMediaSource->getWidth();
+        int plugin_media_height = panel->mMediaSource->getHeight();
+        int plugin_texture_width = panel->mMediaSource->getBitsWidth();
+        int plugin_texture_height = panel->mMediaSource->getBitsHeight();
+
+        // If the texture isn't created or the media or texture dimensions changed AND
+        // the sizes are valid then we need to delete the old media texture (if necessary) 
+        // then make a new one.
+        if ((panel->mMediaTextureHandle == 0 ||
+                 panel->mMediaWidth != plugin_media_width ||
+                 panel->mMediaHeight != plugin_media_height ||           
+                 panel->mTextureWidth != plugin_texture_width ||
+                 panel->mTextureHeight != plugin_texture_height) &&
+                ( plugin_media_width > 0 && plugin_media_height > 0 && 
+                  plugin_texture_width > 0 && plugin_texture_height > 0 ) )
+        {
+                std::cout << "Valid media size (" <<  plugin_media_width << " x " << plugin_media_height 
+                                << ") and texture size (" <<  plugin_texture_width << " x " << plugin_texture_height 
+                                << ") for panel with ID=" << panel->mId << " - making texture" << std::endl;
+
+                // delete old GL texture
+                if ( isTexture( panel->mMediaTextureHandle ) )
+                {
+                        std::cerr << "updateMediaPanel: deleting texture " << panel->mMediaTextureHandle << std::endl;
+                        glDeleteTextures( 1, &panel->mMediaTextureHandle );
+                        panel->mMediaTextureHandle = 0;
+                }
+                
+                std::cerr << "before: pick texture is " << panel->mPickTextureHandle << ", media texture is " << panel->mMediaTextureHandle << std::endl;
+                
+                // make a GL texture based on the dimensions the plugin told us
+                GLuint new_texture = 0;
+                glGenTextures( 1, &new_texture );
+                
+                checkGLError("glGenTextures");
+
+                std::cout << "glGenTextures returned " << new_texture << std::endl;
+
+                panel->mMediaTextureHandle = new_texture;
+
+                bindTexture( panel->mMediaTextureHandle );
+
+                std::cout << "Setting texture size to " << plugin_texture_width << " x " << plugin_texture_height << std::endl;
+                glTexImage2D( GL_TEXTURE_2D, 0,
+                        GL_RGB,
+                                plugin_texture_width, plugin_texture_height,
+                                        0, GL_RGB, GL_UNSIGNED_BYTE,
+                                                0 );
+
+
+                std::cerr << "after: pick texture is " << panel->mPickTextureHandle << ", media texture is " << panel->mMediaTextureHandle << std::endl;
+        };
+        
+        // update our record of the media and texture dimensions
+        // NOTE: do this after we we check for sizes changes
+        panel->mMediaWidth = plugin_media_width;
+        panel->mMediaHeight = plugin_media_height;
+        panel->mTextureWidth = plugin_texture_width;
+        panel->mTextureHeight = plugin_texture_height;
+        if ( plugin_texture_width > 0 )
+        {
+                panel->mTextureScaleX = (double)panel->mMediaWidth / (double)panel->mTextureWidth;
+        };
+        if ( plugin_texture_height > 0 )
+        {
+                panel->mTextureScaleY = (double)panel->mMediaHeight / (double)panel->mTextureHeight;
+        };
+
+        // update the flag which tells us if the media source uses OprnGL coords or not.
+        panel->mAppTextureCoordsOpenGL = panel->mMediaSource->getTextureCoordsOpenGL();
+
+        // Check to see if we have enough to render this panel.
+        // If we do, set a flag that the display functions use so 
+        // they only render a panel with media if it's ready.
+        if ( panel->mMediaWidth < 0 ||
+                 panel->mMediaHeight < 0 ||
+                 panel->mTextureWidth < 1 ||
+                 panel->mTextureHeight < 1 ||
+                 panel->mMediaTextureHandle == 0 )
+        {
+                panel->mReadyToRender = false;
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::replaceMediaPanel( mediaPanel* panel, std::string url )
+{
+        // no media panels so we can't change anything - have to add
+        if ( mMediaPanels.size() == 0 ) 
+                return;
+
+        // sanity check
+        if ( ! panel ) 
+                return;
+        
+        int index;
+        for(index = 0; index < (int)mMediaPanels.size(); index++)
+        {
+                if(mMediaPanels[index] == panel)
+                        break;
+        }
+        
+        if(index >= (int)mMediaPanels.size())
+        {
+                // panel isn't in mMediaPanels
+                return;
+        }
+                        
+        std::cout << "Replacing media panel with index " << panel->mId << std::endl;
+
+        int panel_id = panel->mId;
+
+        if(mSelectedPanel == panel)
+                mSelectedPanel = NULL;
+
+        delete panel;
+
+        // Get the plugin filename using the URL
+        std::string mime_type = mimeTypeFromUrl( url );
+        std::string plugin_name = pluginNameFromMimeType( mime_type );
+
+        // create a random size for the new media
+        int media_width;
+        int media_height;
+        getRandomMediaSize( media_width, media_height, mime_type );
+
+        // make a new plugin
+        LLPluginClassMedia* media_source = new LLPluginClassMedia(this);
+
+        // tell the plugin what size we asked for
+        media_source->setSize( media_width, media_height );
+
+        // Use the launcher start and initialize the plugin 
+#if LL_DARWIN || LL_LINUX
+        std::string launcher_name( "SLPlugin" );
+#elif LL_WINDOWS
+        std::string launcher_name( "SLPlugin.exe" );
+#endif
+        media_source->init( launcher_name, plugin_name );
+        media_source->setDisableTimeout(mDisableTimeout);
+
+        // make a new panel and save parameters
+        panel = new mediaPanel;
+        panel->mMediaSource = media_source;
+        panel->mStartUrl = url;
+        panel->mMimeType = mime_type;
+        panel->mMediaWidth = media_width;
+        panel->mMediaHeight = media_height;
+        panel->mTextureWidth = 0;
+        panel->mTextureHeight = 0;
+        panel->mTextureScaleX = 0;
+        panel->mTextureScaleY = 0;
+        panel->mMediaTextureHandle = 0;
+        panel->mPickTextureHandle = 0;
+        panel->mAppTextureCoordsOpenGL = false; // really need an 'undefined' state here too
+        panel->mReadyToRender = false;
+
+        panel->mId = panel_id; 
+        
+        // Replace the entry in the panels array
+        mMediaPanels[index] = panel;
+
+        // now we have the ID we can use it to make the 
+        // pick texture (id is baked into texture pixels)
+        makePickTexture( panel->mId, &panel->mPickTextureHandle, &panel->mPickTexturePixels );
+
+        // select the panel that was just created
+        selectPanel( panel );
+
+        // load and start the URL
+        panel->mMediaSource->loadURI( url );
+        panel->mMediaSource->start();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::getRandomMediaSize( int& width, int& height, std::string mime_type )
+{
+        // Make a new media source with a random size which we'll either 
+        // directly or the media plugin will tell us what it wants later.
+        // Use a random size so we can test support for weird media sizes.
+        // (Almost everything else will get filled in later once the
+        // plugin responds)
+        // NB. Do we need to enforce that width is on 4 pixel boundary?
+        width = ( ( rand() % 170 ) + 30 ) * 4;
+        height = ( ( rand() % 170 ) + 30 ) * 4;
+
+        // adjust this random size if it's a browser so we get 
+        // a more useful size for testing.. 
+        if ( mime_type == "text/html" || mime_type == "example/example"  )
+        {
+                width = ( ( rand() % 100 ) + 100 ) * 4;
+                height = ( width * ( ( rand() % 400 ) + 1000 ) ) / 1000;
+        };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::remMediaPanel( mediaPanel* panel )
+{
+        // always leave one panel
+        if ( mMediaPanels.size() == 1 ) 
+                return;
+
+        // sanity check - don't think this can happen but see above for a case where it might...
+        if ( ! panel ) 
+                return;
+
+        std::cout << "Removing media panel with index " << panel->mId << " - total panels = " << mMediaPanels.size() - 1 << std::endl;
+
+        if(mSelectedPanel == panel)
+                mSelectedPanel = NULL;
+
+        delete panel;   
+
+        // remove from storage list
+        for( int i = 0; i < (int)mMediaPanels.size(); ++i )
+        {
+                if ( mMediaPanels[ i ] == panel )
+                {
+                        mMediaPanels.erase( mMediaPanels.begin() + i );
+                        break;
+                };
+        };
+
+        // select the first panel 
+        selectPanel( mMediaPanels[ 0 ] );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::updateStatusBar()
+{
+        if ( ! mSelectedPanel )
+                return;
+
+        // cache results - this is a very slow function
+        static int cached_id = -1;
+        static int cached_media_width = -1;
+        static int cached_media_height = -1;
+        static int cached_texture_width = -1;
+        static int cached_texture_height = -1;
+        static bool cached_supports_browser_media = true;
+        static bool cached_supports_time_media = false;
+        static int cached_movie_time = -1;
+
+        static std::string cached_plugin_version = "";
+        if ( 
+                 cached_id == mSelectedPanel->mId &&
+                 cached_media_width == mSelectedPanel->mMediaWidth &&
+                 cached_media_height  == mSelectedPanel->mMediaHeight &&
+                 cached_texture_width == mSelectedPanel->mTextureWidth &&
+                 cached_texture_height == mSelectedPanel->mTextureHeight &&
+                 cached_supports_browser_media == mSelectedPanel->mMediaSource->pluginSupportsMediaBrowser() && 
+                 cached_supports_time_media == mSelectedPanel->mMediaSource->pluginSupportsMediaTime() &&
+                 cached_plugin_version == mSelectedPanel->mMediaSource->getPluginVersion() &&
+                 cached_movie_time == (int)mSelectedPanel->mMediaSource->getCurrentTime()
+           )
+        {
+                // nothing changed so don't spend time in this shitty function
+                return;
+        };
+
+        std::ostringstream stream( "" );
+        
+        stream.str( "" );
+        stream.clear();
+
+        stream << "Id: ";
+        stream << std::setw( 2 ) << std::setfill( '0' );
+        stream << mSelectedPanel->mId;
+        stream << " | ";
+        stream << "Media: ";
+        stream << std::setw( 3 ) << std::setfill( '0' );
+        stream << mSelectedPanel->mMediaWidth;
+        stream << " x ";
+        stream << std::setw( 3 ) << std::setfill( '0' );
+        stream << mSelectedPanel->mMediaHeight;
+        stream << " | ";
+        stream << "Texture: ";
+        stream << std::setw( 4 ) << std::setfill( '0' );
+        stream << mSelectedPanel->mTextureWidth;
+        stream << " x ";
+        stream << std::setw( 4 ) << std::setfill( '0' );
+        stream << mSelectedPanel->mTextureHeight;
+        stream << " | ";
+        if ( mSelectedPanel->mMediaSource->pluginSupportsMediaBrowser() )
+                stream << "BROWSER";
+        else
+        if ( mSelectedPanel->mMediaSource->pluginSupportsMediaTime() )
+                stream << "TIME   ";
+        stream << " | ";
+        stream << mSelectedPanel->mMediaSource->getPluginVersion();
+        stream << " | ";
+        if ( mSelectedPanel->mMediaSource->pluginSupportsMediaTime() )
+        {
+                stream << std::setw( 3 ) << std::setfill( '0' );
+                stream << (int)mSelectedPanel->mMediaSource->getCurrentTime();
+                stream << " / ";
+                stream << std::setw( 3 ) << std::setfill( '0' );
+                stream << (int)mSelectedPanel->mMediaSource->getDuration();
+                stream << " @ ";
+                stream << (int)mSelectedPanel->mMediaSource->getCurrentPlayRate();
+                stream << " | ";
+        };
+
+        glutSetWindow( mBottomGLUIWindow->get_glut_window_id() );
+        mStatusText->set_text( const_cast< char*>( stream.str().c_str() ) );
+        glutSetWindow( mAppWindow );
+
+        // caching
+        cached_id = mSelectedPanel->mId;
+        cached_media_width = mSelectedPanel->mMediaWidth;
+        cached_media_height = mSelectedPanel->mMediaHeight;
+        cached_texture_width = mSelectedPanel->mTextureWidth;
+        cached_texture_height = mSelectedPanel->mTextureHeight;
+        cached_supports_browser_media = mSelectedPanel->mMediaSource->pluginSupportsMediaBrowser();
+        cached_supports_time_media = mSelectedPanel->mMediaSource->pluginSupportsMediaTime();
+        cached_plugin_version = mSelectedPanel->mMediaSource->getPluginVersion();
+        cached_movie_time = (int)mSelectedPanel->mMediaSource->getCurrentTime();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::dumpPanelInfo()
+{
+        std::cout << std::endl << "===== Media Panels =====" << std::endl;
+        for( int i = 0; i < (int)mMediaPanels.size(); ++i )
+        {
+                std::cout << std::setw( 2 ) << std::setfill( '0' );
+                std::cout << i + 1 << "> ";
+                std::cout << "Id: ";
+                std::cout << std::setw( 2 ) << std::setfill( '0' );
+                std::cout << mMediaPanels[ i ]->mId;
+                std::cout << " | ";
+                std::cout << "Media: ";
+                std::cout << std::setw( 3 ) << std::setfill( '0' );
+                std::cout << mMediaPanels[ i ]->mMediaWidth;
+                std::cout << " x ";
+                std::cout << std::setw( 3 ) << std::setfill( '0' );
+                std::cout << mMediaPanels[ i ]->mMediaHeight;
+                std::cout << " | ";
+                std::cout << "Texture: ";
+                std::cout << std::setw( 4 ) << std::setfill( '0' );
+                std::cout << mMediaPanels[ i ]->mTextureWidth;
+                std::cout << " x ";
+                std::cout << std::setw( 4 ) << std::setfill( '0' );
+                std::cout << mMediaPanels[ i ]->mTextureHeight;
+                std::cout << " | ";
+                if ( mMediaPanels[ i ] == mSelectedPanel )
+                        std::cout << "(selected)";
+
+                std::cout << std::endl;
+        };
+        std::cout << "========================" << std::endl;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLMediaPluginTest::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
+{
+        // Uncomment this to make things much, much quieter.
+//      return;
+        
+        switch(event)
+        {
+                case MEDIA_EVENT_CONTENT_UPDATED:
+                        // too spammy -- don't log these
+//                      std::cerr <<  "Media event:  MEDIA_EVENT_CONTENT_UPDATED " << std::endl;
+                break;
+
+                case MEDIA_EVENT_TIME_DURATION_UPDATED:
+                        // too spammy -- don't log these
+//                      std::cerr <<  "Media event:  MEDIA_EVENT_TIME_DURATION_UPDATED, time is " << self->getCurrentTime() << " of " << self->getDuration() << std::endl;
+                break;
+
+                case MEDIA_EVENT_SIZE_CHANGED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_SIZE_CHANGED " << std::endl;
+                break;
+
+                case MEDIA_EVENT_CURSOR_CHANGED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << self->getCursorName() << std::endl;
+                break;
+
+                case MEDIA_EVENT_NAVIGATE_BEGIN:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_NAVIGATE_BEGIN " << std::endl;
+                break;
+
+                case MEDIA_EVENT_NAVIGATE_COMPLETE:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_NAVIGATE_COMPLETE, result string is: " << self->getNavigateResultString() << std::endl;
+                break;
+
+                case MEDIA_EVENT_PROGRESS_UPDATED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_PROGRESS_UPDATED, loading at " << self->getProgressPercent() << "%" << std::endl;
+                break;
+
+                case MEDIA_EVENT_STATUS_TEXT_CHANGED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_STATUS_TEXT_CHANGED, new status text is: " << self->getStatusText() << std::endl;
+                break;
+
+                case MEDIA_EVENT_NAME_CHANGED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_NAME_CHANGED, new name is: " << self->getMediaName() << std::endl;
+                        glutSetWindowTitle( self->getMediaName().c_str() );
+                break;
+
+                case MEDIA_EVENT_LOCATION_CHANGED:
+                {
+                        std::cerr <<  "Media event:  MEDIA_EVENT_LOCATION_CHANGED, new uri is: " << self->getLocation() << std::endl;
+                        mediaPanel* panel = findMediaPanel(self);
+                        if(panel != NULL)
+                        {
+                                panel->mStartUrl = self->getLocation();
+                                if(panel == mSelectedPanel)
+                                {
+                                        mUrlEdit->set_text(const_cast<char*>(panel->mStartUrl.c_str()) );
+                                }
+                        }
+                }
+                break;
+
+                case MEDIA_EVENT_CLICK_LINK_HREF:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_CLICK_LINK_HREF, uri is " << self->getClickURL() << std::endl;
+                break;
+                
+                case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is " << self->getClickURL() << std::endl;
+                break;
+                
+                case MEDIA_EVENT_PLUGIN_FAILED:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_PLUGIN_FAILED" << std::endl;
+                break;
+
+                case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
+                        std::cerr <<  "Media event:  MEDIA_EVENT_PLUGIN_FAILED_LAUNCH" << std::endl;
+                break;
+        }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+static void gluiCallbackWrapper( int control_id )
+{
+        if ( gApplication )
+                gApplication->gluiCallback( control_id );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutReshape( int width, int height )
+{
+        if ( gApplication )
+                gApplication->reshape( width, height );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutDisplay()
+{
+        if ( gApplication )
+                gApplication->display();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutIdle(int update_ms)
+{
+        GLUI_Master.set_glutTimerFunc( update_ms, glutIdle, update_ms);
+
+        if ( gApplication )
+                gApplication->idle();
+
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutKeyboard( unsigned char key, int x, int y )
+{
+        if ( gApplication )
+                gApplication->keyboard( key );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMousePassive( int x, int y )
+{
+        if ( gApplication )
+                gApplication->mousePassive( x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseMove( int x , int y )
+{
+        if ( gApplication )
+                gApplication->mouseMove( x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseButton( int button, int state, int x, int y )
+{
+        if ( gApplication )
+                gApplication->mouseButton( button, state, x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+int main( int argc, char* argv[] )
+{
+#if LL_DARWIN
+        // Set the current working directory to <application bundle>/Contents/Resources/
+        CFURLRef resources_url = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle());
+        if(resources_url != NULL)
+        {
+                CFStringRef resources_string = CFURLCopyFileSystemPath(resources_url, kCFURLPOSIXPathStyle);
+                CFRelease(resources_url);
+                if(resources_string != NULL)
+                {
+                        char buffer[PATH_MAX] = "";
+                        if(CFStringGetCString(resources_string, buffer, sizeof(buffer), kCFStringEncodingUTF8))
+                        {
+                                chdir(buffer);
+                        }
+                        CFRelease(resources_string);
+                }
+        }
+#endif
+
+        glutInit( &argc, argv );
+        glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB );
+
+        const int app_window_x = 80;
+        const int app_window_y = 0;
+        const int app_window_width = 960;
+        const int app_window_height = 960;
+
+        glutInitWindowPosition( app_window_x, app_window_y );
+        glutInitWindowSize( app_window_width, app_window_height );
+
+        int app_window_handle = glutCreateWindow( "LLMediaPluginTest" );
+
+        glutDisplayFunc( glutDisplay );
+
+        GLUI_Master.set_glutReshapeFunc( glutReshape );
+        GLUI_Master.set_glutKeyboardFunc( glutKeyboard );
+        GLUI_Master.set_glutMouseFunc( glutMouseButton );
+
+        glutPassiveMotionFunc( glutMousePassive );
+        glutMotionFunc( glutMouseMove );
+
+        glutSetWindow( app_window_handle );
+
+        gApplication = new LLMediaPluginTest( app_window_handle, app_window_width, app_window_height );
+        
+        // update at approximately 60hz
+        int update_ms = 1000 / 60;
+        
+        GLUI_Master.set_glutTimerFunc( update_ms, glutIdle, update_ms);
+
+        glutMainLoop();
+        
+        delete gApplication;
+}
diff --git a/linden/indra/test_apps/llplugintest/llmediaplugintest.h b/linden/indra/test_apps/llplugintest/llmediaplugintest.h
new file mode 100644
index 0000000..c2b2bab
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/llmediaplugintest.h
@@ -0,0 +1,201 @@
+/**
+ * @file LLMediaPluginTest.cpp
+ * @brief Primary test application for LLMedia (Separate Process) Plugin system
+ *
+ * $LicenseInfo:firstyear=2008&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://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$
+ */
+
+#ifndef LL_MEDIA_PLUGIN_TEST_H
+#define LL_MEDIA_PLUGIN_TEST_H
+
+#include <vector>
+#include <string>
+#include "llpluginclassmedia.h"
+#include "llgl.h"
+
+// Forward declarations
+class GLUI_Rotation;
+class GLUI_Translation;
+class GLUI_Listbox;
+class GLUI_EditText;
+class GLUI_StaticText;
+class GLUI;
+class GLUI_Button;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+struct mediaPanel
+{
+        public:
+                mediaPanel();
+                ~mediaPanel();
+                int mId;
+                std::string mStartUrl;
+                std::string mMimeType;
+                LLPluginClassMedia *mMediaSource;
+                int mMediaWidth;
+                int mMediaHeight;
+                int mTextureWidth;
+                int mTextureHeight;
+                double mTextureScaleX;
+                double mTextureScaleY;
+                GLuint mMediaTextureHandle;
+                GLuint mPickTextureHandle;
+                unsigned char* mPickTexturePixels;
+                bool mAppTextureCoordsOpenGL;
+                bool mReadyToRender;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+class LLMediaPluginTest : public LLPluginClassMediaOwner
+{
+        public:
+                LLMediaPluginTest( int app_window, int window_width, int window_height );
+                ~LLMediaPluginTest();
+
+                void reshape( int width, int height );
+                void display();
+                void idle();
+                void gluiCallback( int control_id );
+                void keyboard( int key );
+                void mousePassive( int x, int y );
+                void mouseButton( int button, int state, int x, int y );
+                void mouseMove( int x, int y );
+
+                void bindTexture(GLuint texture, GLint row_length = 0, GLint alignment = 1);
+                bool checkGLError(const char *name = "OpenGL");
+                void drawGeometry( int panel );
+                void startPanelHighlight( float red, float green, float blue, float line_width );
+                void endPanelHighlight();
+                enum { DrawTypePickTexture, DrawTypeMediaTexture };
+                void draw( int draw_type );
+                void windowPosToTexturePos( int window_x, int window_y, int& media_x, int& media_y, int& id );
+
+                void addMediaPanel( std::string url );
+                void updateMediaPanel( mediaPanel* panel );
+                void remMediaPanel( mediaPanel* panel );
+                void replaceMediaPanel( mediaPanel* panel, std::string url );
+                void getRandomMediaSize( int& width, int& height, std::string mime_type );
+                void navigateToNewURI( std::string uri );
+        void initUrlHistory( std::string uri );
+                void selectPanelById( int id );
+                void selectPanel( mediaPanel* panel );
+                mediaPanel* findMediaPanel( LLPluginClassMedia* panel );
+                void makePickTexture( int id, GLuint* texture_handle, unsigned char** texture_pixels );
+                void makeChrome();
+                void resetView();
+
+                void dumpPanelInfo();
+                void updateStatusBar();
+
+        // Inherited from LLPluginClassMediaOwner
+        /*virtual*/ void handleMediaEvent(LLPluginClassMedia* self, LLPluginClassMediaOwner::EMediaEvent);
+
+        private:
+                const int mVersionMajor;
+                const int mVersionMinor;
+                const int mVersionPatch;
+                const int mMaxPanels;
+                int mAppWindow;
+                int mWindowWidth;
+                int mWindowHeight;
+                int mCurMouseX;
+                int mCurMouseY;
+                unsigned char mPixelReadColor[ 3 ];
+                bool mFuzzyMedia;
+                const std::string mHomeWebUrl;
+
+                std::vector< mediaPanel* > mMediaPanels;
+                mediaPanel* mSelectedPanel;
+                std::string mimeTypeFromUrl( std::string& url );
+                std::string pluginNameFromMimeType( std::string& mime_type );
+
+                GLUI_Rotation* mViewRotationCtrl;
+                GLUI_Translation* mViewScaleCtrl;
+                GLUI_Translation* mViewTranslationCtrl;
+                float mViewportAspect;
+                float mViewPos[ 3 ];
+                float mViewRotation[ 16 ];
+
+                int mIdControlAddPanel;
+                int mIdControlRemPanel;
+
+                std::vector< std::pair< std::string, std::string > > mBookmarks;
+                GLUI_Listbox* mBookmarkList;
+                int mIdBookmarks;
+                int mIdUrlEdit;
+                GLUI_EditText* mUrlEdit;
+        int mIdUrlInitHistoryEdit;
+                GLUI_EditText* mUrlInitHistoryEdit;
+                int mSelBookmark;
+                int mIdRandomPanelCount;
+                int mRandomPanelCount;
+                int mIdRandomBookmarks;
+                int mRandomBookmarks;
+                int mIdDisableTimeout;
+                int mDisableTimeout;
+                int mIdControlCrashPlugin;
+                int mIdControlHangPlugin;
+                int mIdControlExitApp;
+
+                GLUI* mGluiMediaTimeControlWindow;
+                int mIdMediaTimeControlPlay;
+                int mIdMediaTimeControlLoop;
+                int mIdMediaTimeControlPause;
+                int mIdMediaTimeControlStop;
+                int mIdMediaTimeControlSeek;
+                int mIdMediaTimeControlVolume;
+                int mMediaTimeControlVolume;
+                int mIdMediaTimeControlSeekSeconds;
+                int mMediaTimeControlSeekSeconds;
+                int mIdMediaTimeControlRewind;
+                int mIdMediaTimeControlFastForward;
+
+                GLUI* mGluiMediaBrowserControlWindow;
+                int mIdMediaBrowserControlBack;
+                GLUI_Button* mMediaBrowserControlBackButton;
+                int mIdMediaBrowserControlStop;
+                int mIdMediaBrowserControlForward;
+                GLUI_Button* mMediaBrowserControlForwardButton;
+                bool mGluiMediaTimeControlWindowFlag;
+                bool mGluiMediaBrowserControlWindowFlag;
+                bool mMediaBrowserControlBackButtonFlag;
+                bool mMediaBrowserControlForwardButtonFlag;
+                int mIdMediaBrowserControlHome;
+                int mIdMediaBrowserControlReload;
+                int mIdMediaBrowserControlClearCache;
+                int mIdMediaBrowserControlClearCookies;
+                int mIdMediaBrowserControlEnableCookies;
+                int mMediaBrowserControlEnableCookies;
+
+                GLUI* mBottomGLUIWindow;
+                GLUI_StaticText* mStatusText;
+};
+
+#endif  // LL_MEDIA_PLUGIN_TEST_H
+
diff --git a/linden/indra/test_apps/llplugintest/media_mappings.txt b/linden/indra/test_apps/llplugintest/media_mappings.txt
new file mode 100644
index 0000000..74188bc
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/media_mappings.txt
@@ -0,0 +1,3 @@
+Flash demo_media_plugin_flash.dll
+ColNoise demo_media_plugin.dll
+CheckBounce demo_media_plugin_2.dll
diff --git a/linden/indra/test_apps/llplugintest/media_plugin_test.cpp b/linden/indra/test_apps/llplugintest/media_plugin_test.cpp
new file mode 100644
index 0000000..8e42fa7
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/media_plugin_test.cpp
@@ -0,0 +1,511 @@
+/**
+ * @file demo_plugin.cpp
+ * @brief Test plugin to be loaded by the llplugin testbed.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "indra_constants.h"
+
+#include "lltimer.h" // for ms_sleep()
+#include "llpumpio.h"
+#include "llapr.h"
+#include "llerrorcontrol.h"
+#include "llpluginclassmedia.h"
+
+#include <string>
+#include <iostream>
+#include <stdlib.h>
+#include <time.h>
+
+#include "llmediaplugintest.h" // for GLUT headers
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+class mediaPluginTest : public LLPluginClassMediaOwner
+{
+        private:
+                int mAppWindowWidth;
+                int mAppWindowHeight;
+                LLPluginClassMedia* mMediaSource;
+                int mAppTextureWidth;
+                int mAppTextureHeight;
+                bool mAppTextureCoordsOpenGL;
+                GLuint mAppTexture;
+                std::string mAppWindowName;
+                std::string mHomeUrl;
+                std::string mLauncherFilename;
+                std::string mPluginFilename;
+
+                LLPluginClassMedia *mPlugin;
+
+        public:
+                mediaPluginTest(const std::string &launcher_filename, const std::string &plugin_filename) :
+                        mAppWindowWidth( 800 ),
+                        mAppWindowHeight( 600 ),
+                        mAppTextureWidth( 0 ),
+                        mAppTextureHeight( 0 ),
+                        mAppTextureCoordsOpenGL(false),
+                        mAppTexture( 0 ),
+                        mAppWindowName( "Media Simple Test" ),
+                        mHomeUrl( "" )
+                {
+                        mLauncherFilename = launcher_filename;
+                        mMediaSource = new LLPluginClassMedia(this);
+                        mMediaSource->init(launcher_filename, plugin_filename);
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                virtual ~mediaPluginTest()
+                {
+                        delete mMediaSource;
+                };
+                
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void createTexture()
+                {
+                        // create the texture used to display the browser data
+                        if(mMediaSource->textureValid())
+                        {
+                                mAppTextureWidth = mMediaSource->getTextureWidth();
+                                mAppTextureHeight = mMediaSource->getTextureHeight();
+                                mAppTextureCoordsOpenGL = mMediaSource->getTextureCoordsOpenGL();
+                                
+                                if(mAppTexture != 0)
+                                {
+                                        glDeleteTextures( 1, &mAppTexture );
+                                        mAppTexture = 0;
+                                }
+                                
+                                glGenTextures( 1, &mAppTexture );
+                                glBindTexture( GL_TEXTURE_2D, mAppTexture );
+                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+                                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                                glTexImage2D( GL_TEXTURE_2D, 0,
+                                                mMediaSource->getTextureFormatInternal(),
+                                                mAppTextureWidth, 
+                                                mAppTextureHeight,
+                                                0, 
+                                                mMediaSource->getTextureFormatPrimary(), 
+                                                mMediaSource->getTextureFormatType(), 
+                                                NULL );
+                        }
+                }
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void initGL()
+                {
+                        // OpenGL initialization
+                        glClearColor( 0.0f, 0.0f, 0.0f, 0.5f);
+                        glEnable( GL_COLOR_MATERIAL );
+                        glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );
+                        glEnable( GL_TEXTURE_2D );
+                        glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+                        glEnable( GL_CULL_FACE );
+                }
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void reshape( int width, int height )
+                {
+                        if ( height == 0 )
+                                height = 1;
+
+                        glMatrixMode( GL_PROJECTION );
+                        glLoadIdentity();
+
+                        glViewport( 0, 0, width, height );
+                        glOrtho( 0.0f, width, height, 0.0f, -1.0f, 1.0f );
+
+                        // we use these values elsewhere so save
+                        mAppWindowWidth = width;
+                        mAppWindowHeight = height;
+                        
+                        // Request a media size change
+                        mMediaSource->setSize(width, height);
+                        
+                        glMatrixMode( GL_MODELVIEW );
+                        glLoadIdentity();
+
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void idle()
+                {
+                        // lots of updates for smooth motion
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void display()
+                {
+                        mMediaSource->idle();
+
+                        // Check whether the texture needs to be recreated.
+                        if(mMediaSource->textureValid())
+                        {
+                                if(
+                                        (mAppTextureWidth != mMediaSource->getTextureWidth() || mAppTextureHeight != mMediaSource->getTextureHeight()) &&
+                                        (mAppWindowWidth == mMediaSource->getWidth() && mAppWindowHeight == mMediaSource->getHeight())
+                                )
+                                {
+                                        // Attempt to (re)create the texture
+                                        createTexture();
+                                }
+                        }
+                                                
+                        // clear screen
+                        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+                        glLoadIdentity();
+                        
+                        if(mAppTexture != 0)
+                        {
+                                // use the browser texture
+                                glBindTexture( GL_TEXTURE_2D, mAppTexture );
+
+                                // If dirty, update the texture.
+                                LLRect dirtyRect;
+                                if(!mMediaSource->textureValid())
+                                {
+//                                      LL_DEBUGS("media_plugin_test") << "Resize in progress, skipping update..." << LL_ENDL;
+                                }
+                                else if(mAppWindowWidth != mMediaSource->getWidth() || mAppWindowHeight != mMediaSource->getHeight())
+                                {
+                                        // A resize is in progress.  Just wait for it...
+                                }
+                                else if(mMediaSource->getDirty(&dirtyRect))
+                                {
+                                        // grab the page
+                                        const unsigned char* pixels = mMediaSource->getBitsData();
+                                        if ( pixels )
+                                        {
+                                                // write them into the texture
+                                                
+                                                // Paranoia: intersect dirtyRect with (0, 0, mAppTextureWidth, mAppTextureHeight)?
+
+                                                int x_offset = dirtyRect.mLeft;
+                                                int y_offset = dirtyRect.mBottom;
+                                                int width = dirtyRect.mRight - dirtyRect.mLeft;
+                                                int height = dirtyRect.mTop - dirtyRect.mBottom;
+
+                                                LL_DEBUGS("media_plugin_test") << "Updating, dirty rect is (" 
+                                                        << dirtyRect.mLeft << ", " 
+                                                        << dirtyRect.mTop << ", " 
+                                                        << dirtyRect.mRight << ", " 
+                                                        << dirtyRect.mBottom << "), update params are: (" 
+                                                        << x_offset << ", " 
+                                                        << y_offset << ", " 
+                                                        << width << ", " 
+                                                        << height << ")" 
+                                                        << LL_ENDL; 
+                                                
+                                                // Offset the pixels pointer properly
+                                                pixels += (y_offset * mMediaSource->getTextureDepth() * mMediaSource->getTextureWidth());
+                                                pixels += (x_offset * mMediaSource->getTextureDepth());
+                                                
+                                                glPixelStorei(GL_UNPACK_ROW_LENGTH, mMediaSource->getTextureWidth());
+                                                
+                                                glTexSubImage2D( GL_TEXTURE_2D, 0, 
+                                                        x_offset, 
+                                                        y_offset,
+                                                        width, 
+                                                        height,
+                                                        mMediaSource->getTextureFormatPrimary(), 
+                                                        mMediaSource->getTextureFormatType(), 
+                                                        pixels );
+                                                
+                                                mMediaSource->resetDirty();
+                                        }
+                                }
+                                
+                                // scale the texture so that it fits the screen
+                                GLdouble media_texture_x = mAppWindowWidth / (double)mAppTextureWidth;
+                                GLdouble media_texture_y = mAppWindowHeight / (double)mAppTextureHeight;
+
+                                // draw the single quad full screen (orthographic)
+
+                                glEnable( GL_TEXTURE_2D );
+                                glColor3f( 1.0f, 1.0f, 1.0f );
+                                glBegin( GL_QUADS );
+                                if(mAppTextureCoordsOpenGL)
+                                {
+                                        // Render the texture as per opengl coords (where 0,0 is at the lower left)
+                                        glTexCoord2d( 0, 0 );
+                                        glVertex2d( 0, 0 );
+
+                                        glTexCoord2d( 0 , media_texture_y );
+                                        glVertex2d( 0, mAppWindowHeight);
+
+                                        glTexCoord2d( media_texture_x, media_texture_y );
+                                        glVertex2d( mAppWindowWidth , mAppWindowHeight);
+
+                                        glTexCoord2d( media_texture_x, 0 );
+                                        glVertex2d( mAppWindowWidth, 0 );
+                                }
+                                else
+                                {
+                                        // Render the texture the "other way round" (where 0,0 is at the upper left)
+                                        glTexCoord2d( 0, media_texture_y );
+                                        glVertex2d( 0, 0 );
+
+                                        glTexCoord2d( 0 , 0 );
+                                        glVertex2d( 0, mAppWindowHeight);
+
+                                        glTexCoord2d( media_texture_x, 0 );
+                                        glVertex2d( mAppWindowWidth , mAppWindowHeight);
+
+                                        glTexCoord2d( media_texture_x, media_texture_y );
+                                        glVertex2d( mAppWindowWidth, 0 );
+                                }
+                                glEnd();
+
+                        }
+                        
+                        glutSwapBuffers();
+                };
+                
+                
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                MASK getModifiers(void)
+                {
+                        MASK result = 0;
+                        
+                        int modifiers = glutGetModifiers();
+                        
+                        if(modifiers & GLUT_ACTIVE_SHIFT)
+                                result |= MASK_SHIFT;
+                        if(modifiers & GLUT_ACTIVE_CTRL)
+                                result |= MASK_CONTROL;
+                        if(modifiers & GLUT_ACTIVE_ALT)
+                                result |= MASK_ALT;
+
+                        return result;
+                }
+                
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseButton( int button, int state, int x, int y )
+                {
+                        // Texture has been scaled so it's 1:1 with screen pixels, so no need to scale mouse coords here.
+//                      x = ( x * mAppTextureWidth ) / mAppWindowWidth;
+//                      y = ( y * mAppTextureHeight ) / mAppWindowHeight;
+
+                        if ( button == GLUT_LEFT_BUTTON )
+                        {
+                                if ( state == GLUT_DOWN )
+                                        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, x, y, getModifiers());
+                                else if ( state == GLUT_UP )
+                                        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, x, y, getModifiers());
+                        }
+
+                        // force a GLUT update
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseMove( int x , int y )
+                {
+                        // Texture has been scaled so it's 1:1 with screen pixels, so no need to scale mouse coords here.
+//                      x = ( x * mAppTextureWidth ) / mAppWindowWidth;
+//                      y = ( y * mAppTextureHeight ) / mAppWindowHeight;
+                        
+                        // GLUT complains if I get the keyboard modifiers here, so just pretend there aren't any.
+                        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_MOVE, x, y, 0);
+
+                        // force a GLUT update
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void keyboard( unsigned char key )
+                {
+                        mMediaSource->keyEvent( LLPluginClassMedia::KEY_EVENT_DOWN, key, getModifiers());
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                int getAppWindowWidth()
+                {
+                        return mAppWindowWidth;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                int getAppWindowHeight()
+                {
+                        return mAppWindowHeight;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                std::string getAppWindowName()
+                {
+                        return mAppWindowName;
+                };
+
+};
+
+mediaPluginTest* gApplication;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutReshape( int width, int height )
+{
+        if ( gApplication )
+                gApplication->reshape( width, height );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutDisplay()
+{
+        if ( gApplication )
+                gApplication->display();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutIdle()
+{
+        if ( gApplication )
+                gApplication->idle();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutKeyboard( unsigned char key, int x, int y )
+{
+        if ( key == 27 )
+        {
+                delete gApplication;
+                exit( 0 );
+        };
+
+        if ( gApplication )
+                gApplication->keyboard( key );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseMove( int x, int y )
+{
+        if ( gApplication )
+                gApplication->mouseMove( x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseButton( int button, int state, int x, int y )
+{
+        if ( gApplication )
+                gApplication->mouseButton( button, state, x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+int main( int argc, char* argv[] )
+{
+
+        ll_init_apr();
+
+        // Set up llerror logging 
+        {
+                LLError::initForApplication(".");
+                LLError::setDefaultLevel(LLError::LEVEL_INFO);
+        }
+        
+        std::string launcher_name;
+        std::string plugin_name;
+
+        if(argc >= 3)
+        {
+                launcher_name = argv[1];
+                plugin_name = argv[2];
+        }
+        else
+        {
+#if LL_DARWIN
+                // hardcoding the testbed arguments by default
+                launcher_name = "plugin_process_host";
+                plugin_name = "libdemo_media_plugin_quicktime.dylib";
+#elif LL_WINDOWS
+                // hardcoding the testbed arguments by default
+                launcher_name = "plugin_process_host.exe";
+                plugin_name = "demo_media_plugin_quicktime.dll";
+#else
+                LL_ERRS("plugin_process_launcher") << "usage: " << argv[0] << " launcher_filename plugin_filename" << LL_ENDL;
+#endif
+        }
+
+        gApplication = new mediaPluginTest(launcher_name, plugin_name);
+
+        if ( gApplication )
+        {
+                glutInit( &argc, argv );
+                glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB );
+
+                glutInitWindowPosition( 80, 0 );
+                glutInitWindowSize( gApplication->getAppWindowWidth(), gApplication->getAppWindowHeight() );
+
+                glutCreateWindow( gApplication->getAppWindowName().c_str() );
+
+                glutKeyboardFunc( glutKeyboard );
+
+                glutMouseFunc( glutMouseButton );
+                glutPassiveMotionFunc( glutMouseMove );
+                glutMotionFunc( glutMouseMove );
+
+                glutDisplayFunc( glutDisplay );
+                glutReshapeFunc( glutReshape );
+
+                glutIdleFunc( glutIdle );
+
+                gApplication->initGL();
+
+                glutMainLoop();
+
+                delete gApplication;
+        };
+
+        ll_cleanup_apr();
+
+        return 0;
+}
+
diff --git a/linden/indra/test_apps/llplugintest/media_simple_test.cpp b/linden/indra/test_apps/llplugintest/media_simple_test.cpp
new file mode 100644
index 0000000..9a60e8e
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/media_simple_test.cpp
@@ -0,0 +1,460 @@
+/**
+ * @file demo_plugin.cpp
+ * @brief Test plugin to be loaded by the llplugin testbed.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 <string>
+#include <iostream>
+#include <stdlib.h>
+#include <time.h>
+
+#if LL_DARWIN
+        #include <GLUT/glut.h>
+#elif LL_LINUX
+        #include <GL/glut.h>
+#else
+        #include "glut.h"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//
+class mediaSource
+{
+        public:
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                mediaSource() :
+                        mPixels( 0 ),
+                        mIsDirty( false ),
+                        mWidth( 200 ),
+                        mHeight( 100 ),
+                        mDepth( 3 ),
+                        mPixelFormat( GL_BGR_EXT )
+                {
+                        mPixels = new unsigned char [ mWidth * mHeight * mDepth ];
+
+                        for( int i = 0; i < mWidth * mHeight * mDepth; ++i )
+                                *( mPixels + i ) = rand() % 0x40;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void update()
+                {
+                        const time_t interval = 1;
+                        static time_t last_time = time( NULL );
+                        time_t cur_time = time( NULL );
+
+                        if ( cur_time - last_time > interval )
+                        {
+                                for( int i = 0; i < mWidth * mHeight * mDepth; ++i )
+                                        *( mPixels + i ) = rand() % 0x40;
+
+                                mIsDirty = true;
+
+                                last_time = cur_time;
+                        };
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
+                {
+                        // make sure we don't write outside the buffer
+                        if((x < 0) || (x >= mWidth) || (y < 0) || (y >= mHeight))
+                                return;
+                                
+                        *( mPixels + ( mHeight - y ) * mWidth * mDepth + x * mDepth + 0 ) = b;
+                        *( mPixels + ( mHeight - y ) * mWidth * mDepth + x * mDepth + 1 ) = g;
+                        *( mPixels + ( mHeight - y ) * mWidth * mDepth + x * mDepth + 2 ) = r;
+
+                        mIsDirty = true;
+                }
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseDown( int x, int y )
+                {
+                        write_pixel( x, y, 0xff, 0x00, 0x00 );
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseUp( int x, int y )
+                {
+                        write_pixel( x, y, 0xff, 0xff, 0x00 );
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseMove( int x, int y )
+                {
+                        write_pixel( x, y, 0xff, 0x00, 0xff );
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void keyPress( unsigned char key )
+                {
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                int getWidth() { return mWidth; };
+                int getHeight() { return mHeight; };
+                int getDepth() { return mDepth; };
+                int getPixelFormat() { return mPixelFormat; };
+                bool isDirty() { return mIsDirty; };
+                void ackDirty() { mIsDirty = false; };
+                unsigned char* getPixels() { return mPixels; };
+
+        private:
+                unsigned char* mPixels;
+                bool mIsDirty;
+                int mWidth;
+                int mHeight;
+                int mDepth;
+                int mPixelFormat;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+class mediaSimpleTest
+{
+        public:
+                mediaSimpleTest() :
+                        mAppWindowWidth( 800 ),
+                        mAppWindowHeight( 600 ),
+                        mAppTextureWidth( 0 ),
+                        mAppTextureHeight( 0 ),
+                        mAppTexture( 0 ),
+                        mAppWindowName( "Media Simple Test" ),
+                        mHomeUrl( "" )
+                {
+                        mMediaSource = new mediaSource;
+
+                        // calculate texture size required (next power of two above browser window size
+                        for ( mAppTextureWidth = 1; mAppTextureWidth < mMediaSource->getWidth(); mAppTextureWidth <<= 1 ) {};
+                        for ( mAppTextureHeight = 1; mAppTextureHeight < mMediaSource->getHeight(); mAppTextureHeight <<= 1 ) {};
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                ~mediaSimpleTest()
+                {
+                        delete mMediaSource;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void initGL()
+                {
+                        // OpenGL initialization
+                        glClearColor( 0.0f, 0.0f, 0.0f, 0.5f);
+                        glEnable( GL_COLOR_MATERIAL );
+                        glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );
+                        glEnable( GL_TEXTURE_2D );
+                        glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+                        glEnable( GL_CULL_FACE );
+
+                        // create the texture used to display the browser data
+                        glGenTextures( 1, &mAppTexture );
+                        glBindTexture( GL_TEXTURE_2D, mAppTexture );
+                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                        glTexImage2D( GL_TEXTURE_2D, 0,
+                                GL_RGB,
+                                        mAppTextureWidth, mAppTextureHeight,
+                                                0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
+                }
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void reshape( int width, int height )
+                {
+                        if ( height == 0 )
+                                height = 1;
+
+                        glMatrixMode( GL_PROJECTION );
+                        glLoadIdentity();
+
+                        glViewport( 0, 0, width, height );
+                        glOrtho( 0.0f, width, height, 0.0f, -1.0f, 1.0f );
+
+                        // we use these values elsewhere so save
+                        mAppWindowWidth = width;
+                        mAppWindowHeight = height;
+
+                        glMatrixMode( GL_MODELVIEW );
+                        glLoadIdentity();
+
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void idle()
+                {
+                        // lots of updates for smooth motion
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void display()
+                {
+                        // clear screen
+                        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+                        glLoadIdentity();
+
+                        // use the browser texture
+                        glBindTexture( GL_TEXTURE_2D, mAppTexture );
+
+                        // needs to be updated?
+                        mMediaSource->update();
+                        if ( mMediaSource->isDirty() )
+                        {
+                                // grab the page
+                                const unsigned char* pixels = mMediaSource->getPixels();
+                                if ( pixels )
+                                {
+                                        // write them into the texture
+                                        glTexSubImage2D( GL_TEXTURE_2D, 0,
+                                                0, 0,
+                                                        mMediaSource->getWidth(),
+                                                                mMediaSource->getHeight(),
+                                                                                mMediaSource->getPixelFormat(),
+                                                                                        GL_UNSIGNED_BYTE,
+                                                                                                pixels );
+
+                                        // acknowledge we saw media was dirty and updated
+                                        mMediaSource->ackDirty();
+                                };
+                        };
+
+                        // scale the texture so that it fits the screen
+                        GLfloat texture_scale_x = ( GLfloat )mMediaSource->getWidth() / ( GLfloat )mAppTextureWidth;
+                        GLfloat texture_scale_y = ( GLfloat )mMediaSource->getHeight() / ( GLfloat )mAppTextureHeight;
+
+                        // draw the single quad full screen (orthographic)
+                        glMatrixMode( GL_TEXTURE );
+                        glPushMatrix();
+                        glScalef( texture_scale_x, texture_scale_y, 1.0f );
+
+                        glEnable( GL_TEXTURE_2D );
+                        glColor3f( 1.0f, 1.0f, 1.0f );
+                        glBegin( GL_QUADS );
+                                glTexCoord2f( 1.0f, 1.0f );
+                                glVertex2d( mAppWindowWidth, 0 );
+
+                                glTexCoord2f( 0.0f, 1.0f );
+                                glVertex2d( 0, 0 );
+
+                                glTexCoord2f( 0.0f, 0.0f );
+                                glVertex2d( 0, mAppWindowHeight );
+
+                                glTexCoord2f( 1.0f, .0f );
+                                glVertex2d( mAppWindowWidth, mAppWindowHeight );
+                        glEnd();
+
+                        glMatrixMode( GL_TEXTURE );
+                        glPopMatrix();
+
+                        glutSwapBuffers();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseButton( int button, int state, int x, int y )
+                {
+                        // texture is scaled to fit the screen so we scale mouse coords in the same way
+                        x = ( x * mMediaSource->getWidth() ) / mAppWindowWidth;
+                        y = ( y * mMediaSource->getHeight() ) / mAppWindowHeight;
+
+                        if ( button == GLUT_LEFT_BUTTON )
+                        {
+                                if ( state == GLUT_DOWN )
+                                        mMediaSource->mouseDown( x, y );
+                                else
+                                if ( state == GLUT_UP )
+                                        mMediaSource->mouseUp( x, y );
+                        };
+
+                        // force a GLUT update
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void mouseMove( int x , int y )
+                {
+                        // texture is scaled to fit the screen so we scale mouse coords in the same way
+                        x = ( x * mMediaSource->getWidth() ) / mAppWindowWidth;
+                        y = ( y * mMediaSource->getHeight() ) / mAppWindowHeight;
+
+                        mMediaSource->mouseMove( x, y );
+
+                        // force a GLUT update
+                        glutPostRedisplay();
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                void keyboard( unsigned char key )
+                {
+                        mMediaSource->keyPress( key );
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                int getAppWindowWidth()
+                {
+                        return mAppWindowWidth;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                int getAppWindowHeight()
+                {
+                        return mAppWindowHeight;
+                };
+
+                ////////////////////////////////////////////////////////////////////////////////
+                //
+                std::string getAppWindowName()
+                {
+                        return mAppWindowName;
+                };
+
+        private:
+                int mAppWindowWidth;
+                int mAppWindowHeight;
+                mediaSource* mMediaSource;
+                int mAppTextureWidth;
+                int mAppTextureHeight;
+                GLuint mAppTexture;
+                std::string mAppWindowName;
+                std::string mHomeUrl;
+};
+
+mediaSimpleTest* gApplication;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutReshape( int width, int height )
+{
+        if ( gApplication )
+                gApplication->reshape( width, height );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutDisplay()
+{
+        if ( gApplication )
+                gApplication->display();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutIdle()
+{
+        if ( gApplication )
+                gApplication->idle();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutKeyboard( unsigned char key, int x, int y )
+{
+        if ( key == 27 )
+        {
+                delete gApplication;
+                exit( 0 );
+        };
+
+        if ( gApplication )
+                gApplication->keyboard( key );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseMove( int x, int y )
+{
+        if ( gApplication )
+                gApplication->mouseMove( x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void glutMouseButton( int button, int state, int x, int y )
+{
+        if ( gApplication )
+                gApplication->mouseButton( button, state, x, y );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+int main( int argc, char* argv[] )
+{
+        gApplication = new mediaSimpleTest;
+
+        if ( gApplication )
+        {
+                glutInit( &argc, argv );
+                glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB );
+
+                glutInitWindowPosition( 80, 0 );
+                glutInitWindowSize( gApplication->getAppWindowWidth(), gApplication->getAppWindowHeight() );
+
+                glutCreateWindow( gApplication->getAppWindowName().c_str() );
+
+                glutKeyboardFunc( glutKeyboard );
+
+                glutMouseFunc( glutMouseButton );
+                glutPassiveMotionFunc( glutMouseMove );
+                glutMotionFunc( glutMouseMove );
+
+                glutDisplayFunc( glutDisplay );
+                glutReshapeFunc( glutReshape );
+
+                glutIdleFunc( glutIdle );
+
+                gApplication->initGL();
+
+                glutMainLoop();
+
+                delete gApplication;
+        };
+
+        return 0;
+}
+
diff --git a/linden/indra/test_apps/llplugintest/plugin_host.cpp b/linden/indra/test_apps/llplugintest/plugin_host.cpp
new file mode 100644
index 0000000..5ba5d8b
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/plugin_host.cpp
@@ -0,0 +1,92 @@
+/** 
+ * @file plugin_host.cpp
+ * @brief Testbed for llplugin which directly loads a plugin dynamic library.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "llplugininstance.h"
+#include "llpluginmessage.h"
+#include "llerrorcontrol.h"
+
+class MessageReceiver: public LLPluginInstanceMessageListener
+{
+        // Inherited from LLPluginInstanceMessageListener
+        /* virtual */ void receivePluginMessage(const std::string &message)
+        {
+                LL_INFOS("plugin_host") << "message received from plugin: " << message << LL_ENDL;
+        }
+        
+};
+
+int main(int argc, char **argv)
+{
+        ll_init_apr();
+
+        // Set up llerror logging 
+        {
+                LLError::initForApplication(".");
+                LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+        }
+
+        if(argc < 2)
+        {
+                LL_ERRS("plugin_host") << "usage: " << argv[0] << " plugin_filename" << LL_ENDL;
+                exit(1);
+        }
+                
+        std::string name = argv[1];
+        
+        MessageReceiver receiver;
+        LLPluginInstance *plugin = new LLPluginInstance(&receiver);
+        if(plugin->load(name) == 0)
+        {
+                LLPluginMessage message;
+                message.setMessage("base", "init");
+                message.setValue("foo", "1");
+                message.setValue("bar", "2");
+                plugin->sendMessage(message.generate());
+                
+                message.setMessage("base", "idle");
+                message.setValue("baz", "3");
+                plugin->sendMessage(message.generate());
+
+                message.setMessage("base", "shutdown");
+                plugin->sendMessage(message.generate());
+
+                plugin->idle();
+        }
+
+        delete plugin;
+
+        ll_cleanup_apr();       
+}
+
diff --git a/linden/indra/test_apps/llplugintest/plugin_process_launcher.cpp b/linden/indra/test_apps/llplugintest/plugin_process_launcher.cpp
new file mode 100644
index 0000000..82b11e3
--- /dev/null
+++ b/linden/indra/test_apps/llplugintest/plugin_process_launcher.cpp
@@ -0,0 +1,197 @@
+/** 
+ * @file plugin_process_launcher.cpp
+ * @brief Testbed for llplugin which launches the plugin loader shell.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "llprocesslauncher.h"
+#include "lltimer.h" // for ms_sleep()
+#include "llpumpio.h"
+#include "llapr.h"
+#include "llerrorcontrol.h"
+#include "llpluginprocessparent.h"
+
+class PluginProcessLauncherMessageReceiver : public LLPluginProcessParentOwner
+{
+LOG_CLASS(PluginProcessLauncherMessageReceiver);
+
+public:
+        virtual ~PluginProcessLauncherMessageReceiver()
+        {
+        }
+        
+        /* virtual */ void receivePluginMessage(const LLPluginMessage &message)
+        {
+                LL_INFOS("plugin_process_launcher") << "received message: \n" << message.generate() << LL_ENDL;
+        }
+};
+
+LLPumpIO* gServicePump;
+LLPluginProcessParent *gPlugin;
+
+
+#define SHARED_MEMORY_SIZE 0x10000
+#define SHARED_MEMORY_NAME "testsegment"
+enum State
+{
+        STATE_STARTUP,
+        STATE_ADD_MEMORY,
+        STATE_RUNNING,
+        STATE_REMOVE_MEMORY,
+        STATE_SHUTDOWN,
+        STATE_CLEANUP,
+        STATE_DONE
+};
+
+int main(int argc, char **argv)
+{
+        ll_init_apr();
+
+        // Set up llerror logging 
+        {
+                LLError::initForApplication(".");
+                LLError::setDefaultLevel(LLError::LEVEL_INFO);
+        }
+        
+        std::string launcher_name;
+        std::string plugin_name;
+
+        if(argc >= 3)
+        {
+                launcher_name = argv[1];
+                plugin_name = argv[2];
+        }
+        else
+        {
+#if LL_DARWIN
+                // hardcoding the testbed arguments by default
+                launcher_name = "plugin_process_host";
+                plugin_name = "libdemo_plugin.dylib";
+#elif LL_WINDOWS
+                // hardcoding the testbed arguments by default
+                launcher_name = "plugin_process_host.exe";
+                plugin_name = "demo_plugin.dll";
+#else
+                LL_ERRS("plugin_process_launcher") << "usage: " << argv[0] << " launcher_filename plugin_filename" << LL_ENDL;
+#endif
+        }
+
+        PluginProcessLauncherMessageReceiver receiver;
+        
+        gServicePump = new LLPumpIO(gAPRPoolp);
+        gServicePump->prime(gAPRPoolp);
+
+        gPlugin = new LLPluginProcessParent(gServicePump, &receiver);
+
+        State state = STATE_STARTUP;
+        while(state != STATE_DONE)
+        {
+                switch(state)
+                {
+                        case STATE_STARTUP:
+                                LL_INFOS("plugin_process_launcher") << "startup" << LL_ENDL;
+                                gPlugin->init(launcher_name, plugin_name);
+                                state = STATE_ADD_MEMORY;
+                        break;
+                        
+                        case STATE_ADD_MEMORY:
+                                if(gPlugin->isRunning())
+                                {
+                                        LL_INFOS("plugin_process_launcher") << "adding shared memory" << LL_ENDL;
+                                        gPlugin->addSharedMemory(SHARED_MEMORY_SIZE);
+                                        state = STATE_RUNNING;
+                                }
+                        break;
+                        
+                        case STATE_RUNNING:
+                        {
+                                volatile unsigned char *addr = (unsigned char*)gPlugin->getSharedMemoryAddress(SHARED_MEMORY_NAME);
+                                if(addr != NULL)
+                                {
+                                        int val = (int)(addr[0]);
+                                        if(val >= 16)
+                                        {
+                                                state = STATE_REMOVE_MEMORY;
+                                        }
+                                        else
+                                        {
+                                                LL_INFOS("plugin_process_launcher") << "running, value from shared memory is " << val << LL_ENDL;
+                                        }
+                                }
+                        }
+                        break;
+                        
+                        case STATE_REMOVE_MEMORY:
+                                LL_INFOS("plugin_process_launcher") << "removing shared memory" << LL_ENDL;
+                                gPlugin->removeSharedMemory(SHARED_MEMORY_NAME);
+                                state = STATE_SHUTDOWN;
+                        break;
+                        
+                        case STATE_SHUTDOWN:
+                        {
+                                volatile unsigned char *addr = (unsigned char*)gPlugin->getSharedMemoryAddress(SHARED_MEMORY_NAME);
+                                if(addr == NULL)
+                                {
+                                        LL_INFOS("plugin_process_launcher") << "sending shutdown request" << LL_ENDL;
+                                        gPlugin->shutdownRequest();
+                                        state = STATE_CLEANUP;
+                                }
+                        }
+                        break;
+                        
+                        case STATE_CLEANUP:
+                                if(gPlugin->isDone())
+                                {
+                                        LL_INFOS("plugin_process_launcher") << "plugin is done" << LL_ENDL;
+                                        state = STATE_DONE;
+                                }
+                        break;
+                        
+                        case STATE_DONE:
+                                // should never reach here -- the while() should exit first.
+                        break;
+                }
+                
+                // Do this every time through the loop
+                if(state != STATE_DONE)
+                {
+                        gServicePump->pump();
+                        gServicePump->callback();
+                        gPlugin->idle();
+                        ms_sleep(100);
+                }
+        }
+
+        delete gPlugin;
+        
+        ll_cleanup_apr();
+        
+}