Merged lindenlab/viewer-release into default

18 files changed, 692 insertions, 4371 deletions

diff --git a/indra/media_plugins/CMakeLists.txt b/indra/media_plugins/CMakeLists.txt
index 9055e0111a..1a5cc8ec9a 100644
--- a/indra/media_plugins/CMakeLists.txt
+++ b/indra/media_plugins/CMakeLists.txt
@@ -5,17 +5,17 @@ add_subdirectory(base)
 if (LINUX)
     add_subdirectory(gstreamer010)
     add_subdirectory(libvlc)
+    add_subdirectory(example)
 endif (LINUX)
 
 if (DARWIN)
-    add_subdirectory(quicktime)
     add_subdirectory(cef)
+    add_subdirectory(libvlc)
+    add_subdirectory(example)
 endif (DARWIN)
 
 if (WINDOWS)
     add_subdirectory(cef)
-    add_subdirectory(winmmshim)
     add_subdirectory(libvlc)
+    add_subdirectory(example)
 endif (WINDOWS)
-
-### add_subdirectory(example)
diff --git a/indra/media_plugins/base/CMakeLists.txt b/indra/media_plugins/base/CMakeLists.txt
index 7367b9e5e6..70c81d4023 100644
--- a/indra/media_plugins/base/CMakeLists.txt
+++ b/indra/media_plugins/base/CMakeLists.txt
@@ -28,13 +28,13 @@ include_directories(SYSTEM
 
 ### media_plugin_base
 
-if(NOT WORD_SIZE EQUAL 32)
+if(NOT ADDRESS_SIZE EQUAL 32)
   if(WINDOWS)
-    add_definitions(/FIXED:NO)
+    ##add_definitions(/FIXED:NO)
   else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
     add_definitions(-fPIC)
   endif(WINDOWS)
-endif(NOT WORD_SIZE EQUAL 32)
+endif(NOT ADDRESS_SIZE EQUAL 32)
 
 set(media_plugin_base_SOURCE_FILES
     media_plugin_base.cpp
diff --git a/indra/media_plugins/cef/CMakeLists.txt b/indra/media_plugins/cef/CMakeLists.txt
index db471c7906..5452fd9d1e 100644
--- a/indra/media_plugins/cef/CMakeLists.txt
+++ b/indra/media_plugins/cef/CMakeLists.txt
@@ -34,13 +34,13 @@ include_directories(SYSTEM
 
 ### media_plugin_cef
 
-if(NOT WORD_SIZE EQUAL 32)
+if(NOT ADDRESS_SIZE EQUAL 32)
   if(WINDOWS)
-    add_definitions(/FIXED:NO)
+    ##add_definitions(/FIXED:NO)
   else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
     add_definitions(-fPIC)
   endif(WINDOWS)
-endif(NOT WORD_SIZE EQUAL 32)
+endif(NOT ADDRESS_SIZE EQUAL 32)
 
 set(media_plugin_cef_SOURCE_FILES
     media_plugin_cef.cpp
@@ -57,14 +57,12 @@ set (media_plugin_cef_LINK_LIBRARIES
   ${LLCOMMON_LIBRARIES}
   ${PLUGIN_API_WINDOWS_LIBRARIES})
 
-
 # Select which VolumeCatcher implementation to use
 if (LINUX)
   message(FATAL_ERROR "CEF plugin has been enabled for a Linux compile.\n"
     "  Please create a volume_catcher implementation for this platform.")
-
 elseif (DARWIN)
-  list(APPEND media_plugin_cef_SOURCE_FILES mac_volume_catcher.cpp)
+  list(APPEND media_plugin_cef_SOURCE_FILES mac_volume_catcher_null.cpp)
   find_library(CORESERVICES_LIBRARY CoreServices)
   find_library(AUDIOUNIT_LIBRARY AudioUnit)
   list(APPEND media_plugin_cef_LINK_LIBRARIES
@@ -97,8 +95,8 @@ if (WINDOWS)
   set_target_properties(
     media_plugin_cef
     PROPERTIES
-    LINK_FLAGS "/MANIFEST:NO /SAFESEH:NO /LTCG /NODEFAULTLIB:LIBCMT"
-    LINK_FLAGS_DEBUG "/MANIFEST:NO /SAFESEH:NO /NODEFAULTLIB:LIBCMTD"
+    LINK_FLAGS "/MANIFEST:NO /SAFESEH:NO /NODEFAULTLIB:LIBCMT /IGNORE:4099"
+    LINK_FLAGS_DEBUG "/MANIFEST:NO /SAFESEH:NO /NODEFAULTLIB:LIBCMTD /IGNORE:4099"
     )
 endif (WINDOWS)
 
@@ -113,6 +111,9 @@ if (DARWIN)
     LINK_FLAGS "-exported_symbols_list ${CMAKE_CURRENT_SOURCE_DIR}/../base/media_plugin_base.exp"
   )
 
+  ## turns on C++11 using Cmake
+  target_compile_features(media_plugin_cef PRIVATE cxx_range_for)
+
   add_custom_command(TARGET media_plugin_cef
     POST_BUILD COMMAND ${CMAKE_INSTALL_NAME_TOOL} -change "@executable_path/Chromium Embedded Framework"
         "@executable_path/../../../../Frameworks/Chromium Embedded Framework.framework/Chromium Embedded Framework"
diff --git a/indra/media_plugins/cef/mac_volume_catcher_null.cpp b/indra/media_plugins/cef/mac_volume_catcher_null.cpp
new file mode 100644
index 0000000000..f4fcef71aa
--- /dev/null
+++ b/indra/media_plugins/cef/mac_volume_catcher_null.cpp
@@ -0,0 +1,95 @@
+/** 
+ * @file windows_volume_catcher.cpp
+ * @brief A null implementation of volume level control of all audio channels opened by a process.
+ *        We are using this for the macOS version for now until we can understand how to make the 
+ *        exitising mac_volume_catcher.cpp work without the (now, non-existant) QuickTime dependency
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ * @endcond
+ */
+
+#include "volume_catcher.h"
+#include "llsingleton.h"
+class VolumeCatcherImpl : public LLSingleton<VolumeCatcherImpl>
+{
+	LLSINGLETON(VolumeCatcherImpl);
+	// This is a singleton class -- both callers and the component implementation should use getInstance() to find the instance.
+	~VolumeCatcherImpl();
+
+public:
+
+	void setVolume(F32 volume);
+	void setPan(F32 pan);
+	
+private:
+	F32 	mVolume;
+	F32 	mPan;
+	bool mSystemIsVistaOrHigher;
+};
+
+VolumeCatcherImpl::VolumeCatcherImpl()
+:	mVolume(1.0f),			// default volume is max
+	mPan(0.f)				// default pan is centered
+{
+}
+
+VolumeCatcherImpl::~VolumeCatcherImpl()
+{
+}
+
+void VolumeCatcherImpl::setVolume(F32 volume)
+{
+	mVolume = volume;
+}
+
+void VolumeCatcherImpl::setPan(F32 pan)
+{	// remember pan for calculating individual channel levels later
+	mPan = pan;
+}
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+	pimpl = VolumeCatcherImpl::getInstance();
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+	// Let the instance persist until exit.
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+	pimpl->setVolume(volume);
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+	pimpl->setPan(pan);
+}
+
+void VolumeCatcher::pump()
+{
+	// No periodic tasks are necessary for this implementation.
+}
diff --git a/indra/media_plugins/cef/media_plugin_cef.cpp b/indra/media_plugins/cef/media_plugin_cef.cpp
index ec1454308c..f3d7762a08 100644
--- a/indra/media_plugins/cef/media_plugin_cef.cpp
+++ b/indra/media_plugins/cef/media_plugin_cef.cpp
@@ -34,12 +34,12 @@
 #include "llplugininstance.h"
 #include "llpluginmessage.h"
 #include "llpluginmessageclasses.h"
+#include "volume_catcher.h"
 #include "media_plugin_base.h"
 
-#include "boost/function.hpp"
-#include "boost/bind.hpp"
-#include "llCEFLib.h"
-#include "volume_catcher.h"
+#include <functional>
+
+#include "dullahan.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -56,7 +56,7 @@ public:
 private:
 	bool init();
 
-	void onPageChangedCallback(unsigned char* pixels, int x, int y, int width, int height, bool is_popup);
+	void onPageChangedCallback(const unsigned char* pixels, int x, int y, const int width, const int height);
 	void onCustomSchemeURLCallback(std::string url);
 	void onConsoleMessageCallback(std::string message, std::string source, int line);
 	void onStatusMessageCallback(std::string value);
@@ -67,26 +67,25 @@ private:
 	void onAddressChangeCallback(std::string url);
 	void onNavigateURLCallback(std::string url, std::string target);
 	bool onHTTPAuthCallback(const std::string host, const std::string realm, std::string& username, std::string& password);
-	void onCursorChangedCallback(LLCEFLib::ECursorType type, unsigned int handle);
+	void onCursorChangedCallback(dullahan::ECursorType type);
 	void onFileDownloadCallback(std::string filename);
 	const std::string onFileDialogCallback();
 
 	void postDebugMessage(const std::string& msg);
 	void authResponse(LLPluginMessage &message);
 
-	LLCEFLib::EKeyboardModifier decodeModifiers(std::string &modifiers);
-	void deserializeKeyboardData(LLSD native_key_data, uint32_t& native_scan_code, uint32_t& native_virtual_key, uint32_t& native_modifiers);
-	void keyEvent(LLCEFLib::EKeyEvent key_event, int key, LLCEFLib::EKeyboardModifier modifiers, LLSD native_key_data);
-	void unicodeInput(const std::string &utf8str, LLCEFLib::EKeyboardModifier modifiers, LLSD native_key_data);
+	void keyEvent(dullahan::EKeyEvent key_event, LLSD native_key_data);
+	void unicodeInput(std::string event, LLSD native_key_data);
 
 	void checkEditState();
-    void setVolume(F32 vol);
+    void setVolume();
 
 	bool mEnableMediaPluginDebugging;
 	std::string mHostLanguage;
 	bool mCookiesEnabled;
 	bool mPluginsEnabled;
 	bool mJavascriptEnabled;
+	bool mDisableGPU;
 	std::string mUserAgentSubtring;
 	std::string mAuthUsername;
 	std::string mAuthPassword;
@@ -97,15 +96,9 @@ private:
 	std::string mCachePath;
 	std::string mCookiePath;
 	std::string mPickedFile;
-	LLCEFLib* mLLCEFLib;
-
-    VolumeCatcher mVolumeCatcher;
-
-	U8 *mPopupBuffer;
-	U32 mPopupW;
-	U32 mPopupH;
-	U32 mPopupX;
-	U32 mPopupY;
+	VolumeCatcher mVolumeCatcher;
+	F32 mCurVolume;
+	dullahan* mCEFLib;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -122,6 +115,7 @@ MediaPluginBase(host_send_func, host_user_data)
 	mCookiesEnabled = true;
 	mPluginsEnabled = false;
 	mJavascriptEnabled = true;
+	mDisableGPU = true;
 	mUserAgentSubtring = "";
 	mAuthUsername = "";
 	mAuthPassword = "";
@@ -132,20 +126,18 @@ MediaPluginBase(host_send_func, host_user_data)
 	mCachePath = "";
 	mCookiePath = "";
 	mPickedFile = "";
-	mLLCEFLib = new LLCEFLib();
+	mCurVolume = 0.0;
 
-	mPopupBuffer = NULL;
-	mPopupW = 0;
-	mPopupH = 0;
-	mPopupX = 0;
-	mPopupY = 0;
+	mCEFLib = new dullahan();
+
+	setVolume();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 MediaPluginCEF::~MediaPluginCEF()
 {
-	delete[] mPopupBuffer;
+	mCEFLib->shutdown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -166,56 +158,13 @@ void MediaPluginCEF::postDebugMessage(const std::string& msg)
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginCEF::onPageChangedCallback(unsigned char* pixels, int x, int y, int width, int height, bool is_popup)
+void MediaPluginCEF::onPageChangedCallback(const unsigned char* pixels, int x, int y, const int width, const int height)
 {
-	if( is_popup )
-	{
-		delete mPopupBuffer;
-		mPopupBuffer = NULL;
-		mPopupH = 0;
-		mPopupW = 0;
-		mPopupX = 0;
-		mPopupY = 0;
-	}
-
 	if( mPixels && pixels )
 	{
-		if (is_popup)
-		{
-			if( width > 0 && height> 0 )
-			{
-				mPopupBuffer = new U8[ width * height * mDepth ];
-				memcpy( mPopupBuffer, pixels, width * height * mDepth );
-				mPopupH = height;
-				mPopupW = width;
-				mPopupX = x;
-				mPopupY = mHeight - y - height;
-			}
-		}
-		else
+		if (mWidth == width && mHeight == height)
 		{
-			if (mWidth == width && mHeight == height)
-			{
-				memcpy(mPixels, pixels, mWidth * mHeight * mDepth);
-			}
-			if( mPopupBuffer && mPopupH && mPopupW )
-			{
-				U32 bufferSize = mWidth * mHeight * mDepth;
-				U32 popupStride = mPopupW * mDepth;
-				U32 bufferStride = mWidth * mDepth;
-				int dstY = mPopupY;
-
-				int src = 0;
-				int dst = dstY  * mWidth * mDepth + mPopupX * mDepth;
-
-				for( int line = 0; dst + popupStride < bufferSize && line < mPopupH; ++line )
-				{
-					memcpy( mPixels + dst, mPopupBuffer + src, popupStride );
-					src += popupStride;
-					dst += bufferStride;
-				}
-			}
-
+			memcpy(mPixels, pixels, mWidth * mHeight * mDepth);
 		}
 		setDirty(0, 0, mWidth, mHeight);
 	}
@@ -254,8 +203,8 @@ void MediaPluginCEF::onLoadStartCallback()
 {
 	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_begin");
 	//message.setValue("uri", event.getEventUri());  // not easily available here in CEF - needed?
-	message.setValueBoolean("history_back_available", mLLCEFLib->canGoBack());
-	message.setValueBoolean("history_forward_available", mLLCEFLib->canGoForward());
+	message.setValueBoolean("history_back_available", mCEFLib->canGoBack());
+	message.setValueBoolean("history_forward_available", mCEFLib->canGoForward());
 	sendMessage(message);
 }
 
@@ -263,10 +212,10 @@ void MediaPluginCEF::onLoadStartCallback()
 //
 void MediaPluginCEF::onRequestExitCallback()
 {
-	mLLCEFLib->shutdown();
-
 	LLPluginMessage message("base", "goodbye");
 	sendMessage(message);
+
+	mDeleteMe = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -276,8 +225,8 @@ void MediaPluginCEF::onLoadEndCallback(int httpStatusCode)
 	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete");
 	//message.setValue("uri", event.getEventUri());  // not easily available here in CEF - needed?
 	message.setValueS32("result_code", httpStatusCode);
-	message.setValueBoolean("history_back_available", mLLCEFLib->canGoBack());
-	message.setValueBoolean("history_forward_available", mLLCEFLib->canGoForward());
+	message.setValueBoolean("history_back_available", mCEFLib->canGoBack());
+	message.setValueBoolean("history_forward_available", mCEFLib->canGoForward());
 	sendMessage(message);
 }
 
@@ -360,25 +309,25 @@ const std::string MediaPluginCEF::onFileDialogCallback()
 	return mPickedFile;
 }
 
-void MediaPluginCEF::onCursorChangedCallback(LLCEFLib::ECursorType type, unsigned int handle)
+void MediaPluginCEF::onCursorChangedCallback(dullahan::ECursorType type)
 {
 	std::string name = "";
 
 	switch (type)
 	{
-		case LLCEFLib::CT_POINTER:
+		case dullahan::CT_POINTER:
 			name = "arrow";
 			break;
-		case LLCEFLib::CT_IBEAM:
+		case dullahan::CT_IBEAM:
 			name = "ibeam";
 			break;
-		case LLCEFLib::CT_NORTHSOUTHRESIZE:
+		case dullahan::CT_NORTHSOUTHRESIZE:
 			name = "splitv";
 			break;
-		case LLCEFLib::CT_EASTWESTRESIZE:
+		case dullahan::CT_EASTWESTRESIZE:
 			name = "splith";
 			break;
-		case LLCEFLib::CT_HAND:
+		case dullahan::CT_HAND:
 			name = "hand";
 			break;
 
@@ -430,9 +379,8 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			}
 			else if (message_name == "idle")
 			{
-				mLLCEFLib->update();
+				mCEFLib->update();
 
-                mVolumeCatcher.pump();
 				// this seems bad but unless the state changes (it won't until we figure out
 				// how to get CEF to tell us if copy/cut/paste is available) then this function
 				// will return immediately
@@ -441,7 +389,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			else if (message_name == "cleanup")
 			{
 				mVolumeCatcher.setVolume(0);
-				mLLCEFLib->requestExit();
+				mCEFLib->requestExit();
 			}
 			else if (message_name == "shm_added")
 			{
@@ -483,42 +431,56 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 		{
 			if (message_name == "init")
 			{
-				// event callbacks from LLCefLib
-				mLLCEFLib->setOnPageChangedCallback(boost::bind(&MediaPluginCEF::onPageChangedCallback, this, _1, _2, _3, _4, _5, _6));
-				mLLCEFLib->setOnCustomSchemeURLCallback(boost::bind(&MediaPluginCEF::onCustomSchemeURLCallback, this, _1));
-				mLLCEFLib->setOnConsoleMessageCallback(boost::bind(&MediaPluginCEF::onConsoleMessageCallback, this, _1, _2, _3));
-				mLLCEFLib->setOnStatusMessageCallback(boost::bind(&MediaPluginCEF::onStatusMessageCallback, this, _1));
-				mLLCEFLib->setOnTitleChangeCallback(boost::bind(&MediaPluginCEF::onTitleChangeCallback, this, _1));
-				mLLCEFLib->setOnLoadStartCallback(boost::bind(&MediaPluginCEF::onLoadStartCallback, this));
-				mLLCEFLib->setOnLoadEndCallback(boost::bind(&MediaPluginCEF::onLoadEndCallback, this, _1));
-				mLLCEFLib->setOnAddressChangeCallback(boost::bind(&MediaPluginCEF::onAddressChangeCallback, this, _1));
-				mLLCEFLib->setOnNavigateURLCallback(boost::bind(&MediaPluginCEF::onNavigateURLCallback, this, _1, _2));
-				mLLCEFLib->setOnHTTPAuthCallback(boost::bind(&MediaPluginCEF::onHTTPAuthCallback, this, _1, _2, _3, _4));
-				mLLCEFLib->setOnFileDownloadCallback(boost::bind(&MediaPluginCEF::onFileDownloadCallback, this, _1));
-				mLLCEFLib->setOnFileDialogCallback(boost::bind(&MediaPluginCEF::onFileDialogCallback, this));
-				mLLCEFLib->setOnCursorChangedCallback(boost::bind(&MediaPluginCEF::onCursorChangedCallback, this, _1, _2));
-				mLLCEFLib->setOnRequestExitCallback(boost::bind(&MediaPluginCEF::onRequestExitCallback, this));
-
-				LLCEFLib::LLCEFLibSettings settings;
-				settings.initial_width = 1024;
-				settings.initial_height = 1024;
-				settings.page_zoom_factor = message_in.getValueReal("factor");
-				settings.plugins_enabled = mPluginsEnabled;
-				settings.media_stream_enabled = false; // MAINT-6060 - WebRTC media removed until we can add granualrity/query UI
-				settings.javascript_enabled = mJavascriptEnabled;
-				settings.cookies_enabled = mCookiesEnabled;
-				settings.cookie_store_path = mCookiePath;
+				// event callbacks from Dullahan
+				mCEFLib->setOnPageChangedCallback(std::bind(&MediaPluginCEF::onPageChangedCallback, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
+				mCEFLib->setOnCustomSchemeURLCallback(std::bind(&MediaPluginCEF::onCustomSchemeURLCallback, this, std::placeholders::_1));
+				mCEFLib->setOnConsoleMessageCallback(std::bind(&MediaPluginCEF::onConsoleMessageCallback, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+				mCEFLib->setOnStatusMessageCallback(std::bind(&MediaPluginCEF::onStatusMessageCallback, this, std::placeholders::_1));
+				mCEFLib->setOnTitleChangeCallback(std::bind(&MediaPluginCEF::onTitleChangeCallback, this, std::placeholders::_1));
+				mCEFLib->setOnLoadStartCallback(std::bind(&MediaPluginCEF::onLoadStartCallback, this));
+				mCEFLib->setOnLoadEndCallback(std::bind(&MediaPluginCEF::onLoadEndCallback, this, std::placeholders::_1));
+				mCEFLib->setOnAddressChangeCallback(std::bind(&MediaPluginCEF::onAddressChangeCallback, this, std::placeholders::_1));
+				mCEFLib->setOnNavigateURLCallback(std::bind(&MediaPluginCEF::onNavigateURLCallback, this, std::placeholders::_1, std::placeholders::_2));
+				mCEFLib->setOnHTTPAuthCallback(std::bind(&MediaPluginCEF::onHTTPAuthCallback, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+				mCEFLib->setOnFileDownloadCallback(std::bind(&MediaPluginCEF::onFileDownloadCallback, this, std::placeholders::_1));
+				mCEFLib->setOnFileDialogCallback(std::bind(&MediaPluginCEF::onFileDialogCallback, this));
+				mCEFLib->setOnCursorChangedCallback(std::bind(&MediaPluginCEF::onCursorChangedCallback, this, std::placeholders::_1));
+				mCEFLib->setOnRequestExitCallback(std::bind(&MediaPluginCEF::onRequestExitCallback, this));
+
+				dullahan::dullahan_settings settings;
+				settings.accept_language_list = mHostLanguage;
+				settings.background_color = 0xffffffff;
 				settings.cache_enabled = true;
 				settings.cache_path = mCachePath;
-				settings.accept_language_list = mHostLanguage;
-				settings.user_agent_substring = mLLCEFLib->makeCompatibleUserAgentString(mUserAgentSubtring);
+				settings.cookie_store_path = mCookiePath;
+				settings.cookies_enabled = mCookiesEnabled;
+				settings.disable_gpu = mDisableGPU;
+				settings.flash_enabled = mPluginsEnabled;
+				settings.flip_mouse_y = false;
+				settings.flip_pixels_y = true;
+				settings.frame_rate = 60;
+				settings.force_wave_audio = true;
+				settings.initial_height = 1024;
+				settings.initial_width = 1024;
+				settings.java_enabled = false;
+				settings.javascript_enabled = mJavascriptEnabled;
+				settings.media_stream_enabled = false; // MAINT-6060 - WebRTC media removed until we can add granualrity/query UI
+				settings.plugins_enabled = mPluginsEnabled;
+				settings.user_agent_substring = mCEFLib->makeCompatibleUserAgentString(mUserAgentSubtring);
+				settings.webgl_enabled = true;
 
-				bool result = mLLCEFLib->init(settings);
+				std::vector<std::string> custom_schemes(1, "secondlife");
+				mCEFLib->setCustomSchemes(custom_schemes);
+
+				bool result = mCEFLib->init(settings);
 				if (!result)
 				{
 					// if this fails, the media system in viewer will put up a message
 				}
 
+				// now we can set page zoom factor
+				mCEFLib->setPageZoom(message_in.getValueReal("factor"));
+
 				// Plugin gets to decide the texture parameters to use.
 				mDepth = 4;
 				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
@@ -561,7 +523,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 					};
 				};
 
-				mLLCEFLib->setSize(mWidth, mHeight);
+				mCEFLib->setSize(mWidth, mHeight);
 
 				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
 				message.setValue("name", name);
@@ -579,7 +541,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			else if (message_name == "load_uri")
 			{
 				std::string uri = message_in.getValue("uri");
-				mLLCEFLib->navigate(uri);
+				mCEFLib->navigate(uri);
 			}
 			else if (message_name == "set_cookie")
 			{
@@ -590,7 +552,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				std::string path = message_in.getValue("path");
 				bool httponly = message_in.getValueBoolean("httponly");
 				bool secure = message_in.getValueBoolean("secure");
-				mLLCEFLib->setCookie(uri, name, value, domain, path, httponly, secure);
+				mCEFLib->setCookie(uri, name, value, domain, path, httponly, secure);
 			}
 			else if (message_name == "mouse_event")
 			{
@@ -599,18 +561,16 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				S32 x = message_in.getValueS32("x");
 				S32 y = message_in.getValueS32("y");
 
-				y = mHeight - y;
-
-				// only even send left mouse button events to LLCEFLib
+				// only even send left mouse button events to the CEF library
 				// (partially prompted by crash in OS X CEF when sending right button events)
 				// we catch the right click in viewer and display our own context menu anyway
 				S32 button = message_in.getValueS32("button");
-				LLCEFLib::EMouseButton btn = LLCEFLib::MB_MOUSE_BUTTON_LEFT;
+				dullahan::EMouseButton btn = dullahan::MB_MOUSE_BUTTON_LEFT;
 
 				if (event == "down" && button == 0)
 				{
-					mLLCEFLib->mouseButton(btn, LLCEFLib::ME_MOUSE_DOWN, x, y);
-					mLLCEFLib->setFocus(true);
+					mCEFLib->mouseButton(btn, dullahan::ME_MOUSE_DOWN, x, y);
+					mCEFLib->setFocus();
 
 					std::stringstream str;
 					str << "Mouse down at = " << x << ", " << y;
@@ -618,7 +578,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				}
 				else if (event == "up" && button == 0)
 				{
-					mLLCEFLib->mouseButton(btn, LLCEFLib::ME_MOUSE_UP, x, y);
+					mCEFLib->mouseButton(btn, dullahan::ME_MOUSE_UP, x, y);
 
 					std::stringstream str;
 					str << "Mouse up at = " << x << ", " << y;
@@ -626,11 +586,11 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				}
 				else if (event == "double_click")
 				{
-					mLLCEFLib->mouseButton(btn, LLCEFLib::ME_MOUSE_DOUBLE_CLICK, x, y);
+					mCEFLib->mouseButton(btn, dullahan::ME_MOUSE_DOUBLE_CLICK, x, y);
 				}
 				else
 				{
-					mLLCEFLib->mouseMove(x, y);
+					mCEFLib->mouseMove(x, y);
 				}
 			}
 			else if (message_name == "scroll_event")
@@ -640,68 +600,48 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				const int scaling_factor = 40;
 				y *= -scaling_factor;
 
-				mLLCEFLib->mouseWheel(x, y);
+				mCEFLib->mouseWheel(x, y);
 			}
 			else if (message_name == "text_event")
 			{
-				std::string text = message_in.getValue("text");
-				std::string modifiers = message_in.getValue("modifiers");
+				std::string event = message_in.getValue("event");
 				LLSD native_key_data = message_in.getValueLLSD("native_key_data");
-
-				unicodeInput(text, decodeModifiers(modifiers), native_key_data);
+				unicodeInput(event, native_key_data);
 			}
 			else if (message_name == "key_event")
 			{
 #if LL_DARWIN
 				std::string event = message_in.getValue("event");
-				S32 key = message_in.getValueS32("key");
                 LLSD native_key_data = message_in.getValueLLSD("native_key_data");
 
-#if 0
-				if (event == "down")
-				{
-					//mLLCEFLib->keyPress(key, true);
-					mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_DOWN, (uint32_t)key, 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
-
-				}
-				else if (event == "up")
-				{
-					//mLLCEFLib->keyPress(key, false);
-					mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_UP, (uint32_t)key, 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
-				}
-#else
-                // Treat unknown events as key-up for safety.
-                LLCEFLib::EKeyEvent key_event = LLCEFLib::KE_KEY_UP;
+                dullahan::EKeyEvent key_event = dullahan::KE_KEY_UP;
                 if (event == "down")
                 {
-                    key_event = LLCEFLib::KE_KEY_DOWN;
+                    key_event = dullahan::KE_KEY_DOWN;
                 }
                 else if (event == "repeat")
                 {
-                    key_event = LLCEFLib::KE_KEY_REPEAT;
+                    key_event = dullahan::KE_KEY_REPEAT;
                 }
 
-                keyEvent(key_event, key, LLCEFLib::KM_MODIFIER_NONE, native_key_data);
+                keyEvent(key_event, native_key_data);
 
-#endif
 #elif LL_WINDOWS
 				std::string event = message_in.getValue("event");
-				S32 key = message_in.getValueS32("key");
-				std::string modifiers = message_in.getValue("modifiers");
 				LLSD native_key_data = message_in.getValueLLSD("native_key_data");
 
 				// Treat unknown events as key-up for safety.
-				LLCEFLib::EKeyEvent key_event = LLCEFLib::KE_KEY_UP;
+				dullahan::EKeyEvent key_event = dullahan::KE_KEY_UP;
 				if (event == "down")
 				{
-					key_event = LLCEFLib::KE_KEY_DOWN;
+					key_event = dullahan::KE_KEY_DOWN;
 				}
 				else if (event == "repeat")
 				{
-					key_event = LLCEFLib::KE_KEY_REPEAT;
+					key_event = dullahan::KE_KEY_REPEAT;
 				}
 
-				keyEvent(key_event, key, decodeModifiers(modifiers), native_key_data);
+				keyEvent(key_event, native_key_data);
 #endif
 			}
 			else if (message_name == "enable_media_plugin_debugging")
@@ -718,15 +658,15 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			}
 			if (message_name == "edit_cut")
 			{
-				mLLCEFLib->editCut();
+				mCEFLib->editCut();
 			}
 			if (message_name == "edit_copy")
 			{
-				mLLCEFLib->editCopy();
+				mCEFLib->editCopy();
 			}
 			if (message_name == "edit_paste")
 			{
-				mLLCEFLib->editPaste();
+				mCEFLib->editPaste();
 			}
 		}
 		else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
@@ -734,24 +674,24 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			if (message_name == "set_page_zoom_factor")
 			{
 				F32 factor = (F32)message_in.getValueReal("factor");
-				mLLCEFLib->setPageZoom(factor);
+				mCEFLib->setPageZoom(factor);
 			}
 			if (message_name == "browse_stop")
 			{
-				mLLCEFLib->stop();
+				mCEFLib->stop();
 			}
 			else if (message_name == "browse_reload")
 			{
 				bool ignore_cache = true;
-				mLLCEFLib->reload(ignore_cache);
+				mCEFLib->reload(ignore_cache);
 			}
 			else if (message_name == "browse_forward")
 			{
-				mLLCEFLib->goForward();
+				mCEFLib->goForward();
 			}
 			else if (message_name == "browse_back")
 			{
-				mLLCEFLib->goBack();
+				mCEFLib->goBack();
 			}
 			else if (message_name == "cookies_enabled")
 			{
@@ -763,7 +703,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			}
 			else if (message_name == "show_web_inspector")
 			{
-				mLLCEFLib->showDevTools(true);
+				mCEFLib->showDevTools();
 			}
 			else if (message_name == "plugins_enabled")
 			{
@@ -773,13 +713,18 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			{
 				mJavascriptEnabled = message_in.getValueBoolean("enable");
 			}
+			else if (message_name == "gpu_disabled")
+			{
+				mDisableGPU = message_in.getValueBoolean("disable");
+			}
 		}
         else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
         {
             if (message_name == "set_volume")
             {
-                F32 volume = (F32)message_in.getValueReal("volume");
-                setVolume(volume);
+				F32 volume = (F32)message_in.getValueReal("volume");
+				mCurVolume = volume;
+                setVolume();
             }
         }
         else
@@ -788,100 +733,61 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 	}
 }
 
-LLCEFLib::EKeyboardModifier MediaPluginCEF::decodeModifiers(std::string &modifiers)
-{
-	int result = 0;
-
-	if (modifiers.find("shift") != std::string::npos)
-		result |= LLCEFLib::KM_MODIFIER_SHIFT;
-
-	if (modifiers.find("alt") != std::string::npos)
-		result |= LLCEFLib::KM_MODIFIER_ALT;
-
-	if (modifiers.find("control") != std::string::npos)
-		result |= LLCEFLib::KM_MODIFIER_CONTROL;
-
-	if (modifiers.find("meta") != std::string::npos)
-		result |= LLCEFLib::KM_MODIFIER_META;
-
-	return (LLCEFLib::EKeyboardModifier)result;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginCEF::deserializeKeyboardData(LLSD native_key_data, uint32_t& native_scan_code, uint32_t& native_virtual_key, uint32_t& native_modifiers)
+void MediaPluginCEF::keyEvent(dullahan::EKeyEvent key_event, LLSD native_key_data = LLSD::emptyMap())
 {
-	native_scan_code = 0;
-	native_virtual_key = 0;
-	native_modifiers = 0;
-
-	if (native_key_data.isMap())
-	{
 #if LL_DARWIN
-		native_scan_code = (uint32_t)(native_key_data["char_code"].asInteger());
-		native_virtual_key = (uint32_t)(native_key_data["key_code"].asInteger());
-		native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger());
-#elif LL_WINDOWS
-		native_scan_code = (uint32_t)(native_key_data["scan_code"].asInteger());
-		native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger());
-		// TODO: I don't think we need to do anything with native modifiers here -- please verify
-#endif
-	};
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-void MediaPluginCEF::keyEvent(LLCEFLib::EKeyEvent key_event, int key, LLCEFLib::EKeyboardModifier modifiers_x, LLSD native_key_data = LLSD::emptyMap())
-{
-#if LL_DARWIN
-
-    if (!native_key_data.has("event_type") ||
-            !native_key_data.has("event_modifiers") ||
-            !native_key_data.has("event_keycode") ||
-            !native_key_data.has("event_isrepeat"))
-        return;
-
-    uint32_t eventType = native_key_data["event_type"].asInteger();
-    if (!eventType)
-        return;
-    uint32_t eventModifiers = native_key_data["event_modifiers"].asInteger();
-    uint32_t eventKeycode = native_key_data["event_keycode"].asInteger();
-    char eventChars = static_cast<char>(native_key_data["event_chars"].isUndefined() ? 0 : native_key_data["event_chars"].asInteger());
-    char eventUChars = static_cast<char>(native_key_data["event_umodchars"].isUndefined() ? 0 : native_key_data["event_umodchars"].asInteger());
-    bool eventIsRepeat = native_key_data["event_isrepeat"].asBoolean();
-
-    mLLCEFLib->keyboardEventOSX(eventType, eventModifiers, (eventChars) ? &eventChars : NULL,
-                                (eventUChars) ? &eventUChars : NULL, eventIsRepeat, eventKeycode);
-
+	U32 event_modifiers = native_key_data["event_modifiers"].asInteger();
+	U32 event_keycode = native_key_data["event_keycode"].asInteger();
+	U32 event_chars = native_key_data["event_chars"].asInteger();
+	U32 event_umodchars = native_key_data["event_umodchars"].asInteger();
+	bool event_isrepeat = native_key_data["event_isrepeat"].asBoolean();
+
+	// adding new code below in unicodeInput means we don't send ascii chars
+	// here too or we get double key presses on a mac.  
+	if (((unsigned char)event_chars < 0x20 || (unsigned char)event_chars >= 0x7f ))
+	{
+		mCEFLib->nativeKeyboardEventOSX(key_event, event_modifiers, 
+										event_keycode, event_chars, 
+										event_umodchars, event_isrepeat);
+	}
 #elif LL_WINDOWS
 	U32 msg = ll_U32_from_sd(native_key_data["msg"]);
 	U32 wparam = ll_U32_from_sd(native_key_data["w_param"]);
 	U64 lparam = ll_U32_from_sd(native_key_data["l_param"]);
 
-	mLLCEFLib->nativeKeyboardEvent(msg, wparam, lparam);
+	mCEFLib->nativeKeyboardEventWin(msg, wparam, lparam);
 #endif
 };
 
-void MediaPluginCEF::unicodeInput(const std::string &utf8str, LLCEFLib::EKeyboardModifier modifiers, LLSD native_key_data = LLSD::emptyMap())
+void MediaPluginCEF::unicodeInput(std::string event, LLSD native_key_data = LLSD::emptyMap())
 {
 #if LL_DARWIN
-	//mLLCEFLib->keyPress(utf8str[0], true);
-	//mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_DOWN, (uint32_t)(utf8str[0]), 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
-    if (!native_key_data.has("event_chars") || !native_key_data.has("event_umodchars") ||
-            !native_key_data.has("event_keycode") || !native_key_data.has("event_modifiers"))
-        return;
-    uint32_t unicodeChar = native_key_data["event_chars"].asInteger();
-    uint32_t unmodifiedChar = native_key_data["event_umodchars"].asInteger();
-    uint32_t keyCode = native_key_data["event_keycode"].asInteger();
-    uint32_t rawmodifiers = native_key_data["event_modifiers"].asInteger();
-
-    mLLCEFLib->injectUnicodeText(unicodeChar, unmodifiedChar, keyCode, rawmodifiers);
-
+	// i didn't think this code was needed for macOS but without it, the IME
+	// input in japanese (and likely others too) doesn't work correctly.
+	// see maint-7654
+	U32 event_modifiers = native_key_data["event_modifiers"].asInteger();
+	U32 event_keycode = native_key_data["event_keycode"].asInteger();
+	U32 event_chars = native_key_data["event_chars"].asInteger();
+	U32 event_umodchars = native_key_data["event_umodchars"].asInteger();
+	bool event_isrepeat = native_key_data["event_isrepeat"].asBoolean();
+
+    dullahan::EKeyEvent key_event = dullahan::KE_KEY_UP;
+    if (event == "down")
+    {
+        key_event = dullahan::KE_KEY_DOWN;
+    }
+
+	mCEFLib->nativeKeyboardEventOSX(key_event, event_modifiers, 
+									event_keycode, event_chars, 
+									event_umodchars, event_isrepeat);
 #elif LL_WINDOWS
+	event = ""; // not needed here but prevents unused var warning as error
 	U32 msg = ll_U32_from_sd(native_key_data["msg"]);
 	U32 wparam = ll_U32_from_sd(native_key_data["w_param"]);
 	U64 lparam = ll_U32_from_sd(native_key_data["l_param"]);
-	mLLCEFLib->nativeKeyboardEvent(msg, wparam, lparam);
+	mCEFLib->nativeKeyboardEventWin(msg, wparam, lparam);
 #endif
 };
 
@@ -889,9 +795,9 @@ void MediaPluginCEF::unicodeInput(const std::string &utf8str, LLCEFLib::EKeyboar
 //
 void MediaPluginCEF::checkEditState()
 {
-	bool can_cut = mLLCEFLib->editCanCut();
-	bool can_copy = mLLCEFLib->editCanCopy();
-	bool can_paste = mLLCEFLib->editCanPaste();
+	bool can_cut = mCEFLib->editCanCut();
+	bool can_copy = mCEFLib->editCanCopy();
+	bool can_paste = mCEFLib->editCanPaste();
 
 	if ((can_cut != mCanCut) || (can_copy != mCanCopy) || (can_paste != mCanPaste))
 	{
@@ -919,9 +825,9 @@ void MediaPluginCEF::checkEditState()
 	}
 }
 
-void MediaPluginCEF::setVolume(F32 vol)
+void MediaPluginCEF::setVolume()
 {
-    mVolumeCatcher.setVolume(vol);
+	mVolumeCatcher.setVolume(mCurVolume);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/indra/media_plugins/cef/windows_volume_catcher.cpp b/indra/media_plugins/cef/windows_volume_catcher.cpp
index c9ea3ed597..6953ad3ab8 100644
--- a/indra/media_plugins/cef/windows_volume_catcher.cpp
+++ b/indra/media_plugins/cef/windows_volume_catcher.cpp
@@ -41,44 +41,15 @@ public:
 	void setPan(F32 pan);
 	
 private:
-	typedef void (WINAPI *set_volume_func_t)(F32);
-	typedef void (WINAPI *set_mute_func_t)(bool);
-
-	set_volume_func_t mSetVolumeFunc;
-	set_mute_func_t mSetMuteFunc;
-
-	// tests if running on Vista, 7, 8 + once in CTOR
-	bool isWindowsVistaOrHigher();
-
 	F32 	mVolume;
 	F32 	mPan;
 	bool mSystemIsVistaOrHigher;
 };
 
-bool VolumeCatcherImpl::isWindowsVistaOrHigher()
-{
-	OSVERSIONINFO osvi;
-	ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
-	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-	GetVersionEx(&osvi);
-	return osvi.dwMajorVersion >= 6;
-}
-
 VolumeCatcherImpl::VolumeCatcherImpl()
 :	mVolume(1.0f),			// default volume is max
 	mPan(0.f)				// default pan is centered
 {
-	mSystemIsVistaOrHigher = isWindowsVistaOrHigher();
-
-	if ( ! mSystemIsVistaOrHigher )
-	{
-		HMODULE handle = ::LoadLibrary(L"winmm.dll");
-		if(handle)
-		{
-			mSetVolumeFunc = (set_volume_func_t)::GetProcAddress(handle, "setPluginVolume");
-			mSetMuteFunc = (set_mute_func_t)::GetProcAddress(handle, "setPluginMute");
-		}
-	}
 }
 
 VolumeCatcherImpl::~VolumeCatcherImpl()
@@ -89,26 +60,12 @@ void VolumeCatcherImpl::setVolume(F32 volume)
 {
 	mVolume = volume;
 
-	if ( mSystemIsVistaOrHigher )
-	{
-		// set both left/right to same volume
-		// TODO: use pan value to set independently
-		DWORD left_channel  = (DWORD)(mVolume * 65535.0f);
-		DWORD right_channel =  (DWORD)(mVolume * 65535.0f);
-		DWORD hw_volume = left_channel << 16 | right_channel;
-		::waveOutSetVolume(NULL, hw_volume);
-	}
-	else
-	{
-		if (mSetMuteFunc)
-		{
-			mSetMuteFunc(volume == 0.f);
-		}
-		if (mSetVolumeFunc)
-		{
-			mSetVolumeFunc(mVolume);
-		}
-	}
+	// set both left/right to same volume
+	// TODO: use pan value to set independently
+	DWORD left_channel = (DWORD)(mVolume * 65535.0f);
+	DWORD right_channel = (DWORD)(mVolume * 65535.0f);
+	DWORD hw_volume = left_channel << 16 | right_channel;
+	::waveOutSetVolume(NULL, hw_volume);
 }
 
 void VolumeCatcherImpl::setPan(F32 pan)
diff --git a/indra/media_plugins/example/CMakeLists.txt b/indra/media_plugins/example/CMakeLists.txt
index 171645ef04..6f5b28b8e9 100644
--- a/indra/media_plugins/example/CMakeLists.txt
+++ b/indra/media_plugins/example/CMakeLists.txt
@@ -32,13 +32,13 @@ include_directories(SYSTEM
 
 ### media_plugin_example
 
-if(NOT WORD_SIZE EQUAL 32)
+if(NOT ADDRESS_SIZE EQUAL 32)
   if(WINDOWS)
-    add_definitions(/FIXED:NO)
+    ##add_definitions(/FIXED:NO)
   else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
     add_definitions(-fPIC)
   endif(WINDOWS)
-endif(NOT WORD_SIZE EQUAL 32)
+endif(NOT ADDRESS_SIZE EQUAL 32)
 
 set(media_plugin_example_SOURCE_FILES
     media_plugin_example.cpp
@@ -60,14 +60,16 @@ target_link_libraries(media_plugin_example
 add_dependencies(media_plugin_example
   ${LLPLUGIN_LIBRARIES}
   ${MEDIA_PLUGIN_BASE_LIBRARIES}
-  ${LLCOMMON_LIBRARIES}
+  # Using ${LLCOMMON_LIBRARIES} here drags in a whole bunch of Boost stuff
+  # that only produces CMake warnings about nonexistent dependencies.
+  llcommon
 )
 
 if (WINDOWS)
   set_target_properties(
     media_plugin_example
     PROPERTIES
-    LINK_FLAGS "/MANIFEST:NO"
+    LINK_FLAGS "/MANIFEST:NO /SAFESEH:NO /LTCG /NODEFAULTLIB:LIBCMT"
     )
 endif (WINDOWS)
 
diff --git a/indra/media_plugins/example/media_plugin_example.cpp b/indra/media_plugins/example/media_plugin_example.cpp
index 66c00cd58c..c296a0413d 100644
--- a/indra/media_plugins/example/media_plugin_example.cpp
+++ b/indra/media_plugins/example/media_plugin_example.cpp
@@ -1,30 +1,30 @@
 /**
- * @file media_plugin_example.cpp
- * @brief Example plugin for LLMedia API plugin system
- *
- * @cond
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- * @endcond
- */
+* @file media_plugin_example.cpp
+* @brief Example plugin for LLMedia API plugin system
+*
+* @cond
+* $LicenseInfo:firstyear=2008&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2010, Linden Research, Inc.
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation;
+* version 2.1 of the License only.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*
+* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+* $/LicenseInfo$
+* @endcond
+*/
 
 #include "linden_common.h"
 
@@ -38,375 +38,354 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-class MediaPluginExample :
-        public MediaPluginBase
+class mediaPluginExample :
+	public MediaPluginBase
 {
-    public:
-        MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data );
-        ~MediaPluginExample();
-
-        /*virtual*/ void receiveMessage( const char* message_string );
-
-    private:
-        bool init();
-        void update( F64 milliseconds );
-        void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b );
-        bool mFirstTime;
-
-        time_t mLastUpdateTime;
-        enum Constants { ENumObjects = 10 };
-        unsigned char* mBackgroundPixels;
-        int mColorR[ ENumObjects ];
-        int mColorG[ ENumObjects ];
-        int mColorB[ ENumObjects ];
-        int mXpos[ ENumObjects ];
-        int mYpos[ ENumObjects ];
-        int mXInc[ ENumObjects ];
-        int mYInc[ ENumObjects ];
-        int mBlockSize[ ENumObjects ];
-        bool mMouseButtonDown;
-        bool mStopAction;
+public:
+	mediaPluginExample(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+	~mediaPluginExample();
+
+	/*virtual*/ void receiveMessage(const char* message_string);
+
+private:
+	bool init();
+	void update(F64 milliseconds);
+	bool mFirstTime;
+
+	time_t mLastUpdateTime;
+	enum Constants { ENumObjects = 64 };
+	unsigned char* mBackgroundPixels;
+	int mColorR[ENumObjects];
+	int mColorG[ENumObjects];
+	int mColorB[ENumObjects];
+	int mXpos[ENumObjects];
+	int mYpos[ENumObjects];
+	int mXInc[ENumObjects];
+	int mYInc[ENumObjects];
+	int mBlockSize[ENumObjects];
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-MediaPluginExample::MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data ) :
-    MediaPluginBase( host_send_func, host_user_data )
+mediaPluginExample::mediaPluginExample(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data) :
+MediaPluginBase(host_send_func, host_user_data)
 {
-    mFirstTime = true;
-    mWidth = 0;
-    mHeight = 0;
-    mDepth = 4;
-    mPixels = 0;
-    mMouseButtonDown = false;
-    mStopAction = false;
-    mLastUpdateTime = 0;
+	mFirstTime = true;
+	mTextureWidth = 0;
+	mTextureHeight = 0;
+	mWidth = 0;
+	mHeight = 0;
+	mDepth = 4;
+	mPixels = 0;
+	mLastUpdateTime = 0;
+	mBackgroundPixels = 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-MediaPluginExample::~MediaPluginExample()
+mediaPluginExample::~mediaPluginExample()
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginExample::receiveMessage( const char* message_string )
+void mediaPluginExample::receiveMessage(const char* message_string)
 {
-//  std::cerr << "MediaPluginWebKit::receiveMessage: received message: \"" << message_string << "\"" << std::endl;
-    LLPluginMessage message_in;
-
-    if(message_in.parse(message_string) >= 0)
-    {
-        std::string message_class = message_in.getClass();
-        std::string message_name = message_in.getName();
-        if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
-        {
-            if(message_name == "init")
-            {
-                LLPluginMessage message("base", "init_response");
-                LLSD versions = LLSD::emptyMap();
-                versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
-                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
-                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
-                message.setValueLLSD("versions", versions);
-
-                std::string plugin_version = "Example plugin 1.0..0";
-                message.setValue("plugin_version", plugin_version);
-                sendMessage(message);
-            }
-            else if(message_name == "idle")
-            {
-                // no response is necessary here.
-                F64 time = message_in.getValueReal("time");
-
-                // Convert time to milliseconds for update()
-                update((int)(time * 1000.0f));
-            }
-            else if(message_name == "cleanup")
-            {
-            }
-            else if(message_name == "shm_added")
-            {
-                SharedSegmentInfo info;
-                info.mAddress = message_in.getValuePointer("address");
-                info.mSize = (size_t)message_in.getValueS32("size");
-                std::string name = message_in.getValue("name");
-
-                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
-
-            }
-            else if(message_name == "shm_remove")
-            {
-                std::string name = message_in.getValue("name");
-
-                SharedSegmentMap::iterator iter = mSharedSegments.find(name);
-                if(iter != mSharedSegments.end())
-                {
-                    if(mPixels == iter->second.mAddress)
-                    {
-                        // This is the currently active pixel buffer.  Make sure we stop drawing to it.
-                        mPixels = NULL;
-                        mTextureSegmentName.clear();
-                    }
-                    mSharedSegments.erase(iter);
-                }
-                else
-                {
-//                  std::cerr << "MediaPluginWebKit::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 << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl;
-            }
-        }
-        else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
-        {
-            if(message_name == "init")
-            {
-                // Plugin gets to decide the texture parameters to use.
-                mDepth = 4;
-                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
-                message.setValueS32("default_width", 1024);
-                message.setValueS32("default_height", 1024);
-                message.setValueS32("depth", mDepth);
-                message.setValueU32("internalformat", GL_RGBA);
-                message.setValueU32("format", GL_RGBA);
-                message.setValueU32("type", GL_UNSIGNED_BYTE);
-                message.setValueBoolean("coords_opengl", true);
-                sendMessage(message);
-            }
-            else if(message_name == "size_change")
-            {
-                std::string name = message_in.getValue("name");
-                S32 width = message_in.getValueS32("width");
-                S32 height = message_in.getValueS32("height");
-                S32 texture_width = message_in.getValueS32("texture_width");
-                S32 texture_height = message_in.getValueS32("texture_height");
-
-                if(!name.empty())
-                {
-                    // Find the shared memory region with this name
-                    SharedSegmentMap::iterator iter = mSharedSegments.find(name);
-                    if(iter != mSharedSegments.end())
-                    {
-                        mPixels = (unsigned char*)iter->second.mAddress;
-                        mWidth = width;
-                        mHeight = height;
-
-                        mTextureWidth = texture_width;
-                        mTextureHeight = 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);
-
-            }
-            else if(message_name == "load_uri")
-            {
-            }
-            else if(message_name == "mouse_event")
-            {
-                std::string event = message_in.getValue("event");
-                if(event == "down")
-                {
-
-                }
-                else if(event == "up")
-                {
-                }
-                else if(event == "double_click")
-                {
-                }
-            }
-        }
-        else
-        {
-//          std::cerr << "MediaPluginWebKit::receiveMessage: unknown message class: " << message_class << std::endl;
-        };
-    }
+	//  std::cerr << "MediaPluginWebKit::receiveMessage: received message: \"" << message_string << "\"" << std::endl;
+	LLPluginMessage message_in;
+
+	if (message_in.parse(message_string) >= 0)
+	{
+		std::string message_class = message_in.getClass();
+		std::string message_name = message_in.getName();
+		if (message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
+		{
+			if (message_name == "init")
+			{
+				LLPluginMessage message("base", "init_response");
+				LLSD versions = LLSD::emptyMap();
+				versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
+				versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
+				versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
+				message.setValueLLSD("versions", versions);
+
+				std::string plugin_version = "Example plugin 0.0.0";
+				message.setValue("plugin_version", plugin_version);
+				sendMessage(message);
+			}
+			else if (message_name == "idle")
+			{
+				// no response is necessary here.
+				F64 time = message_in.getValueReal("time");
+
+				// Convert time to milliseconds for update()
+				update((int)(time * 1000.0f));
+			}
+			else if (message_name == "cleanup")
+			{
+				LLPluginMessage message("base", "goodbye");
+				sendMessage(message);
+
+				mDeleteMe = true;
+			}
+			else if (message_name == "shm_added")
+			{
+				SharedSegmentInfo info;
+				info.mAddress = message_in.getValuePointer("address");
+				info.mSize = (size_t)message_in.getValueS32("size");
+				std::string name = message_in.getValue("name");
+
+				mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+
+			}
+			else if (message_name == "shm_remove")
+			{
+				std::string name = message_in.getValue("name");
+
+				SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+				if (iter != mSharedSegments.end())
+				{
+					if (mPixels == iter->second.mAddress)
+					{
+						// This is the currently active pixel buffer.  Make sure we stop drawing to it.
+						mPixels = NULL;
+						mTextureSegmentName.clear();
+					}
+					mSharedSegments.erase(iter);
+				}
+				else
+				{
+					//                  std::cerr << "MediaPluginWebKit::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 << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl;
+			}
+		}
+		else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
+		{
+			if (message_name == "init")
+			{
+				// Plugin gets to decide the texture parameters to use.
+				mDepth = 4;
+				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+				message.setValueS32("default_width", 1024);
+				message.setValueS32("default_height", 1024);
+				message.setValueS32("depth", mDepth);
+				message.setValueU32("internalformat", GL_RGB);
+				message.setValueU32("format", GL_RGBA);
+				message.setValueU32("type", GL_UNSIGNED_BYTE);
+				message.setValueBoolean("coords_opengl", true);
+				sendMessage(message);
+			}
+			else if (message_name == "size_change")
+			{
+				std::string name = message_in.getValue("name");
+				S32 width = message_in.getValueS32("width");
+				S32 height = message_in.getValueS32("height");
+				S32 texture_width = message_in.getValueS32("texture_width");
+				S32 texture_height = message_in.getValueS32("texture_height");
+
+				if (!name.empty())
+				{
+					// Find the shared memory region with this name
+					SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+					if (iter != mSharedSegments.end())
+					{
+						mPixels = (unsigned char*)iter->second.mAddress;
+						mWidth = width;
+						mHeight = height;
+
+						mTextureWidth = texture_width;
+						mTextureHeight = 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);
+
+				mFirstTime = true;
+				mLastUpdateTime = 0;
+
+			}
+			else if (message_name == "load_uri")
+			{
+			}
+			else if (message_name == "mouse_event")
+			{
+				std::string event = message_in.getValue("event");
+				if (event == "down")
+				{
+
+				}
+				else if (event == "up")
+				{
+				}
+				else if (event == "double_click")
+				{
+				}
+			}
+		}
+		else
+		{
+		};
+	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginExample::write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
+void mediaPluginExample::update(F64 milliseconds)
 {
-    // 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;
-        pixel += ( x * mDepth );
-        pixel[ 0 ] = b;
-        pixel[ 1 ] = g;
-        pixel[ 2 ] = r;
-
-        setDirty( x, y, x + 1, y + 1 );
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-void MediaPluginExample::update( F64 milliseconds )
-{
-    if ( mWidth < 1 || mWidth > 2048 || mHeight < 1 || mHeight > 2048 )
-        return;
-
-    if ( mPixels == 0 )
-            return;
-
-    if ( mFirstTime )
-    {
-        for( int n = 0; n < ENumObjects; ++n )
-        {
-            mXpos[ n ] = ( mWidth / 2 ) + rand() % ( mWidth / 16 ) - ( mWidth / 32 );
-            mYpos[ n ] = ( mHeight / 2 ) + rand() % ( mHeight / 16 ) - ( mHeight / 32 );
-
-            mColorR[ n ] = rand() % 0x60 + 0x60;
-            mColorG[ n ] = rand() % 0x60 + 0x60;
-            mColorB[ n ] = rand() % 0x60 + 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() % 0x30 + 0x10;
-        };
-
-        delete [] mBackgroundPixels;
-
-        mBackgroundPixels = new unsigned char[ mWidth * mHeight * mDepth ];
-
-        mFirstTime = false;
-    };
-
-    if ( mStopAction )
-        return;
-
-    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 < ENumObjects; ++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 ];
-            };
-        };
-    };
-
-    setDirty( 0, 0, mWidth, mHeight );
+	if (mWidth < 1 || mWidth > 2048 || mHeight < 1 || mHeight > 2048)
+		return;
+
+	if (mPixels == 0)
+		return;
+
+	if (mFirstTime)
+	{
+		for (int n = 0; n < ENumObjects; ++n)
+		{
+			mXpos[n] = (mWidth / 2) + rand() % (mWidth / 16) - (mWidth / 32);
+			mYpos[n] = (mHeight / 2) + rand() % (mHeight / 16) - (mHeight / 32);
+
+			mColorR[n] = rand() % 0x60 + 0x60;
+			mColorG[n] = rand() % 0x60 + 0x60;
+			mColorB[n] = rand() % 0x60 + 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() % 0x30 + 0x10;
+		};
+
+		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 < ENumObjects; ++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];
+			};
+		};
+	};
+
+	setDirty(0, 0, mWidth, mHeight);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-bool MediaPluginExample::init()
+bool mediaPluginExample::init()
 {
-    LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text" );
-    message.setValue( "name", "Example Plugin" );
-    sendMessage( message );
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
+	message.setValue("name", "Example Plugin");
+	sendMessage(message);
 
-    return true;
+	return true;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-int init_media_plugin( LLPluginInstance::sendMessageFunction host_send_func,
-                        void* host_user_data,
-                        LLPluginInstance::sendMessageFunction *plugin_send_func,
-                        void **plugin_user_data )
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func,
+	void* host_user_data,
+	LLPluginInstance::sendMessageFunction *plugin_send_func,
+	void **plugin_user_data)
 {
-    MediaPluginExample* self = new MediaPluginExample( host_send_func, host_user_data );
-    *plugin_send_func = MediaPluginExample::staticReceiveMessage;
-    *plugin_user_data = ( void* )self;
+	mediaPluginExample* self = new mediaPluginExample(host_send_func, host_user_data);
+	*plugin_send_func = mediaPluginExample::staticReceiveMessage;
+	*plugin_user_data = (void*)self;
 
-    return 0;
+	return 0;
 }
-
diff --git a/indra/media_plugins/gstreamer010/CMakeLists.txt b/indra/media_plugins/gstreamer010/CMakeLists.txt
index 447f6e0689..6d18814b1e 100644
--- a/indra/media_plugins/gstreamer010/CMakeLists.txt
+++ b/indra/media_plugins/gstreamer010/CMakeLists.txt
@@ -33,13 +33,13 @@ include_directories(SYSTEM
 
 ### media_plugin_gstreamer010
 
-if(NOT WORD_SIZE EQUAL 32)
+if(NOT ADDRESS_SIZE EQUAL 32)
   if(WINDOWS)
-    add_definitions(/FIXED:NO)
+    ##add_definitions(/FIXED:NO)
   else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
     add_definitions(-fPIC)
   endif(WINDOWS)
-endif(NOT WORD_SIZE EQUAL 32)
+endif(NOT ADDRESS_SIZE EQUAL 32)
 
 set(media_plugin_gstreamer010_SOURCE_FILES
     media_plugin_gstreamer010.cpp
diff --git a/indra/media_plugins/libvlc/CMakeLists.txt b/indra/media_plugins/libvlc/CMakeLists.txt
index 535d29125b..d3e9243069 100644
--- a/indra/media_plugins/libvlc/CMakeLists.txt
+++ b/indra/media_plugins/libvlc/CMakeLists.txt
@@ -33,13 +33,13 @@ include_directories(SYSTEM
 
 ### media_plugin_libvlc
 
-if(NOT WORD_SIZE EQUAL 32)
+if(NOT ADDRESS_SIZE EQUAL 32)
   if(WINDOWS)
-    add_definitions(/FIXED:NO)
+    ##add_definitions(/FIXED:NO)
   else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
     add_definitions(-fPIC)
   endif(WINDOWS)
-endif(NOT WORD_SIZE EQUAL 32)
+endif(NOT ADDRESS_SIZE EQUAL 32)
 
 set(media_plugin_libvlc_SOURCE_FILES
     media_plugin_libvlc.cpp
@@ -61,14 +61,24 @@ target_link_libraries(media_plugin_libvlc
 add_dependencies(media_plugin_libvlc
   ${LLPLUGIN_LIBRARIES}
   ${MEDIA_PLUGIN_BASE_LIBRARIES}
-  ${LLCOMMON_LIBRARIES}
+##${LLCOMMON_LIBRARIES}
+  # Just say 'llcommon' here. LLCOMMON_LIBRARIES is specified for use in
+  # target_link_libraries: it includes several Boost libraries, which are
+  # absolutely NOT dependencies in the sense intended here. Those Boost
+  # library macros, in turn, specify 'debug' and 'optimized' and a different
+  # library name for each, producing several wordy errors:
+  # Policy CMP0046 is not set: Error on non-existent dependency in
+  # add_dependencies.
+  # Really, the only dependency we should mention from LLCOMMON_LIBRARIES is
+  # llcommon itself.
+  llcommon
 )
 
 if (WINDOWS)
   set_target_properties(
     media_plugin_libvlc
     PROPERTIES
-    LINK_FLAGS "/MANIFEST:NO /SAFESEH:NO /LTCG /NODEFAULTLIB:LIBCMT"
+    LINK_FLAGS "/MANIFEST:NO /SAFESEH:NO /NODEFAULTLIB:LIBCMT"
     )
 endif (WINDOWS)
 
diff --git a/indra/media_plugins/libvlc/media_plugin_libvlc.cpp b/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
index ebcdde2960..80702a1079 100644
--- a/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
+++ b/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
@@ -37,6 +37,11 @@
 #include "vlc/vlc.h"
 #include "vlc/libvlc_version.h"
 
+#if LL_WINDOWS
+// needed for waveOut call - see below for description
+#include <mmsystem.h>
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 class MediaPluginLibVLC :
@@ -55,6 +60,7 @@ private:
 	void playMedia();
 	void resetVLC();
 	void setVolume(const F64 volume);
+	void setVolumeVLC();
 	void updateTitle(const char* title);
 
 	static void* lock(void* data, void** p_pixels);
@@ -161,6 +167,10 @@ void MediaPluginLibVLC::initVLC()
 		"--video-filter=transform{type=vflip}",  // MAINT-6578 Y flip textures in plugin vs client
 	};
 
+#if LL_DARWIN
+	setenv("VLC_PLUGIN_PATH", ".", 1);
+#endif
+
 	int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
 	mLibVLC = libvlc_new(vlc_argc, vlc_argv);
 
@@ -217,6 +227,7 @@ void MediaPluginLibVLC::eventCallbacks(const libvlc_event_t* event, void* ptr)
 	case libvlc_MediaPlayerPlaying:
 		parent->mDuration = (float)(libvlc_media_get_duration(parent->mLibVLCMedia)) / 1000.0f;
 		parent->mVlcStatus = STATUS_PLAYING;
+		parent->setVolumeVLC();
 		break;
 
 	case libvlc_MediaPlayerPaused:
@@ -390,30 +401,60 @@ void MediaPluginLibVLC::updateTitle(const char* title)
 	sendMessage(message);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-void MediaPluginLibVLC::setVolume(const F64 volume)
+void MediaPluginLibVLC::setVolumeVLC()
 {
-	mCurVolume = volume;
-
 	if (mLibVLCMediaPlayer)
 	{
-		int result = libvlc_audio_set_volume(mLibVLCMediaPlayer, (int)(volume * 100));
-		if (result != 0)
+		int vlc_vol = (int)(mCurVolume * 100);
+
+		int result = libvlc_audio_set_volume(mLibVLCMediaPlayer, vlc_vol);
+		if (result == 0)
+		{
+			// volume change was accepted by LibVLC
+		}
+		else
 		{
-			// volume wasn't set but not much to be done here
+			// volume change was NOT accepted by LibVLC and not actioned
 		}
+
+#if LL_WINDOWS
+		// https ://jira.secondlife.com/browse/MAINT-8119
+		// CEF media plugin uses code in media_plugins/cef/windows_volume_catcher.cpp to
+		// set the actual output volume of the plugin process since there is no API in 
+		// CEF to otherwise do this.
+		// There are explicit calls to change the volume in LibVLC but sometimes they
+		// are ignored SLPlugin.exe process volume is set to 0 so you never heard audio
+		// from the VLC media stream.
+		// The right way to solve this is to move the volume catcher stuff out of 
+		// the CEF plugin and into it's own folder under media_plugins and have it referenced
+		// by both CEF and VLC. That's for later. The code there boils down to this so for 
+                // now, as we approach a release, the less risky option is to do it directly vs
+                // calls to volume catcher code.
+		DWORD left_channel = (DWORD)(mCurVolume * 65535.0f);
+		DWORD right_channel = (DWORD)(mCurVolume * 65535.0f);
+		DWORD hw_volume = left_channel << 16 | right_channel;
+		waveOutSetVolume(NULL, hw_volume);
+#endif
 	}
 	else
 	{
 		// volume change was requested but VLC wasn't ready.
-		// that's okay thought because we saved the value in mCurVolume and 
+		// that's okay though because we saved the value in mCurVolume and 
 		// the next volume change after the VLC system is initilzied  will set it
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+void MediaPluginLibVLC::setVolume(const F64 volume)
+{
+	mCurVolume = volume;
+
+	setVolumeVLC();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
 void MediaPluginLibVLC::receiveMessage(const char* message_string)
 {
 	LLPluginMessage message_in;
diff --git a/indra/media_plugins/quicktime/CMakeLists.txt b/indra/media_plugins/quicktime/CMakeLists.txt
deleted file mode 100755
index 58391007ff..0000000000
--- a/indra/media_plugins/quicktime/CMakeLists.txt
+++ /dev/null
@@ -1,94 +0,0 @@
-# -*- cmake -*-
-
-project(media_plugin_quicktime)
-
-include(00-Common)
-include(LLCommon)
-include(LLImage)
-include(LLPlugin)
-include(LLMath)
-include(LLRender)
-include(LLWindow)
-include(Linking)
-include(PluginAPI)
-include(MediaPluginBase)
-include(OpenGL)
-include(QuickTimePlugin)
-
-include_directories(
-    ${LLPLUGIN_INCLUDE_DIRS}
-    ${MEDIA_PLUGIN_BASE_INCLUDE_DIRS}
-    ${LLCOMMON_INCLUDE_DIRS}
-    ${LLMATH_INCLUDE_DIRS}
-    ${LLIMAGE_INCLUDE_DIRS}
-    ${LLRENDER_INCLUDE_DIRS}
-    ${LLWINDOW_INCLUDE_DIRS}
-)
-include_directories(SYSTEM
-    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
-    )
-
-if (DARWIN)
-    include(CMakeFindFrameworks)
-    find_library(CARBON_LIBRARY Carbon)
-endif (DARWIN)
-
-
-### media_plugin_quicktime
-
-set(media_plugin_quicktime_SOURCE_FILES
-    media_plugin_quicktime.cpp
-    )
-
-add_library(media_plugin_quicktime
-    SHARED
-    ${media_plugin_quicktime_SOURCE_FILES}
-)
-
-target_link_libraries(media_plugin_quicktime
-  ${LLPLUGIN_LIBRARIES}
-  ${MEDIA_PLUGIN_BASE_LIBRARIES}
-  ${LLCOMMON_LIBRARIES}
-  ${QUICKTIME_LIBRARY}
-  ${PLUGIN_API_WINDOWS_LIBRARIES}
-)
-
-add_dependencies(media_plugin_quicktime
-  ${LLPLUGIN_LIBRARIES}
-  ${MEDIA_PLUGIN_BASE_LIBRARIES}
-  ${LLCOMMON_LIBRARIES}
-)
-
-if (WINDOWS)
-  set_target_properties(
-    media_plugin_quicktime
-    PROPERTIES
-    LINK_FLAGS "/MANIFEST:NO"
-    )
-endif (WINDOWS)
-
-if (QUICKTIME)
-
-    add_definitions(-DLL_QUICKTIME_ENABLED=1)
-
-    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(
-        media_plugin_quicktime
-        PROPERTIES
-        PREFIX ""
-        BUILD_WITH_INSTALL_RPATH 1
-        INSTALL_NAME_DIR "@executable_path"
-        LINK_FLAGS "-exported_symbols_list ${CMAKE_CURRENT_SOURCE_DIR}/../base/media_plugin_base.exp"
-      )
-
-# We use a bunch of deprecated system APIs.
-    set_source_files_properties(
-        media_plugin_quicktime.cpp PROPERTIES
-        COMPILE_FLAGS -Wno-deprecated-declarations
-        )
-    find_library(CARBON_LIBRARY Carbon)
-    target_link_libraries(media_plugin_quicktime ${CARBON_LIBRARY})
-  endif (DARWIN)
-endif (QUICKTIME)
-
diff --git a/indra/media_plugins/quicktime/media_plugin_quicktime.cpp b/indra/media_plugins/quicktime/media_plugin_quicktime.cpp
deleted file mode 100755
index b43598e4a5..0000000000
--- a/indra/media_plugins/quicktime/media_plugin_quicktime.cpp
+++ /dev/null
@@ -1,1085 +0,0 @@
-/**
- * @file media_plugin_quicktime.cpp
- * @brief QuickTime plugin for LLMedia API plugin system
- *
- * @cond
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- * @endcond
- */
-
-#include "linden_common.h"
-
-#include "llgl.h"
- 
-#include "llplugininstance.h"
-#include "llpluginmessage.h"
-#include "llpluginmessageclasses.h"
-#include "media_plugin_base.h"
- 
-#if LL_QUICKTIME_ENABLED
- 
-#if defined(LL_DARWIN)
-#include <QuickTime/QuickTime.h>
-#elif defined(LL_WINDOWS)
-#include "llwin32headers.h"
-#include "MacTypes.h"
-#include "QTML.h"
-#include "Movies.h"
-#include "QDoffscreen.h"
-#include "FixMath.h"
-#include "QTLoadLibraryUtils.h"
-#endif
-
-
-
-// TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
-////////////////////////////////////////////////////////////////////////////////
-//
-class MediaPluginQuickTime : public MediaPluginBase
-{
-public:
-	MediaPluginQuickTime(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
-	~MediaPluginQuickTime();
-
-	/* virtual */ void receiveMessage(const char *message_string);
-
-private:
-
-	int mNaturalWidth;
-	int mNaturalHeight;
-	Movie mMovieHandle;
-	GWorldPtr mGWorldHandle;
-	ComponentInstance mMovieController;
-	int mCurVolume;
-	bool mMediaSizeChanging;
-	bool mIsLooping;
-	std::string mMovieTitle;
-	bool mReceivedTitle;
-	const int mMinWidth;
-	const int mMaxWidth;
-	const int mMinHeight;
-	const int mMaxHeight;
-	F64 mPlayRate;
-	std::string mNavigateURL;
-
-	enum ECommand {
-		COMMAND_NONE,
-		COMMAND_STOP,
-		COMMAND_PLAY,
-		COMMAND_FAST_FORWARD,
-		COMMAND_FAST_REWIND,
-		COMMAND_PAUSE,
-		COMMAND_SEEK,
-	};
-	ECommand mCommand;
-
-	// Override this to add current time and duration to the message
-	/*virtual*/ void 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);
-
-		if(mMovieHandle)
-		{
-			message.setValueReal("current_time", getCurrentTime());
-			message.setValueReal("duration", getDuration());
-			message.setValueReal("current_rate", Fix2X(GetMovieRate(mMovieHandle)));
-		}
-
-		sendMessage(message);
-	}
-
-
-	static Rect rectFromSize(int width, int height)
-	{
-		Rect result;
-
-
-		result.left = 0;
-		result.top = 0;
-		result.right = width;
-		result.bottom = height;
-
-		return result;
-	}
-
-	Fixed getPlayRate(void)
-	{
-		Fixed result;
-		if(mPlayRate == 0.0f)
-		{
-			// Default to the movie's preferred rate
-			result = GetMoviePreferredRate(mMovieHandle);
-			if(result == 0)
-			{
-				// Don't return a 0 play rate, ever.
-				std::cerr << "Movie's preferred rate is 0, forcing to 1.0." << std::endl;
-				result = X2Fix(1.0f);
-			}
-		}
-		else
-		{
-			result = X2Fix(mPlayRate);
-		}
-
-		return result;
-	}
-
-	void load( const std::string url )
-	{
-
-		if ( url.empty() )
-			return;
-
-		// Stop and unload any existing movie before starting another one.
-		unload();
-
-		setStatus(STATUS_LOADING);
-
-		//In case std::string::c_str() makes a copy of the url data,
-		//make sure there is memory to hold it before allocating memory for handle.
-		//if fails, NewHandleClear(...) should return NULL.
-		const char* url_string = url.c_str() ;
-		Handle handle = NewHandleClear( ( Size )( url.length() + 1 ) );
-
-		if ( NULL == handle || noErr != MemError() || NULL == *handle )
-		{
-			setStatus(STATUS_ERROR);
-			return;
-		}
-
-		BlockMove( url_string, *handle, ( Size )( url.length() + 1 ) );
-
-		OSErr err = NewMovieFromDataRef( &mMovieHandle, newMovieActive | newMovieDontInteractWithUser | newMovieAsyncOK | newMovieIdleImportOK, nil, handle, URLDataHandlerSubType );
-		DisposeHandle( handle );
-		if ( noErr != err )
-		{
-			setStatus(STATUS_ERROR);
-			return;
-		};
-		
-		mNavigateURL = url;
-		LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_begin");
-		message.setValue("uri", mNavigateURL);
-		sendMessage(message);
-
-		// do pre-roll actions (typically fired for streaming movies but not always)
-		PrePrerollMovie( mMovieHandle, 0, getPlayRate(), moviePrePrerollCompleteCallback, ( void * )this );
-
-		Rect movie_rect = rectFromSize(mWidth, mHeight);
-
-		// make a new movie controller
-		mMovieController = NewMovieController( mMovieHandle, &movie_rect, mcNotVisible | mcTopLeftMovie );
-
-		// movie controller
-		MCSetActionFilterWithRefCon( mMovieController, mcActionFilterCallBack, ( long )this );
-
-		SetMoviePlayHints( mMovieHandle, hintsAllowDynamicResize, hintsAllowDynamicResize );
-
-		// function that gets called when a frame is drawn
-		SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, movieDrawingCompleteCallback, ( long )this );
-
-		setStatus(STATUS_LOADED);
-
-		sizeChanged();
-	};
-
-	bool unload()
-	{
-		// new movie and have to get title again
-		mReceivedTitle = false;
-
-		if ( mMovieHandle )
-		{
-			StopMovie( mMovieHandle );
-			if ( mMovieController )
-			{
-				MCMovieChanged( mMovieController, mMovieHandle );
-			};
-		};
-
-		if ( mMovieController )
-		{
-			MCSetActionFilterWithRefCon( mMovieController, NULL, (long)this );
-			DisposeMovieController( mMovieController );
-			mMovieController = NULL;
-		};
-
-		if ( mMovieHandle )
-		{
-			SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, nil, ( long )this );
-			DisposeMovie( mMovieHandle );
-			mMovieHandle = NULL;
-		};
-
-        mGWorldHandle = NULL;
-        
-		setStatus(STATUS_NONE);
-
-		return true;
-	}
-
-	bool navigateTo( const std::string url )
-	{
-		unload();
-		load( url );
-
-		return true;
-	};
-
-	bool sizeChanged()
-	{
-		if ( ! mMovieHandle )
-			return false;
-
-		// Check to see whether the movie's natural size has updated
-		{
-			int width, height;
-			getMovieNaturalSize(&width, &height);
-			if((width != 0) && (height != 0) && ((width != mNaturalWidth) || (height != mNaturalHeight)))
-			{
-				mNaturalWidth = width;
-				mNaturalHeight = height;
-
-				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_request");
-				message.setValue("name", mTextureSegmentName);
-				message.setValueS32("width", width);
-				message.setValueS32("height", height);
-				sendMessage(message);
-				//std::cerr << "<--- Sending size change request to application with name: " << mTextureSegmentName << " - size is " << width << " x " << height << std::endl;
-			}
-		}
-        
-
-		// sanitize destination size
-		Rect dest_rect = rectFromSize(mWidth, mHeight);
-
-		// media depth won't change
-		int depth_bits = mDepth * 8;
-		long rowbytes = mDepth * mTextureWidth;
-
-		if(mPixels != NULL)
-		{
-			// We have pixels.  Set up a GWorld pointing at the texture.
-			OSErr result = QTNewGWorldFromPtr( &mGWorldHandle, depth_bits, &dest_rect, NULL, NULL, 0, (Ptr)mPixels, rowbytes);
-			if ( noErr != result )
-			{
-				// TODO: unrecoverable??  throw exception?  return something?
-				return false;
-			}
-		}
-		else
-		{
-			// We don't have pixels. Create a fake GWorld we can point the movie at when it's not safe to render normally.
-			Rect tempRect = rectFromSize(1, 1);
-			OSErr result = QTNewGWorld( &mGWorldHandle, depth_bits, &tempRect, NULL, NULL, 0);
-			if ( noErr != result )
-			{
-				// TODO: unrecoverable??  throw exception?  return something?
-				return false;
-			}
-		}
-
-		SetMovieGWorld( mMovieHandle, mGWorldHandle, NULL );
-        
-		// Set up the movie display matrix
-		{
-			// scale movie to fit rect and invert vertically to match opengl image format
-			MatrixRecord transform;
-			SetIdentityMatrix( &transform );	// transforms are additive so start from identify matrix
-			double scaleX = (double) mWidth / mNaturalWidth;
-			double scaleY = -1.0 * (double) mHeight / mNaturalHeight;
-			double centerX = mWidth / 2.0;
-			double centerY = mHeight / 2.0;
-			ScaleMatrix( &transform, X2Fix( scaleX ), X2Fix( scaleY ), X2Fix( centerX ), X2Fix( centerY ) );
-			SetMovieMatrix( mMovieHandle, &transform );
-		}
-
-		// update movie controller
-		if ( mMovieController )
-		{
-			MCSetControllerPort( mMovieController, mGWorldHandle );
-			MCPositionController( mMovieController, &dest_rect, &dest_rect,
-								  mcTopLeftMovie | mcPositionDontInvalidate );
-			MCMovieChanged( mMovieController, mMovieHandle );
-		}
-
-
-		// Emit event with size change so the calling app knows about it too
-		// TODO:
-		//LLMediaEvent event( this );
-		//mEventEmitter.update( &LLMediaObserver::onMediaSizeChange, event );
-
-		return true;
-	}
-	static Boolean mcActionFilterCallBack( MovieController mc, short action, void *params, long ref )
-	{
-		Boolean result = false;
-
-		MediaPluginQuickTime* self = ( MediaPluginQuickTime* )ref;
-
-		switch( action )
-		{
-			// handle window resizing
-			case mcActionControllerSizeChanged:
-				// Ensure that the movie draws correctly at the new size
-				self->sizeChanged();
-				break;
-
-			// Block any movie controller actions that open URLs.
-			case mcActionLinkToURL:
-			case mcActionGetNextURL:
-			case mcActionLinkToURLExtended:
-				// Prevent the movie controller from handling the message
-				result = true;
-				break;
-
-			default:
-				break;
-		};
-
-		return result;
-	};
-
-	static OSErr movieDrawingCompleteCallback( Movie call_back_movie, long ref )
-	{
-		MediaPluginQuickTime* self = ( MediaPluginQuickTime* )ref;
-
-		// IMPORTANT: typically, a consumer who is observing this event will set a flag
-		// when this event is fired then render later. Be aware that the media stream
-		// can change during this period - dimensions, depth, format etc.
-		//LLMediaEvent event( self );
-//		self->updateQuickTime();
-		// TODO ^^^
-
-
-		if ( self->mWidth > 0 && self->mHeight > 0 )
-			self->setDirty( 0, 0, self->mWidth, self->mHeight );
-
-		return noErr;
-	};
-
-	static void moviePrePrerollCompleteCallback( Movie movie, OSErr preroll_err, void *ref )
-	{
-		MediaPluginQuickTime* self = ( MediaPluginQuickTime* )ref;
-
-		// TODO:
-		//LLMediaEvent event( self );
-		//self->mEventEmitter.update( &LLMediaObserver::onMediaPreroll, event );
-		
-		// Send a "navigate complete" event.
-		LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete");
-		message.setValue("uri", self->mNavigateURL);
-		message.setValueS32("result_code", 200);
-		message.setValue("result_string", "OK");
-		self->sendMessage(message);
-	};
-
-
-	void rewind()
-	{
-		GoToBeginningOfMovie( mMovieHandle );
-		MCMovieChanged( mMovieController, mMovieHandle );
-	};
-
-	bool processState()
-	{
-		if ( mCommand == COMMAND_PLAY )
-		{
-			if ( mStatus == STATUS_LOADED || mStatus == STATUS_PAUSED || mStatus == STATUS_PLAYING || mStatus == STATUS_DONE )
-			{
-				long state = GetMovieLoadState( mMovieHandle );
-
-				if ( state >= kMovieLoadStatePlaythroughOK )
-				{
-					// if the movie is at the end (generally because it reached it naturally)
-					// and we play is requested, jump back to the start of the movie.
-					// note: this is different from having loop flag set.
-					if ( IsMovieDone( mMovieHandle ) )
-					{
-						Fixed rate = X2Fix( 0.0 );
-						MCDoAction( mMovieController, mcActionPlay, (void*)rate );
-						rewind();
-					};
-
-					MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)getPlayRate() );
-					MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
-					setStatus(STATUS_PLAYING);
-					mCommand = COMMAND_NONE;
-				};
-			};
-		}
-		else
-		if ( mCommand == COMMAND_STOP )
-		{
-			if ( mStatus == STATUS_PLAYING || mStatus == STATUS_PAUSED || mStatus == STATUS_DONE )
-			{
-				if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
-				{
-					Fixed rate = X2Fix( 0.0 );
-					MCDoAction( mMovieController, mcActionPlay, (void*)rate );
-					rewind();
-
-					setStatus(STATUS_LOADED);
-					mCommand = COMMAND_NONE;
-				};
-			};
-		}
-		else
-		if ( mCommand == COMMAND_PAUSE )
-		{
-			if ( mStatus == STATUS_PLAYING )
-			{
-				if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
-				{
-					Fixed rate = X2Fix( 0.0 );
-					MCDoAction( mMovieController, mcActionPlay, (void*)rate );
-					setStatus(STATUS_PAUSED);
-					mCommand = COMMAND_NONE;
-				};
-			};
-		};
-
-		return true;
-	};
-
-	void play(F64 rate)
-	{
-		mPlayRate = rate;
-		mCommand = COMMAND_PLAY;
-	};
-
-	void stop()
-	{
-		mCommand = COMMAND_STOP;
-	};
-
-	void pause()
-	{
-		mCommand = COMMAND_PAUSE;
-	};
-
-	void getMovieNaturalSize(int *movie_width, int *movie_height)
-	{
-		Rect rect;
-
-		GetMovieNaturalBoundsRect( mMovieHandle, &rect );
-
-		int width  = ( rect.right - rect.left );
-		int height = ( rect.bottom - rect.top );
-
-		// make sure width and height fall in valid range
-		if ( width < mMinWidth )
-			width = mMinWidth;
-
-		if ( width > mMaxWidth )
-			width = mMaxWidth;
-
-		if ( height < mMinHeight )
-			height = mMinHeight;
-
-		if ( height > mMaxHeight )
-			height = mMaxHeight;
-
-		// return the new rect
-		*movie_width = width;
-		*movie_height = height;
-	}
-
-	void updateQuickTime(int milliseconds)
-	{
-		if ( ! mMovieHandle )
-			return;
-
-		if ( ! mMovieController )
-			return;
-
-		// this wasn't required in 1.xx viewer but we have to manually 
-		// work the Windows message pump now
-		#if defined( LL_WINDOWS )
-		MSG msg;
-		while ( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) ) 
-		{
-			GetMessage( &msg, NULL, 0, 0 );
-			TranslateMessage( &msg );
-			DispatchMessage( &msg );
-		};
-		#endif
-
-		MCIdle( mMovieController );
-
-		if ( ! mGWorldHandle )
-			return;
-
-		if ( mMediaSizeChanging )
-			return;
-
-		// update state machine
-		processState();
-
-		// see if title arrived and if so, update member variable with contents
-		checkTitle();
-		
-		// QT call to see if we are at the end - can't do with controller
-		if ( IsMovieDone( mMovieHandle ) )
-		{
-			// special code for looping - need to rewind at the end of the movie
-			if ( mIsLooping )
-			{
-				// go back to start
-				rewind();
-
-				if ( mMovieController )
-				{
-					// kick off new play
-					MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)getPlayRate() );
-
-					// set the volume
-					MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
-				};
-			}
-			else
-			{
-				if(mStatus == STATUS_PLAYING)
-				{
-					setStatus(STATUS_DONE);
-				}
-			}
-		}
-
-	};
-    
-	void seek( F64 time )
-	{
-		if ( mMovieController )
-		{
-			TimeRecord when;
-			when.scale = GetMovieTimeScale( mMovieHandle );
-			when.base = 0;
-
-			// 'time' is in (floating point) seconds.  The timebase time will be in 'units', where
-			// there are 'scale' units per second.
-			SInt64 raw_time = ( SInt64 )( time * (double)( when.scale ) );
-
-			when.value.hi = ( SInt32 )( raw_time >> 32 );
-			when.value.lo = ( SInt32 )( ( raw_time & 0x00000000FFFFFFFF ) );
-
-			MCDoAction( mMovieController, mcActionGoToTime, &when );
-		};
-	};
-
-	F64 getLoadedDuration() 	  	 
-	{ 	  	 
-		TimeValue duration; 	  	 
-		if(GetMaxLoadedTimeInMovie( mMovieHandle, &duration ) != noErr) 	  	 
-		{ 	  	 
-			// If GetMaxLoadedTimeInMovie returns an error, return the full duration of the movie. 	  	 
-			duration = GetMovieDuration( mMovieHandle ); 	  	 
-		} 	  	 
-		TimeValue scale = GetMovieTimeScale( mMovieHandle ); 	  	 
-
-		return (F64)duration / (F64)scale; 	  	 
-	}; 	  	 
-
-	F64 getDuration()
-	{
-		TimeValue duration = GetMovieDuration( mMovieHandle );
-		TimeValue scale = GetMovieTimeScale( mMovieHandle );
-
-		return (F64)duration / (F64)scale;
-	};
-
-	F64 getCurrentTime()
-	{
-		TimeValue curr_time = GetMovieTime( mMovieHandle, 0 );
-		TimeValue scale = GetMovieTimeScale( mMovieHandle );
-
-		return (F64)curr_time / (F64)scale;
-	};
-
-	void setVolume( F64 volume )
-	{
-		mCurVolume = (short)(volume * ( double ) 0x100 );
-
-		if ( mMovieController )
-		{
-			MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
-		};
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	//
-	void update(int milliseconds = 0)
-	{
-		updateQuickTime(milliseconds);
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	//
-	void mouseDown( int x, int y )
-	{
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	//
-	void mouseUp( int x, int y )
-	{
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	//
-	void mouseMove( int x, int y )
-	{
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	//
-	void keyPress( unsigned char key )
-	{
-	};
-
-	////////////////////////////////////////////////////////////////////////////////
-	// Grab movie title into mMovieTitle - should be called repeatedly
-	// until it returns true since movie title takes a while to become 
-	// available.
-	const bool getMovieTitle()
-	{
-		// grab meta data from movie
-		QTMetaDataRef media_data_ref;
-		OSErr result = QTCopyMovieMetaData( mMovieHandle, &media_data_ref );
-		if ( noErr != result ) 
-			return false;
-
-		// look up "Display Name" in meta data
-		OSType meta_data_key = kQTMetaDataCommonKeyDisplayName;
-		QTMetaDataItem item = kQTMetaDataItemUninitialized;
-		result = (OSErr)QTMetaDataGetNextItem( media_data_ref, kQTMetaDataStorageFormatWildcard, 
-										0, kQTMetaDataKeyFormatCommon, 
-										(const UInt8 *)&meta_data_key, 
-										sizeof( meta_data_key ), &item );
-		if ( noErr != result ) 
-			return false;
-
-		// find the size of the title
-		ByteCount size;
-		result = (OSErr)QTMetaDataGetItemValue( media_data_ref, item, NULL, 0, &size );
-		if ( noErr != result || size <= 0 /*|| size > 1024  FIXME: arbitrary limit */ ) 
-			return false;
-
-		// allocate some space and grab it
-		UInt8* item_data = new UInt8[ size + 1 ];
-		memset( item_data, 0, ( size + 1 ) * sizeof( UInt8 ) );
-		result = (OSErr)QTMetaDataGetItemValue( media_data_ref, item, item_data, size, NULL );
-		if ( noErr != result ) 
-		{
-			delete [] item_data;
-			return false;
-		};
-
-		// save it
-		if ( strlen( (char*)item_data ) )
-			mMovieTitle = std::string( (char* )item_data );
-		else
-			mMovieTitle = "";
-
-		// clean up
-		delete [] item_data;
-
-		return true;
-	};
-
-	// called regularly to see if title changed
-	void checkTitle()
-	{
-		// we did already receive title so keep checking
-		if ( ! mReceivedTitle )
-		{
-			// grab title from movie meta data
-			if ( getMovieTitle() )
-			{
-				// pass back to host application
-				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
-				message.setValue("name", mMovieTitle );
-				sendMessage( message );
-
-				// stop looking once we find a title for this movie.
-				// TODO: this may to be reset if movie title changes
-				// during playback but this is okay for now
-				mReceivedTitle = true;
-			};
-		};
-	};
-};
-
-MediaPluginQuickTime::MediaPluginQuickTime(
-	LLPluginInstance::sendMessageFunction host_send_func,
-	void *host_user_data ) :
-	MediaPluginBase(host_send_func, host_user_data),
-	mMinWidth( 0 ),
-	mMaxWidth( 2048 ),
-	mMinHeight( 0 ),
-	mMaxHeight( 2048 )
-{
-//	std::cerr << "MediaPluginQuickTime constructor" << std::endl;
-
-	mNaturalWidth = -1;
-	mNaturalHeight = -1;
-	mMovieHandle = 0;
-	mGWorldHandle = 0;
-	mMovieController = 0;
-	mCurVolume = 0x99;
-	mMediaSizeChanging = false;
-	mIsLooping = false;
-	mMovieTitle = std::string();
-	mReceivedTitle = false;
-	mCommand = COMMAND_NONE;
-	mPlayRate = 0.0f;
-	mStatus = STATUS_NONE;
-}
-
-MediaPluginQuickTime::~MediaPluginQuickTime()
-{
-//	std::cerr << "MediaPluginQuickTime destructor" << std::endl;
-
-	ExitMovies();
-
-#ifdef LL_WINDOWS
-	TerminateQTML();
-//		std::cerr << "QuickTime closing down" << std::endl;
-#endif
-}
-
-
-void MediaPluginQuickTime::receiveMessage(const char *message_string)
-{
-//	std::cerr << "MediaPluginQuickTime::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_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
-				message.setValueLLSD("versions", versions);
-
-				#ifdef LL_WINDOWS
-
-				// QuickTime 7.6.4 has an issue (that was not present in 7.6.2) with initializing QuickTime
-				// according to this article: http://lists.apple.com/archives/QuickTime-API/2009/Sep/msg00097.html
-				// The solution presented there appears to work.
-				QTLoadLibrary("qtcf.dll");
-
-				// main initialization for QuickTime - only required on Windows
-				OSErr result = InitializeQTML( 0L );
-				if ( result != noErr )
-				{
-					//TODO: If no QT on Windows, this fails - respond accordingly.
-				}
-				else
-				{
-					//std::cerr << "QuickTime initialized" << std::endl;
-				};
-				#endif
-
-				// required for both Windows and Mac
-				EnterMovies();
-
-				std::string plugin_version = "QuickTime media plugin, QuickTime version ";
-
-				long version = 0;
-				Gestalt( gestaltQuickTimeVersion, &version );
-				std::ostringstream codec( "" );
-				codec << std::hex << version << std::dec;
-				plugin_version += codec.str();
-				message.setValue("plugin_version", plugin_version);
-				sendMessage(message);
-			}
-			else if(message_name == "idle")
-			{
-				// no response is necessary here.
-				F64 time = message_in.getValueReal("time");
-
-				// Convert time to milliseconds for update()
-				update((int)(time * 1000.0f));
-			}
-			else if(message_name == "cleanup")
-			{
-				// TODO: clean up here
-			}
-			else if(message_name == "shm_added")
-			{
-				SharedSegmentInfo info;
-				info.mAddress = message_in.getValuePointer("address");
-				info.mSize = (size_t)message_in.getValueS32("size");
-				std::string name = message_in.getValue("name");
-//				std::cerr << "MediaPluginQuickTime::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 << "MediaPluginQuickTime::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;
-						mTextureSegmentName.clear();
-
-						// Make sure the movie GWorld is no longer pointed at the shared segment.
-						sizeChanged();
-					}
-					mSharedSegments.erase(iter);
-				}
-				else
-				{
-//					std::cerr << "MediaPluginQuickTime::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 << "MediaPluginQuickTime::receiveMessage: unknown base message: " << message_name << std::endl;
-			}
-		}
-		else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
-		{
-			if(message_name == "init")
-			{
-				// This is the media init message -- all necessary data for initialization should have been received.
-
-				// Plugin gets to decide the texture parameters to use.
-				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
-				#if defined(LL_WINDOWS)
-					// Values for Windows
-					mDepth = 3;
-					message.setValueU32("format", GL_RGB);
-					message.setValueU32("type", GL_UNSIGNED_BYTE);
-
-					// We really want to pad the texture width to a multiple of 32 bytes, but since we're using 3-byte pixels, it doesn't come out even.
-					// Padding to a multiple of 3*32 guarantees it'll divide out properly.
-					message.setValueU32("padding", 32 * 3);
-				#else
-					// Values for Mac
-					mDepth = 4;
-					message.setValueU32("format", GL_BGRA_EXT);
-					#ifdef __BIG_ENDIAN__
-						message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8_REV );
-					#else
-						message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8);
-					#endif
-
-					// Pad texture width to a multiple of 32 bytes, to line up with cache lines.
-					message.setValueU32("padding", 32);
-				#endif
-				message.setValueS32("depth", mDepth);
-				message.setValueU32("internalformat", GL_RGB);
-
-                // note this apparently only has an effect when media is opened in 2D browser. 
-                // see https://jira.secondlife.com/browse/BUG-18252 - media flipped in 2D so flipping it back.
-				message.setValueBoolean("coords_opengl", true);	// true == use OpenGL-style coordinates, false == (0,0) is upper left.
-				message.setValueBoolean("allow_downsample", true);
-				sendMessage(message);
-			}
-			else if(message_name == "size_change")
-			{
-				std::string name = message_in.getValue("name");
-				S32 width = message_in.getValueS32("width");
-				S32 height = message_in.getValueS32("height");
-				S32 texture_width = message_in.getValueS32("texture_width");
-				S32 texture_height = message_in.getValueS32("texture_height");
-
-				//std::cerr << "---->Got size change instruction from application with name: " << name << " - size is " << width << " x " << height << std::endl;
-
-				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;
-						mTextureSegmentName = name;
-						mWidth = width;
-						mHeight = height;
-
-						mTextureWidth = texture_width;
-						mTextureHeight = texture_height;
-
-						mMediaSizeChanging = false;
-
-						sizeChanged();
-
-						update();
-					};
-				};
-			}
-			else if(message_name == "load_uri")
-			{
-				std::string uri = message_in.getValue("uri");
-				load( uri );
-				sendStatus();
-			}
-			else if(message_name == "mouse_event")
-			{
-				std::string event = message_in.getValue("event");
-				S32 x = message_in.getValueS32("x");
-				S32 y = message_in.getValueS32("y");
-
-				if(event == "down")
-				{
-					mouseDown(x, y);
-				}
-				else if(event == "up")
-				{
-					mouseUp(x, y);
-				}
-				else if(event == "move")
-				{
-					mouseMove(x, y);
-				};
-			};
-		}
-		else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
-		{
-			if(message_name == "stop")
-			{
-				stop();
-			}
-			else if(message_name == "start")
-			{
-				F64 rate = 0.0;
-				if(message_in.hasValue("rate"))
-				{
-					rate = message_in.getValueReal("rate");
-				}
-				play(rate);
-			}
-			else if(message_name == "pause")
-			{
-				pause();
-			}
-			else if(message_name == "seek")
-			{
-				F64 time = message_in.getValueReal("time");
-				seek(time);
-			}
-			else if(message_name == "set_loop")
-			{
-				bool loop = message_in.getValueBoolean("loop");
-				mIsLooping = loop;
-			}
-			else if(message_name == "set_volume")
-			{
-				F64 volume = message_in.getValueReal("volume");
-				setVolume(volume);
-			}
-		}
-		else
-		{
-//			std::cerr << "MediaPluginQuickTime::receiveMessage: unknown message class: " << message_class << std::endl;
-		};
-	};
-}
-
-int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
-{
-	MediaPluginQuickTime *self = new MediaPluginQuickTime(host_send_func, host_user_data);
-	*plugin_send_func = MediaPluginQuickTime::staticReceiveMessage;
-	*plugin_user_data = (void*)self;
-
-	return 0;
-}
-
-#else // LL_QUICKTIME_ENABLED
-
-// Stubbed-out class with constructor/destructor (necessary or windows linker
-// will just think its dead code and optimize it all out)
-class MediaPluginQuickTime : public MediaPluginBase
-{
-public:
-	MediaPluginQuickTime(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
-	~MediaPluginQuickTime();
-	/* virtual */ void receiveMessage(const char *message_string);
-};
-
-MediaPluginQuickTime::MediaPluginQuickTime(
-	LLPluginInstance::sendMessageFunction host_send_func,
-	void *host_user_data ) :
-	MediaPluginBase(host_send_func, host_user_data)
-{
-    // no-op
-}
-
-MediaPluginQuickTime::~MediaPluginQuickTime()
-{
-    // no-op
-}
-
-void MediaPluginQuickTime::receiveMessage(const char *message_string)
-{
-    // no-op
-}
-
-// We're building without quicktime enabled.  Just refuse to initialize.
-int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
-{
-    return -1;
-}
-
-#endif // LL_QUICKTIME_ENABLED
diff --git a/indra/media_plugins/winmmshim/CMakeLists.txt b/indra/media_plugins/winmmshim/CMakeLists.txt
deleted file mode 100644
index 6890589892..0000000000
--- a/indra/media_plugins/winmmshim/CMakeLists.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-# -*- cmake -*-
-
-project(winmm_shim)
-
-### winmm_shim
-# *HACK - override msvcrt implementation (intialized on 00-Common) to be
-# statically linked for winmm.dll this relies on vc taking the last flag on
-# the command line
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MT")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
-
-set(winmm_shim_SOURCE_FILES
-    forwarding_api.cpp
-    winmm_shim.cpp
-    )
-
-set(winmm_shim_HEADER_FILES
-    forwarding_api.h
-    winmm.def
-    )
-
-list(APPEND winmm_shim_SOURCE_FILES ${winmm_shim_HEADER_FILES})
-
-add_library(winmm_shim
-    SHARED
-    ${winmm_shim_SOURCE_FILES}
-)
-
-if (WINDOWS)
-  set_target_properties(
-    winmm_shim
-    PROPERTIES
-    LINK_FLAGS "/MANIFEST:NO"
-    OUTPUT_NAME "winmm"
-    )
-endif (WINDOWS)
diff --git a/indra/media_plugins/winmmshim/forwarding_api.cpp b/indra/media_plugins/winmmshim/forwarding_api.cpp
deleted file mode 100644
index 33f0675028..0000000000
--- a/indra/media_plugins/winmmshim/forwarding_api.cpp
+++ /dev/null
@@ -1,1627 +0,0 @@
-/** 
- * @file forwarding_api.cpp
- * @brief forwards winmm API calls to real winmm.dll
- *
- * $LicenseInfo:firstyear=2010&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "forwarding_api.h"
-
-CloseDriver_type CloseDriver_orig;
-OpenDriver_type OpenDriver_orig;
-SendDriverMessage_type SendDriverMessage_orig;
-DrvGetModuleHandle_type DrvGetModuleHandle_orig;
-GetDriverModuleHandle_type GetDriverModuleHandle_orig;
-DefDriverProc_type DefDriverProc_orig;
-DriverCallback_type DriverCallback_orig;
-mmsystemGetVersion_type mmsystemGetVersion_orig;
-sndPlaySoundA_type sndPlaySoundA_orig;
-sndPlaySoundW_type sndPlaySoundW_orig;
-PlaySoundA_type PlaySoundA_orig;
-PlaySoundW_type PlaySoundW_orig;
-waveOutGetNumDevs_type waveOutGetNumDevs_orig;
-waveOutGetDevCapsA_type waveOutGetDevCapsA_orig;
-waveOutGetDevCapsW_type waveOutGetDevCapsW_orig;
-waveOutGetVolume_type waveOutGetVolume_orig;
-waveOutSetVolume_type waveOutSetVolume_orig;
-waveOutGetErrorTextA_type waveOutGetErrorTextA_orig;
-waveOutGetErrorTextW_type waveOutGetErrorTextW_orig;
-waveOutOpen_type waveOutOpen_orig;
-waveOutClose_type waveOutClose_orig;
-waveOutPrepareHeader_type waveOutPrepareHeader_orig;
-waveOutUnprepareHeader_type waveOutUnprepareHeader_orig;
-waveOutWrite_type waveOutWrite_orig;
-waveOutPause_type waveOutPause_orig;
-waveOutRestart_type waveOutRestart_orig;
-waveOutReset_type waveOutReset_orig;
-waveOutBreakLoop_type waveOutBreakLoop_orig;
-waveOutGetPosition_type waveOutGetPosition_orig;
-waveOutGetPitch_type waveOutGetPitch_orig;
-waveOutSetPitch_type waveOutSetPitch_orig;
-waveOutGetPlaybackRate_type waveOutGetPlaybackRate_orig;
-waveOutSetPlaybackRate_type waveOutSetPlaybackRate_orig;
-waveOutGetID_type waveOutGetID_orig;
-waveOutMessage_type waveOutMessage_orig;
-waveInGetNumDevs_type waveInGetNumDevs_orig;
-waveInGetDevCapsA_type waveInGetDevCapsA_orig;
-waveInGetDevCapsW_type waveInGetDevCapsW_orig;
-waveInGetErrorTextA_type waveInGetErrorTextA_orig;
-waveInGetErrorTextW_type waveInGetErrorTextW_orig;
-waveInOpen_type waveInOpen_orig;
-waveInClose_type waveInClose_orig;
-waveInPrepareHeader_type waveInPrepareHeader_orig;
-waveInUnprepareHeader_type waveInUnprepareHeader_orig;
-waveInAddBuffer_type waveInAddBuffer_orig;
-waveInStart_type waveInStart_orig;
-waveInStop_type waveInStop_orig;
-waveInReset_type waveInReset_orig;
-waveInGetPosition_type waveInGetPosition_orig;
-waveInGetID_type waveInGetID_orig;
-waveInMessage_type waveInMessage_orig;
-midiOutGetNumDevs_type midiOutGetNumDevs_orig;
-midiStreamOpen_type midiStreamOpen_orig;
-midiStreamClose_type midiStreamClose_orig;
-midiStreamProperty_type midiStreamProperty_orig;
-midiStreamPosition_type midiStreamPosition_orig;
-midiStreamOut_type midiStreamOut_orig;
-midiStreamPause_type midiStreamPause_orig;
-midiStreamRestart_type midiStreamRestart_orig;
-midiStreamStop_type midiStreamStop_orig;
-midiConnect_type midiConnect_orig;
-midiDisconnect_type midiDisconnect_orig;
-midiOutGetDevCapsA_type midiOutGetDevCapsA_orig;
-midiOutGetDevCapsW_type midiOutGetDevCapsW_orig;
-midiOutGetVolume_type midiOutGetVolume_orig;
-midiOutSetVolume_type midiOutSetVolume_orig;
-midiOutGetErrorTextA_type midiOutGetErrorTextA_orig;
-midiOutGetErrorTextW_type midiOutGetErrorTextW_orig;
-midiOutOpen_type midiOutOpen_orig;
-midiOutClose_type midiOutClose_orig;
-midiOutPrepareHeader_type midiOutPrepareHeader_orig;
-midiOutUnprepareHeader_type midiOutUnprepareHeader_orig;
-midiOutShortMsg_type midiOutShortMsg_orig;
-midiOutLongMsg_type midiOutLongMsg_orig;
-midiOutReset_type midiOutReset_orig;
-midiOutCachePatches_type midiOutCachePatches_orig;
-midiOutCacheDrumPatches_type midiOutCacheDrumPatches_orig;
-midiOutGetID_type midiOutGetID_orig;
-midiOutMessage_type midiOutMessage_orig;
-midiInGetNumDevs_type midiInGetNumDevs_orig;
-midiInGetDevCapsA_type midiInGetDevCapsA_orig;
-midiInGetDevCapsW_type midiInGetDevCapsW_orig;
-midiInGetErrorTextA_type midiInGetErrorTextA_orig;
-midiInGetErrorTextW_type midiInGetErrorTextW_orig;
-midiInOpen_type midiInOpen_orig;
-midiInClose_type midiInClose_orig;
-midiInPrepareHeader_type midiInPrepareHeader_orig;
-midiInUnprepareHeader_type midiInUnprepareHeader_orig;
-midiInAddBuffer_type midiInAddBuffer_orig;
-midiInStart_type midiInStart_orig;
-midiInStop_type midiInStop_orig;
-midiInReset_type midiInReset_orig;
-midiInGetID_type midiInGetID_orig;
-midiInMessage_type midiInMessage_orig;
-auxGetNumDevs_type auxGetNumDevs_orig;
-auxGetDevCapsA_type auxGetDevCapsA_orig;
-auxGetDevCapsW_type auxGetDevCapsW_orig;
-auxSetVolume_type auxSetVolume_orig;
-auxGetVolume_type auxGetVolume_orig;
-auxOutMessage_type auxOutMessage_orig;
-mixerGetNumDevs_type mixerGetNumDevs_orig;
-mixerGetDevCapsA_type mixerGetDevCapsA_orig;
-mixerGetDevCapsW_type mixerGetDevCapsW_orig;
-mixerOpen_type mixerOpen_orig;
-mixerClose_type mixerClose_orig;
-mixerMessage_type mixerMessage_orig;
-mixerGetLineInfoA_type mixerGetLineInfoA_orig;
-mixerGetLineInfoW_type mixerGetLineInfoW_orig;
-mixerGetID_type mixerGetID_orig;
-mixerGetLineControlsA_type mixerGetLineControlsA_orig;
-mixerGetLineControlsW_type mixerGetLineControlsW_orig;
-mixerGetControlDetailsA_type mixerGetControlDetailsA_orig;
-mixerGetControlDetailsW_type mixerGetControlDetailsW_orig;
-mixerSetControlDetails_type mixerSetControlDetails_orig;
-mmGetCurrentTask_type mmGetCurrentTask_orig;
-mmTaskBlock_type mmTaskBlock_orig;
-mmTaskCreate_type mmTaskCreate_orig;
-mmTaskSignal_type mmTaskSignal_orig;
-mmTaskYield_type mmTaskYield_orig;
-timeGetSystemTime_type timeGetSystemTime_orig;
-timeGetTime_type timeGetTime_orig;
-timeSetEvent_type timeSetEvent_orig;
-timeKillEvent_type timeKillEvent_orig;
-timeGetDevCaps_type timeGetDevCaps_orig;
-timeBeginPeriod_type timeBeginPeriod_orig;
-timeEndPeriod_type timeEndPeriod_orig;
-joyGetNumDevs_type joyGetNumDevs_orig;
-joyConfigChanged_type joyConfigChanged_orig;
-joyGetDevCapsA_type joyGetDevCapsA_orig;
-joyGetDevCapsW_type joyGetDevCapsW_orig;
-joyGetPos_type joyGetPos_orig;
-joyGetPosEx_type joyGetPosEx_orig;
-joyGetThreshold_type joyGetThreshold_orig;
-joyReleaseCapture_type joyReleaseCapture_orig;
-joySetCapture_type joySetCapture_orig;
-joySetThreshold_type joySetThreshold_orig;
-mmioStringToFOURCCA_type mmioStringToFOURCCA_orig;
-mmioStringToFOURCCW_type mmioStringToFOURCCW_orig;
-mmioInstallIOProcA_type mmioInstallIOProcA_orig;
-mmioInstallIOProcW_type mmioInstallIOProcW_orig;
-mmioOpenA_type mmioOpenA_orig;
-mmioOpenW_type mmioOpenW_orig;
-mmioRenameA_type mmioRenameA_orig;
-mmioRenameW_type mmioRenameW_orig;
-mmioClose_type mmioClose_orig;
-mmioRead_type mmioRead_orig;
-mmioWrite_type mmioWrite_orig;
-mmioSeek_type mmioSeek_orig;
-mmioGetInfo_type mmioGetInfo_orig;
-mmioSetInfo_type mmioSetInfo_orig;
-mmioSetBuffer_type mmioSetBuffer_orig;
-mmioFlush_type mmioFlush_orig;
-mmioAdvance_type mmioAdvance_orig;
-mmioSendMessage_type mmioSendMessage_orig;
-mmioDescend_type mmioDescend_orig;
-mmioAscend_type mmioAscend_orig;
-mmioCreateChunk_type mmioCreateChunk_orig;
-mciSendCommandA_type mciSendCommandA_orig;
-mciSendCommandW_type mciSendCommandW_orig;
-mciSendStringA_type mciSendStringA_orig;
-mciSendStringW_type mciSendStringW_orig;
-mciGetDeviceIDA_type mciGetDeviceIDA_orig;
-mciGetDeviceIDW_type mciGetDeviceIDW_orig;
-mciGetDeviceIDFromElementIDA_type mciGetDeviceIDFromElementIDA_orig;
-mciGetDeviceIDFromElementIDW_type mciGetDeviceIDFromElementIDW_orig;
-mciGetDriverData_type mciGetDriverData_orig;
-mciGetErrorStringA_type mciGetErrorStringA_orig;
-mciGetErrorStringW_type mciGetErrorStringW_orig;
-mciSetDriverData_type mciSetDriverData_orig;
-mciDriverNotify_type mciDriverNotify_orig;
-mciDriverYield_type mciDriverYield_orig;
-mciSetYieldProc_type mciSetYieldProc_orig;
-mciFreeCommandResource_type mciFreeCommandResource_orig;
-mciGetCreatorTask_type mciGetCreatorTask_orig;
-mciGetYieldProc_type mciGetYieldProc_orig;
-mciLoadCommandResource_type mciLoadCommandResource_orig;
-mciExecute_type mciExecute_orig;
-
-// grab pointers to function calls in the real DLL
-void init_function_pointers(HMODULE winmm_handle)
-{	
-	CloseDriver_orig = (CloseDriver_type)::GetProcAddress(winmm_handle, "CloseDriver");
-	OpenDriver_orig = (OpenDriver_type)::GetProcAddress(winmm_handle, "OpenDriver");
-	SendDriverMessage_orig = (SendDriverMessage_type)::GetProcAddress(winmm_handle, "SendDriverMessage");
-	DrvGetModuleHandle_orig = (DrvGetModuleHandle_type)::GetProcAddress(winmm_handle, "DrvGetModuleHandle");
-	GetDriverModuleHandle_orig = (GetDriverModuleHandle_type)::GetProcAddress(winmm_handle, "GetDriverModuleHandle");
-	DefDriverProc_orig = (DefDriverProc_type)::GetProcAddress(winmm_handle, "DefDriverProc");
-	DriverCallback_orig = (DriverCallback_type)::GetProcAddress(winmm_handle, "DriverCallback");
-	mmsystemGetVersion_orig = (mmsystemGetVersion_type)::GetProcAddress(winmm_handle, "mmsystemGetVersion");
-	sndPlaySoundA_orig = (sndPlaySoundA_type)::GetProcAddress(winmm_handle, "sndPlaySoundA");
-	sndPlaySoundW_orig = (sndPlaySoundW_type)::GetProcAddress(winmm_handle, "sndPlaySoundW");
-	PlaySoundA_orig = (PlaySoundA_type)::GetProcAddress(winmm_handle, "PlaySoundA");
-	PlaySoundW_orig = (PlaySoundW_type)::GetProcAddress(winmm_handle, "PlaySoundW");
-	waveOutGetNumDevs_orig = (waveOutGetNumDevs_type)::GetProcAddress(winmm_handle, "waveOutGetNumDevs");
-	waveOutGetDevCapsA_orig = (waveOutGetDevCapsA_type)::GetProcAddress(winmm_handle, "waveOutGetDevCapsA");
-	waveOutGetDevCapsW_orig = (waveOutGetDevCapsW_type)::GetProcAddress(winmm_handle, "waveOutGetDevCapsW");
-	waveOutGetVolume_orig = (waveOutGetVolume_type)::GetProcAddress(winmm_handle, "waveOutGetVolume");
-	waveOutSetVolume_orig = (waveOutSetVolume_type)::GetProcAddress(winmm_handle, "waveOutSetVolume");
-	waveOutGetErrorTextA_orig = (waveOutGetErrorTextA_type)::GetProcAddress(winmm_handle, "waveOutGetErrorTextA");
-	waveOutGetErrorTextW_orig = (waveOutGetErrorTextW_type)::GetProcAddress(winmm_handle, "waveOutGetErrorTextW");
-	waveOutOpen_orig = (waveOutOpen_type)::GetProcAddress(winmm_handle, "waveOutOpen");
-	waveOutClose_orig = (waveOutClose_type)::GetProcAddress(winmm_handle, "waveOutClose");
-	waveOutPrepareHeader_orig = (waveOutPrepareHeader_type)::GetProcAddress(winmm_handle, "waveOutPrepareHeader");
-	waveOutUnprepareHeader_orig = (waveOutUnprepareHeader_type)::GetProcAddress(winmm_handle, "waveOutUnprepareHeader");
-	waveOutWrite_orig = (waveOutWrite_type)::GetProcAddress(winmm_handle, "waveOutWrite");
-	waveOutPause_orig = (waveOutPause_type)::GetProcAddress(winmm_handle, "waveOutPause");
-	waveOutRestart_orig = (waveOutRestart_type)::GetProcAddress(winmm_handle, "waveOutRestart");
-	waveOutReset_orig = (waveOutReset_type)::GetProcAddress(winmm_handle, "waveOutReset");
-	waveOutBreakLoop_orig = (waveOutBreakLoop_type)::GetProcAddress(winmm_handle, "waveOutBreakLoop");
-	waveOutGetPosition_orig = (waveOutGetPosition_type)::GetProcAddress(winmm_handle, "waveOutGetPosition");
-	waveOutGetPitch_orig = (waveOutGetPitch_type)::GetProcAddress(winmm_handle, "waveOutGetPitch");
-	waveOutSetPitch_orig = (waveOutSetPitch_type)::GetProcAddress(winmm_handle, "waveOutSetPitch");
-	waveOutGetPlaybackRate_orig = (waveOutGetPlaybackRate_type)::GetProcAddress(winmm_handle, "waveOutGetPlaybackRate");
-	waveOutSetPlaybackRate_orig = (waveOutSetPlaybackRate_type)::GetProcAddress(winmm_handle, "waveOutSetPlaybackRate");
-	waveOutGetID_orig = (waveOutGetID_type)::GetProcAddress(winmm_handle, "waveOutGetID");
-	waveOutMessage_orig = (waveOutMessage_type)::GetProcAddress(winmm_handle, "waveOutMessage");
-	waveInGetNumDevs_orig = (waveInGetNumDevs_type)::GetProcAddress(winmm_handle, "waveInGetNumDevs");
-	waveInGetDevCapsA_orig = (waveInGetDevCapsA_type)::GetProcAddress(winmm_handle, "waveInGetDevCapsA");
-	waveInGetDevCapsW_orig = (waveInGetDevCapsW_type)::GetProcAddress(winmm_handle, "waveInGetDevCapsW");
-	waveInGetErrorTextA_orig = (waveInGetErrorTextA_type)::GetProcAddress(winmm_handle, "waveInGetErrorTextA");
-	waveInGetErrorTextW_orig = (waveInGetErrorTextW_type)::GetProcAddress(winmm_handle, "waveInGetErrorTextW");
-	waveInOpen_orig = (waveInOpen_type)::GetProcAddress(winmm_handle, "waveInOpen");
-	waveInClose_orig = (waveInClose_type)::GetProcAddress(winmm_handle, "waveInClose");
-	waveInPrepareHeader_orig = (waveInPrepareHeader_type)::GetProcAddress(winmm_handle, "waveInPrepareHeader");
-	waveInUnprepareHeader_orig = (waveInUnprepareHeader_type)::GetProcAddress(winmm_handle, "waveInUnprepareHeader");
-	waveInAddBuffer_orig = (waveInAddBuffer_type)::GetProcAddress(winmm_handle, "waveInAddBuffer");
-	waveInStart_orig = (waveInStart_type)::GetProcAddress(winmm_handle, "waveInStart");
-	waveInStop_orig = (waveInStop_type)::GetProcAddress(winmm_handle, "waveInStop");
-	waveInReset_orig = (waveInReset_type)::GetProcAddress(winmm_handle, "waveInReset");
-	waveInGetPosition_orig = (waveInGetPosition_type)::GetProcAddress(winmm_handle, "waveInGetPosition");
-	waveInGetID_orig = (waveInGetID_type)::GetProcAddress(winmm_handle, "waveInGetID");
-	waveInMessage_orig = (waveInMessage_type)::GetProcAddress(winmm_handle, "waveInMessage");
-	midiOutGetNumDevs_orig = (midiOutGetNumDevs_type)::GetProcAddress(winmm_handle, "midiOutGetNumDevs");
-	midiStreamOpen_orig = (midiStreamOpen_type)::GetProcAddress(winmm_handle, "midiStreamOpen");
-	midiStreamClose_orig = (midiStreamClose_type)::GetProcAddress(winmm_handle, "midiStreamClose");
-	midiStreamProperty_orig = (midiStreamProperty_type)::GetProcAddress(winmm_handle, "midiStreamProperty");
-	midiStreamPosition_orig = (midiStreamPosition_type)::GetProcAddress(winmm_handle, "midiStreamPosition");
-	midiStreamOut_orig = (midiStreamOut_type)::GetProcAddress(winmm_handle, "midiStreamOut");
-	midiStreamPause_orig = (midiStreamPause_type)::GetProcAddress(winmm_handle, "midiStreamPause");
-	midiStreamRestart_orig = (midiStreamRestart_type)::GetProcAddress(winmm_handle, "midiStreamRestart");
-	midiStreamStop_orig = (midiStreamStop_type)::GetProcAddress(winmm_handle, "midiStreamStop");
-	midiConnect_orig = (midiConnect_type)::GetProcAddress(winmm_handle, "midiConnect");
-	midiDisconnect_orig = (midiDisconnect_type)::GetProcAddress(winmm_handle, "midiDisconnect");
-	midiOutGetDevCapsA_orig = (midiOutGetDevCapsA_type)::GetProcAddress(winmm_handle, "midiOutGetDevCapsA");
-	midiOutGetDevCapsW_orig = (midiOutGetDevCapsW_type)::GetProcAddress(winmm_handle, "midiOutGetDevCapsW");
-	midiOutGetVolume_orig = (midiOutGetVolume_type)::GetProcAddress(winmm_handle, "midiOutGetVolume");
-	midiOutSetVolume_orig = (midiOutSetVolume_type)::GetProcAddress(winmm_handle, "midiOutSetVolume");
-	midiOutGetErrorTextA_orig = (midiOutGetErrorTextA_type)::GetProcAddress(winmm_handle, "midiOutGetErrorTextA");
-	midiOutGetErrorTextW_orig = (midiOutGetErrorTextW_type)::GetProcAddress(winmm_handle, "midiOutGetErrorTextW");
-	midiOutOpen_orig = (midiOutOpen_type)::GetProcAddress(winmm_handle, "midiOutOpen");
-	midiOutClose_orig = (midiOutClose_type)::GetProcAddress(winmm_handle, "midiOutClose");
-	midiOutPrepareHeader_orig = (midiOutPrepareHeader_type)::GetProcAddress(winmm_handle, "midiOutPrepareHeader");
-	midiOutUnprepareHeader_orig = (midiOutUnprepareHeader_type)::GetProcAddress(winmm_handle, "midiOutUnprepareHeader");
-	midiOutShortMsg_orig = (midiOutShortMsg_type)::GetProcAddress(winmm_handle, "midiOutShortMsg");
-	midiOutLongMsg_orig = (midiOutLongMsg_type)::GetProcAddress(winmm_handle, "midiOutLongMsg");
-	midiOutReset_orig = (midiOutReset_type)::GetProcAddress(winmm_handle, "midiOutReset");
-	midiOutCachePatches_orig = (midiOutCachePatches_type)::GetProcAddress(winmm_handle, "midiOutCachePatches");
-	midiOutCacheDrumPatches_orig = (midiOutCacheDrumPatches_type)::GetProcAddress(winmm_handle, "midiOutCacheDrumPatches");
-	midiOutGetID_orig = (midiOutGetID_type)::GetProcAddress(winmm_handle, "midiOutGetID");
-	midiOutMessage_orig = (midiOutMessage_type)::GetProcAddress(winmm_handle, "midiOutMessage");
-	midiInGetNumDevs_orig = (midiInGetNumDevs_type)::GetProcAddress(winmm_handle, "midiInGetNumDevs");
-	midiInGetDevCapsA_orig = (midiInGetDevCapsA_type)::GetProcAddress(winmm_handle, "midiInGetDevCapsA");
-	midiInGetDevCapsW_orig = (midiInGetDevCapsW_type)::GetProcAddress(winmm_handle, "midiInGetDevCapsW");
-	midiInGetErrorTextA_orig = (midiInGetErrorTextA_type)::GetProcAddress(winmm_handle, "midiInGetErrorTextA");
-	midiInGetErrorTextW_orig = (midiInGetErrorTextW_type)::GetProcAddress(winmm_handle, "midiInGetErrorTextW");
-	midiInOpen_orig = (midiInOpen_type)::GetProcAddress(winmm_handle, "midiInOpen");
-	midiInClose_orig = (midiInClose_type)::GetProcAddress(winmm_handle, "midiInClose");
-	midiInPrepareHeader_orig = (midiInPrepareHeader_type)::GetProcAddress(winmm_handle, "midiInPrepareHeader");
-	midiInUnprepareHeader_orig = (midiInUnprepareHeader_type)::GetProcAddress(winmm_handle, "midiInUnprepareHeader");
-	midiInAddBuffer_orig = (midiInAddBuffer_type)::GetProcAddress(winmm_handle, "midiInAddBuffer");
-	midiInStart_orig = (midiInStart_type)::GetProcAddress(winmm_handle, "midiInStart");
-	midiInStop_orig = (midiInStop_type)::GetProcAddress(winmm_handle, "midiInStop");
-	midiInReset_orig = (midiInReset_type)::GetProcAddress(winmm_handle, "midiInReset");
-	midiInGetID_orig = (midiInGetID_type)::GetProcAddress(winmm_handle, "midiInGetID");
-	midiInMessage_orig = (midiInMessage_type)::GetProcAddress(winmm_handle, "midiInMessage");
-	auxGetNumDevs_orig = (auxGetNumDevs_type)::GetProcAddress(winmm_handle, "auxGetNumDevs");
-	auxGetDevCapsA_orig = (auxGetDevCapsA_type)::GetProcAddress(winmm_handle, "auxGetDevCapsA");
-	auxGetDevCapsW_orig = (auxGetDevCapsW_type)::GetProcAddress(winmm_handle, "auxGetDevCapsW");
-	auxSetVolume_orig = (auxSetVolume_type)::GetProcAddress(winmm_handle, "auxSetVolume");
-	auxGetVolume_orig = (auxGetVolume_type)::GetProcAddress(winmm_handle, "auxGetVolume");
-	auxOutMessage_orig = (auxOutMessage_type)::GetProcAddress(winmm_handle, "auxOutMessage");
-	mixerGetNumDevs_orig = (mixerGetNumDevs_type)::GetProcAddress(winmm_handle, "mixerGetNumDevs");
-	mixerGetDevCapsA_orig = (mixerGetDevCapsA_type)::GetProcAddress(winmm_handle, "mixerGetDevCapsA");
-	mixerGetDevCapsW_orig = (mixerGetDevCapsW_type)::GetProcAddress(winmm_handle, "mixerGetDevCapsW");
-	mixerOpen_orig = (mixerOpen_type)::GetProcAddress(winmm_handle, "mixerOpen");
-	mixerClose_orig = (mixerClose_type)::GetProcAddress(winmm_handle, "mixerClose");
-	mixerMessage_orig = (mixerMessage_type)::GetProcAddress(winmm_handle, "mixerMessage");
-	mixerGetLineInfoA_orig = (mixerGetLineInfoA_type)::GetProcAddress(winmm_handle, "mixerGetLineInfoA");
-	mixerGetLineInfoW_orig = (mixerGetLineInfoW_type)::GetProcAddress(winmm_handle, "mixerGetLineInfoW");
-	mixerGetID_orig = (mixerGetID_type)::GetProcAddress(winmm_handle, "mixerGetID");
-	mixerGetLineControlsA_orig = (mixerGetLineControlsA_type)::GetProcAddress(winmm_handle, "mixerGetLineControlsA");
-	mixerGetLineControlsW_orig = (mixerGetLineControlsW_type)::GetProcAddress(winmm_handle, "mixerGetLineControlsW");
-	mixerGetControlDetailsA_orig = (mixerGetControlDetailsA_type)::GetProcAddress(winmm_handle, "mixerGetControlDetailsA");
-	mixerGetControlDetailsW_orig = (mixerGetControlDetailsW_type)::GetProcAddress(winmm_handle, "mixerGetControlDetailsW");
-	mixerSetControlDetails_orig = (mixerSetControlDetails_type)::GetProcAddress(winmm_handle, "mixerSetControlDetails");
-	mmGetCurrentTask_orig = (mmGetCurrentTask_type)::GetProcAddress(winmm_handle, "mmGetCurrentTask");
-	mmTaskBlock_orig = (mmTaskBlock_type)::GetProcAddress(winmm_handle, "mmTaskBlock");
-	mmTaskCreate_orig = (mmTaskCreate_type)::GetProcAddress(winmm_handle, "mmTaskCreate");
-	mmTaskSignal_orig = (mmTaskSignal_type)::GetProcAddress(winmm_handle, "mmTaskSignal");
-	mmTaskYield_orig = (mmTaskYield_type)::GetProcAddress(winmm_handle, "mmTaskYield");
-	timeGetSystemTime_orig = (timeGetSystemTime_type)::GetProcAddress(winmm_handle, "timeGetSystemTime");
-	timeGetTime_orig = (timeGetTime_type)::GetProcAddress(winmm_handle, "timeGetTime");
-	timeSetEvent_orig = (timeSetEvent_type)::GetProcAddress(winmm_handle, "timeSetEvent");
-	timeKillEvent_orig = (timeKillEvent_type)::GetProcAddress(winmm_handle, "timeKillEvent");
-	timeGetDevCaps_orig = (timeGetDevCaps_type)::GetProcAddress(winmm_handle, "timeGetDevCaps");
-	timeBeginPeriod_orig = (timeBeginPeriod_type)::GetProcAddress(winmm_handle, "timeBeginPeriod");
-	timeEndPeriod_orig = (timeEndPeriod_type)::GetProcAddress(winmm_handle, "timeEndPeriod");
-	joyGetNumDevs_orig = (joyGetNumDevs_type)::GetProcAddress(winmm_handle, "joyGetNumDevs");
-	joyConfigChanged_orig = (joyConfigChanged_type)::GetProcAddress(winmm_handle, "joyConfigChanged");
-	joyGetDevCapsA_orig = (joyGetDevCapsA_type)::GetProcAddress(winmm_handle, "joyGetDevCapsA");
-	joyGetDevCapsW_orig = (joyGetDevCapsW_type)::GetProcAddress(winmm_handle, "joyGetDevCapsW");
-	joyGetPos_orig = (joyGetPos_type)::GetProcAddress(winmm_handle, "joyGetPos");
-	joyGetPosEx_orig = (joyGetPosEx_type)::GetProcAddress(winmm_handle, "joyGetPosEx");
-	joyGetThreshold_orig = (joyGetThreshold_type)::GetProcAddress(winmm_handle, "joyGetThreshold");
-	joyReleaseCapture_orig = (joyReleaseCapture_type)::GetProcAddress(winmm_handle, "joyReleaseCapture");
-	joySetCapture_orig = (joySetCapture_type)::GetProcAddress(winmm_handle, "joySetCapture");
-	joySetThreshold_orig = (joySetThreshold_type)::GetProcAddress(winmm_handle, "joySetThreshold");
-	mciDriverNotify_orig = (mciDriverNotify_type)::GetProcAddress(winmm_handle, "mciDriverNotify");
-	mciDriverYield_orig = (mciDriverYield_type)::GetProcAddress(winmm_handle, "mciDriverYield");
-	mmioStringToFOURCCA_orig = (mmioStringToFOURCCA_type)::GetProcAddress(winmm_handle, "mmioStringToFOURCCA");
-	mmioStringToFOURCCW_orig = (mmioStringToFOURCCW_type)::GetProcAddress(winmm_handle, "mmioStringToFOURCCW");
-	mmioInstallIOProcA_orig = (mmioInstallIOProcA_type)::GetProcAddress(winmm_handle, "mmioInstallIOProcA");
-	mmioInstallIOProcW_orig = (mmioInstallIOProcW_type)::GetProcAddress(winmm_handle, "mmioInstallIOProcW");
-	mmioOpenA_orig = (mmioOpenA_type)::GetProcAddress(winmm_handle, "mmioOpenA");
-	mmioOpenW_orig = (mmioOpenW_type)::GetProcAddress(winmm_handle, "mmioOpenW");
-	mmioRenameA_orig = (mmioRenameA_type)::GetProcAddress(winmm_handle, "mmioRenameA");
-	mmioRenameW_orig = (mmioRenameW_type)::GetProcAddress(winmm_handle, "mmioRenameW");
-	mmioClose_orig = (mmioClose_type)::GetProcAddress(winmm_handle, "mmioClose");
-	mmioRead_orig = (mmioRead_type)::GetProcAddress(winmm_handle, "mmioRead");
-	mmioWrite_orig = (mmioWrite_type)::GetProcAddress(winmm_handle, "mmioWrite");
-	mmioSeek_orig = (mmioSeek_type)::GetProcAddress(winmm_handle, "mmioSeek");
-	mmioGetInfo_orig = (mmioGetInfo_type)::GetProcAddress(winmm_handle, "mmioGetInfo");
-	mmioSetInfo_orig = (mmioSetInfo_type)::GetProcAddress(winmm_handle, "mmioSetInfo");
-	mmioSetBuffer_orig = (mmioSetBuffer_type)::GetProcAddress(winmm_handle, "mmioSetBuffer");
-	mmioFlush_orig = (mmioFlush_type)::GetProcAddress(winmm_handle, "mmioFlush");
-	mmioAdvance_orig = (mmioAdvance_type)::GetProcAddress(winmm_handle, "mmioAdvance");
-	mmioSendMessage_orig = (mmioSendMessage_type)::GetProcAddress(winmm_handle, "mmioSendMessage");
-	mmioDescend_orig = (mmioDescend_type)::GetProcAddress(winmm_handle, "mmioDescend");
-	mmioAscend_orig = (mmioAscend_type)::GetProcAddress(winmm_handle, "mmioAscend");
-	mmioCreateChunk_orig = (mmioCreateChunk_type)::GetProcAddress(winmm_handle, "mmioCreateChunk");
-	mciSendCommandA_orig = (mciSendCommandA_type)::GetProcAddress(winmm_handle, "mciSendCommandA");
-	mciSendCommandW_orig = (mciSendCommandW_type)::GetProcAddress(winmm_handle, "mciSendCommandW");
-	mciSendStringA_orig = (mciSendStringA_type)::GetProcAddress(winmm_handle, "mciSendStringA");
-	mciSendStringW_orig = (mciSendStringW_type)::GetProcAddress(winmm_handle, "mciSendStringW");
-	mciGetDeviceIDA_orig = (mciGetDeviceIDA_type)::GetProcAddress(winmm_handle, "mciGetDeviceIDA");
-	mciGetDeviceIDW_orig = (mciGetDeviceIDW_type)::GetProcAddress(winmm_handle, "mciGetDeviceIDW");
-	mciGetDeviceIDFromElementIDA_orig = (mciGetDeviceIDFromElementIDA_type)::GetProcAddress(winmm_handle, "mciGetDeviceIDFromElementIDA");
-	mciGetDeviceIDFromElementIDW_orig = (mciGetDeviceIDFromElementIDW_type)::GetProcAddress(winmm_handle, "mciGetDeviceIDFromElementIDW");
-	mciGetDriverData_orig = (mciGetDriverData_type)::GetProcAddress(winmm_handle, "mciGetDriverData");
-	mciGetErrorStringA_orig = (mciGetErrorStringA_type)::GetProcAddress(winmm_handle, "mciGetErrorStringA");
-	mciGetErrorStringW_orig = (mciGetErrorStringW_type)::GetProcAddress(winmm_handle, "mciGetErrorStringW");
-	mciSetDriverData_orig = (mciSetDriverData_type)::GetProcAddress(winmm_handle, "mciSetDriverData");
-	mciSetYieldProc_orig = (mciSetYieldProc_type)::GetProcAddress(winmm_handle, "mciSetYieldProc");
-	mciFreeCommandResource_orig = (mciFreeCommandResource_type)::GetProcAddress(winmm_handle, "mciFreeCommandResource");
-	mciGetCreatorTask_orig = (mciGetCreatorTask_type)::GetProcAddress(winmm_handle, "mciGetCreatorTask");
-	mciGetYieldProc_orig = (mciGetYieldProc_type)::GetProcAddress(winmm_handle, "mciGetYieldProc");
-	mciLoadCommandResource_orig = (mciLoadCommandResource_type)::GetProcAddress(winmm_handle, "mciLoadCommandResource");
-	mciExecute_orig = (mciExecute_type)::GetProcAddress(winmm_handle, "mciExecute");
-}
-
-extern "C" {
-	LRESULT   WINAPI CloseDriver( HDRVR hDriver, LPARAM lParam1, LPARAM lParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"CloseDriver\n");
-		return CloseDriver_orig( hDriver, lParam1, lParam2);
-	}
-
-	HDRVR     WINAPI OpenDriver( LPCWSTR szDriverName, LPCWSTR szSectionName, LPARAM lParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"OpenDriver\n");
-		return OpenDriver_orig( szDriverName, szSectionName, lParam2);
-	}
-
-	LRESULT   WINAPI SendDriverMessage( HDRVR hDriver, UINT message, LPARAM lParam1, LPARAM lParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"SendDriverMessage\n");
-		return SendDriverMessage_orig( hDriver, message, lParam1, lParam2);
-	}
-
-	HMODULE   WINAPI DrvGetModuleHandle( HDRVR hDriver)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"DrvGetModuleHandle\n");
-		return DrvGetModuleHandle_orig( hDriver);
-	}
-
-	HMODULE   WINAPI GetDriverModuleHandle( HDRVR hDriver)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"GetDriverModuleHandle\n");
-		return GetDriverModuleHandle_orig( hDriver);
-	}
-
-	LRESULT   WINAPI DefDriverProc( DWORD_PTR dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"DefDriverProc\n");
-		return DefDriverProc_orig( dwDriverIdentifier, hdrvr, uMsg, lParam1, lParam2);
-	}
-
-	BOOL WINAPI DriverCallback( DWORD dwCallBack, DWORD dwFlags, HDRVR hdrvr, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"DriverCallback\n");
-		return DriverCallback_orig(dwCallBack, dwFlags, hdrvr, msg, dwUser, dwParam1, dwParam2);
-	}
-
-	UINT WINAPI mmsystemGetVersion(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmsystemGetVersion\n");
-		return mmsystemGetVersion_orig();
-	}
-
-	BOOL WINAPI sndPlaySoundA( LPCSTR pszSound, UINT fuSound)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"sndPlaySoundA\n");
-		return sndPlaySoundA_orig( pszSound, fuSound);
-	}
-
-	BOOL WINAPI sndPlaySoundW( LPCWSTR pszSound, UINT fuSound)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"sndPlaySoundW\n");
-		return sndPlaySoundW_orig( pszSound, fuSound);
-	}
-
-	BOOL WINAPI PlaySoundA( LPCSTR pszSound, HMODULE hmod, DWORD fdwSound)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"PlaySoundA\n");
-		return PlaySoundA_orig( pszSound, hmod, fdwSound);
-	}
-
-	BOOL WINAPI PlaySoundW( LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"PlaySoundW\n");
-		return PlaySoundW_orig( pszSound, hmod, fdwSound);
-	}
-
-	UINT WINAPI waveOutGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetNumDevs\n");
-		return waveOutGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI waveOutGetDevCapsA( UINT_PTR uDeviceID, LPWAVEOUTCAPSA pwoc, UINT cbwoc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetDevCapsA\n");
-		return waveOutGetDevCapsA_orig( uDeviceID, pwoc, cbwoc);
-	}
-
-	MMRESULT WINAPI waveOutGetDevCapsW( UINT_PTR uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetDevCapsW\n");
-		return waveOutGetDevCapsW_orig( uDeviceID, pwoc, cbwoc);
-	}
-
-
-	MMRESULT WINAPI waveOutGetVolume( HWAVEOUT hwo, LPDWORD pdwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetVolume\n");
-		return waveOutGetVolume_orig( hwo, pdwVolume);
-	}
-
-	MMRESULT WINAPI waveOutSetVolume( HWAVEOUT hwo, DWORD dwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutSetVolume\n");
-		return waveOutSetVolume_orig( hwo, dwVolume);
-	}
-
-	MMRESULT WINAPI waveOutGetErrorTextA( MMRESULT mmrError, LPSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetErrorTextA\n");
-		return waveOutGetErrorTextA_orig( mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI waveOutGetErrorTextW( MMRESULT mmrError, LPWSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetErrorTextW\n");
-		return waveOutGetErrorTextW_orig( mmrError, pszText, cchText);
-	}
-
-	//MMRESULT WINAPI waveOutOpen( LPHWAVEOUT phwo, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	//{
-	//	//OutputDebugString(L"waveOutGetErrorTextW\n");
-	//	return waveOutOpen_orig( phwo, uDeviceID, pwfx, dwCallback, dwInstance, fdwOpen);
-	//}
-
-	//MMRESULT WINAPI waveOutClose( HWAVEOUT hwo)
-	//{
-	//	//OutputDebugString(L"waveOutGetErrorTextW\n");
-	//	return waveOutClose_orig( hwo );
-	//}
-
-	MMRESULT WINAPI waveOutPrepareHeader( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutPrepareHeader\n");
-		return waveOutPrepareHeader_orig( hwo, pwh, cbwh);
-	}
-
-	MMRESULT WINAPI waveOutUnprepareHeader( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutUnprepareHeader\n");
-		return waveOutUnprepareHeader_orig( hwo, pwh, cbwh);
-	}
-
-
-	//MMRESULT WINAPI waveOutWrite( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
-	//{
-	//	//OutputDebugString(L"waveOutUnprepareHeader\n");
-	//	return waveOutWrite_orig( hwo, pwh, cbwh);
-	//}
-
-	MMRESULT WINAPI waveOutPause( HWAVEOUT hwo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutPause\n");
-		return waveOutPause_orig( hwo);
-	}
-
-	MMRESULT WINAPI waveOutRestart( HWAVEOUT hwo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutRestart\n");
-		return waveOutRestart_orig( hwo);
-	}
-
-	MMRESULT WINAPI waveOutReset( HWAVEOUT hwo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutReset\n");
-		return waveOutReset_orig( hwo);
-	}
-
-	MMRESULT WINAPI waveOutBreakLoop( HWAVEOUT hwo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutBreakLoop\n");
-		return waveOutBreakLoop_orig( hwo);
-	}
-
-	MMRESULT WINAPI waveOutGetPosition( HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetPosition\n");
-		return waveOutGetPosition_orig( hwo, pmmt, cbmmt);
-	}
-
-	MMRESULT WINAPI waveOutGetPitch( HWAVEOUT hwo, LPDWORD pdwPitch)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetPitch\n");
-		return waveOutGetPitch_orig( hwo, pdwPitch);
-	}
-
-	MMRESULT WINAPI waveOutSetPitch( HWAVEOUT hwo, DWORD dwPitch)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutSetPitch\n");
-		return waveOutSetPitch_orig( hwo, dwPitch);
-	}
-
-	MMRESULT WINAPI waveOutGetPlaybackRate( HWAVEOUT hwo, LPDWORD pdwRate)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetPlaybackRate\n");
-		return waveOutGetPlaybackRate_orig( hwo, pdwRate);
-	}
-
-	MMRESULT WINAPI waveOutSetPlaybackRate( HWAVEOUT hwo, DWORD dwRate)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutSetPlaybackRate\n");
-		return waveOutSetPlaybackRate_orig( hwo, dwRate);
-	}
-
-	MMRESULT WINAPI waveOutGetID( HWAVEOUT hwo, LPUINT puDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutGetID\n");
-		return waveOutGetID_orig( hwo, puDeviceID);
-	}
-
-	MMRESULT WINAPI waveOutMessage( HWAVEOUT hwo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveOutMessage\n");
-		return waveOutMessage_orig( hwo, uMsg, dw1, dw2);
-	}
-
-	UINT WINAPI waveInGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetNumDevs\n");
-		return waveInGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI waveInGetDevCapsA( UINT_PTR uDeviceID, LPWAVEINCAPSA pwic, UINT cbwic)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetDevCapsA\n");
-		return waveInGetDevCapsA_orig( uDeviceID, pwic, cbwic);
-	}
-
-	MMRESULT WINAPI waveInGetDevCapsW( UINT_PTR uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetDevCapsW\n");
-		return waveInGetDevCapsW_orig( uDeviceID, pwic, cbwic);
-	}
-
-	MMRESULT WINAPI waveInGetErrorTextA(MMRESULT mmrError, LPSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetErrorTextA\n");
-		return waveInGetErrorTextA_orig(mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI waveInGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetErrorTextW\n");
-		return waveInGetErrorTextW_orig(mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI waveInOpen( LPHWAVEIN phwi, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInOpen\n");
-		return waveInOpen_orig(phwi, uDeviceID, pwfx, dwCallback, dwInstance, fdwOpen);
-	}
-
-	MMRESULT WINAPI waveInClose( HWAVEIN hwi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInClose\n");
-		return waveInClose_orig( hwi);
-	}
-
-	MMRESULT WINAPI waveInPrepareHeader( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInPrepareHeader\n");
-		return waveInPrepareHeader_orig( hwi, pwh, cbwh);
-	}
-
-	MMRESULT WINAPI waveInUnprepareHeader( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInUnprepareHeader\n");
-		return waveInUnprepareHeader_orig( hwi, pwh, cbwh);
-	}
-
-	MMRESULT WINAPI waveInAddBuffer( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInAddBuffer\n");
-		return waveInAddBuffer_orig( hwi, pwh, cbwh);
-	}
-
-	MMRESULT WINAPI waveInStart( HWAVEIN hwi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInStart\n");
-		return waveInStart_orig( hwi);
-	}
-
-	MMRESULT WINAPI waveInStop( HWAVEIN hwi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInStop\n");
-		return waveInStop_orig(hwi);
-	}
-
-	MMRESULT WINAPI waveInReset( HWAVEIN hwi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInReset\n");
-		return waveInReset_orig(hwi);
-	}
-
-	MMRESULT WINAPI waveInGetPosition( HWAVEIN hwi, LPMMTIME pmmt, UINT cbmmt)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetPosition\n");
-		return waveInGetPosition_orig( hwi, pmmt, cbmmt);
-	}
-
-	MMRESULT WINAPI waveInGetID( HWAVEIN hwi, LPUINT puDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInGetID\n");
-		return waveInGetID_orig( hwi, puDeviceID);
-	}
-
-	MMRESULT WINAPI waveInMessage( HWAVEIN hwi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"waveInMessage\n");
-		return waveInMessage_orig( hwi, uMsg, dw1, dw2);
-	}
-
-	UINT WINAPI midiOutGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetNumDevs\n");
-		return midiOutGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI midiStreamOpen( LPHMIDISTRM phms, LPUINT puDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamOpen\n");
-		return midiStreamOpen_orig( phms, puDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
-	}
-
-	MMRESULT WINAPI midiStreamClose( HMIDISTRM hms)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamClose\n");
-		return midiStreamClose_orig( hms);
-	}
-
-	MMRESULT WINAPI midiStreamProperty( HMIDISTRM hms, LPBYTE lppropdata, DWORD dwProperty)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamProperty\n");
-		return midiStreamProperty_orig( hms, lppropdata, dwProperty);
-	}
-
-	MMRESULT WINAPI midiStreamPosition( HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamPosition\n");
-		return midiStreamPosition_orig( hms, lpmmt, cbmmt);
-	}
-
-	MMRESULT WINAPI midiStreamOut( HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamOut\n");
-		return midiStreamOut_orig( hms, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiStreamPause( HMIDISTRM hms)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamPause\n");
-		return midiStreamPause_orig( hms);
-	}
-
-	MMRESULT WINAPI midiStreamRestart( HMIDISTRM hms)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamRestart\n");
-		return midiStreamRestart_orig( hms);
-	}
-
-	MMRESULT WINAPI midiStreamStop( HMIDISTRM hms)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiStreamStop\n");
-		return midiStreamStop_orig( hms);
-	}
-
-	MMRESULT WINAPI midiConnect( HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiConnect\n");
-		return midiConnect_orig( hmi, hmo, pReserved);
-	}
-
-	MMRESULT WINAPI midiDisconnect( HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiDisconnect\n");
-		return midiDisconnect_orig( hmi, hmo, pReserved);
-	}
-
-	MMRESULT WINAPI midiOutGetDevCapsA( UINT_PTR uDeviceID, LPMIDIOUTCAPSA pmoc, UINT cbmoc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetDevCapsA\n");
-		return midiOutGetDevCapsA_orig( uDeviceID, pmoc, cbmoc);
-	}
-
-	MMRESULT WINAPI midiOutGetDevCapsW( UINT_PTR uDeviceID, LPMIDIOUTCAPSW pmoc, UINT cbmoc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetDevCapsW\n");
-		return midiOutGetDevCapsW_orig( uDeviceID, pmoc, cbmoc);
-	}
-
-	MMRESULT WINAPI midiOutGetVolume( HMIDIOUT hmo, LPDWORD pdwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetVolume\n");
-		return midiOutGetVolume_orig( hmo, pdwVolume);
-	}
-
-	MMRESULT WINAPI midiOutSetVolume( HMIDIOUT hmo, DWORD dwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutSetVolume\n");
-		return midiOutSetVolume_orig( hmo, dwVolume);
-	}
-
-	MMRESULT WINAPI midiOutGetErrorTextA( MMRESULT mmrError, LPSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetErrorTextA\n");
-		return midiOutGetErrorTextA_orig( mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI midiOutGetErrorTextW( MMRESULT mmrError, LPWSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetErrorTextW\n");
-		return midiOutGetErrorTextW_orig( mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI midiOutOpen( LPHMIDIOUT phmo, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutOpen\n");
-		return midiOutOpen_orig(phmo, uDeviceID, dwCallback, dwInstance, fdwOpen);
-	}
-
-	MMRESULT WINAPI midiOutClose( HMIDIOUT hmo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutClose\n");
-		return midiOutClose_orig( hmo);
-	}
-
-	MMRESULT WINAPI midiOutPrepareHeader( HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutPrepareHeader\n");
-		return midiOutPrepareHeader_orig( hmo, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiOutUnprepareHeader(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutUnprepareHeader\n");
-		return midiOutUnprepareHeader_orig(hmo, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiOutShortMsg( HMIDIOUT hmo, DWORD dwMsg)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutShortMsg\n");
-		return midiOutShortMsg_orig( hmo, dwMsg);
-	}
-
-	MMRESULT WINAPI midiOutLongMsg(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutLongMsg\n");
-		return midiOutLongMsg_orig(hmo, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiOutReset( HMIDIOUT hmo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutReset\n");
-		return midiOutReset_orig( hmo);
-	}
-
-	MMRESULT WINAPI midiOutCachePatches( HMIDIOUT hmo, UINT uBank, LPWORD pwpa, UINT fuCache)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutCachePatches\n");
-		return midiOutCachePatches_orig( hmo, uBank, pwpa, fuCache);
-	}
-
-	MMRESULT WINAPI midiOutCacheDrumPatches( HMIDIOUT hmo, UINT uPatch, LPWORD pwkya, UINT fuCache)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutCacheDrumPatches\n");
-		return midiOutCacheDrumPatches_orig( hmo, uPatch, pwkya, fuCache);
-	}
-
-	MMRESULT WINAPI midiOutGetID( HMIDIOUT hmo, LPUINT puDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutGetID\n");
-		return midiOutGetID_orig( hmo, puDeviceID);
-	}
-
-	MMRESULT WINAPI midiOutMessage( HMIDIOUT hmo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiOutMessage\n");
-		return midiOutMessage_orig( hmo, uMsg, dw1, dw2);
-	}
-
-	UINT WINAPI midiInGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetNumDevs\n");
-		return midiInGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI midiInGetDevCapsA( UINT_PTR uDeviceID, LPMIDIINCAPSA pmic, UINT cbmic)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetDevCapsA\n");
-		return midiInGetDevCapsA_orig( uDeviceID, pmic, cbmic);
-	}
-
-	MMRESULT WINAPI midiInGetDevCapsW( UINT_PTR uDeviceID, LPMIDIINCAPSW pmic, UINT cbmic)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetDevCapsW\n");
-		return midiInGetDevCapsW_orig( uDeviceID, pmic, cbmic);
-	}
-
-	MMRESULT WINAPI midiInGetErrorTextA( MMRESULT mmrError, LPSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetErrorTextA\n");
-		return midiInGetErrorTextA_orig( mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI midiInGetErrorTextW( MMRESULT mmrError, LPWSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetErrorTextW\n");
-		return midiInGetErrorTextW_orig( mmrError, pszText, cchText);
-	}
-
-	MMRESULT WINAPI midiInOpen( LPHMIDIIN phmi, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInOpen\n");
-		return midiInOpen_orig(phmi, uDeviceID, dwCallback, dwInstance, fdwOpen);
-	}
-
-	MMRESULT WINAPI midiInClose( HMIDIIN hmi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInClose\n");
-		return midiInClose_orig( hmi);
-	}
-
-	MMRESULT WINAPI midiInPrepareHeader( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInPrepareHeader\n");
-		return midiInPrepareHeader_orig( hmi, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiInUnprepareHeader( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInUnprepareHeader\n");
-		return midiInUnprepareHeader_orig( hmi, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiInAddBuffer( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInAddBuffer\n");
-		return midiInAddBuffer_orig( hmi, pmh, cbmh);
-	}
-
-	MMRESULT WINAPI midiInStart( HMIDIIN hmi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInStart\n");
-		return midiInStart_orig( hmi);
-	}
-
-	MMRESULT WINAPI midiInStop( HMIDIIN hmi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInStop\n");
-		return midiInStop_orig(hmi);
-	}
-
-	MMRESULT WINAPI midiInReset( HMIDIIN hmi)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInReset\n");
-		return midiInReset_orig( hmi);
-	}
-
-	MMRESULT WINAPI midiInGetID( HMIDIIN hmi, LPUINT puDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInGetID\n");
-		return midiInGetID_orig( hmi, puDeviceID);
-	}
-
-	MMRESULT WINAPI midiInMessage( HMIDIIN hmi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"midiInMessage\n");
-		return midiInMessage_orig( hmi, uMsg, dw1, dw2);
-	}
-
-	UINT WINAPI auxGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxGetNumDevs\n");
-		return auxGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI auxGetDevCapsA( UINT_PTR uDeviceID, LPAUXCAPSA pac, UINT cbac)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxGetDevCapsA\n");
-		return auxGetDevCapsA_orig( uDeviceID, pac, cbac);
-	}
-
-	MMRESULT WINAPI auxGetDevCapsW( UINT_PTR uDeviceID, LPAUXCAPSW pac, UINT cbac)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxGetDevCapsW\n");
-		return auxGetDevCapsW_orig( uDeviceID, pac, cbac);
-	}
-
-	MMRESULT WINAPI auxSetVolume( UINT uDeviceID, DWORD dwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxSetVolume\n");
-		return auxSetVolume_orig( uDeviceID, dwVolume);
-	}
-
-	MMRESULT WINAPI auxGetVolume( UINT uDeviceID, LPDWORD pdwVolume)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxGetVolume\n");
-		return auxGetVolume_orig( uDeviceID, pdwVolume);
-	}
-
-	MMRESULT WINAPI auxOutMessage( UINT uDeviceID, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"auxOutMessage\n");
-		return auxOutMessage_orig( uDeviceID, uMsg, dw1, dw2);
-	}
-
-	UINT WINAPI mixerGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetNumDevs\n");
-		return mixerGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI mixerGetDevCapsA( UINT_PTR uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetDevCapsA\n");
-		return mixerGetDevCapsA_orig( uMxId, pmxcaps, cbmxcaps);
-	}
-
-	MMRESULT WINAPI mixerGetDevCapsW( UINT_PTR uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetDevCapsW\n");
-		return mixerGetDevCapsW_orig( uMxId, pmxcaps, cbmxcaps);
-	}
-
-	MMRESULT WINAPI mixerOpen( LPHMIXER phmx, UINT uMxId, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerOpen\n");
-		return mixerOpen_orig( phmx, uMxId, dwCallback, dwInstance, fdwOpen);
-	}
-
-	MMRESULT WINAPI mixerClose( HMIXER hmx)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerClose\n");
-		return mixerClose_orig( hmx);
-	}
-
-	DWORD WINAPI mixerMessage( HMIXER hmx, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerMessage\n");
-		return mixerMessage_orig( hmx, uMsg, dwParam1, dwParam2);
-	}
-
-	MMRESULT WINAPI mixerGetLineInfoA( HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetLineInfoA\n");
-		return mixerGetLineInfoA_orig( hmxobj, pmxl, fdwInfo);
-	}
-
-	MMRESULT WINAPI mixerGetLineInfoW( HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetLineInfoW\n");
-		return mixerGetLineInfoW_orig( hmxobj, pmxl, fdwInfo);
-	}
-
-	MMRESULT WINAPI mixerGetID( HMIXEROBJ hmxobj, UINT FAR *puMxId, DWORD fdwId)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetID\n");
-		return mixerGetID_orig( hmxobj, puMxId, fdwId);
-	}
-
-	MMRESULT WINAPI mixerGetLineControlsA( HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetLineControlsA\n");
-		return mixerGetLineControlsA_orig( hmxobj, pmxlc, fdwControls);
-	}
-
-	MMRESULT WINAPI mixerGetLineControlsW( HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetLineControlsW\n");
-		return mixerGetLineControlsW_orig( hmxobj, pmxlc, fdwControls);
-	}
-
-	MMRESULT WINAPI mixerGetControlDetailsA( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetControlDetailsA\n");
-		return mixerGetControlDetailsA_orig( hmxobj, pmxcd, fdwDetails);
-	}
-
-	MMRESULT WINAPI mixerGetControlDetailsW( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerGetControlDetailsW\n");
-		return mixerGetControlDetailsW_orig( hmxobj, pmxcd, fdwDetails);
-	}
-
-	MMRESULT WINAPI mixerSetControlDetails( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mixerSetControlDetails\n");
-		return mixerSetControlDetails_orig( hmxobj, pmxcd, fdwDetails);
-	}
-
-	DWORD    WINAPI mmGetCurrentTask(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmGetCurrentTask\n");
-		return mmGetCurrentTask_orig();
-	}
-
-	void WINAPI mmTaskBlock(DWORD val)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmTaskBlock\n");
-		return mmTaskBlock_orig(val);
-	}
-
-	UINT WINAPI mmTaskCreate(LPTASKCALLBACK a, HANDLE* b, DWORD_PTR c)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmTaskCreate\n");
-		return mmTaskCreate_orig(a, b, c);
-	}
-
-	BOOL WINAPI mmTaskSignal(DWORD a)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmTaskSignal\n");
-		return mmTaskSignal_orig(a);
-	}
-
-	VOID WINAPI mmTaskYield()
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmTaskYield\n");
-		mmTaskYield_orig();
-	}
-
-	MMRESULT WINAPI timeGetSystemTime( LPMMTIME pmmt, UINT cbmmt)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeGetSystemTime\n");
-		return timeGetSystemTime_orig( pmmt, cbmmt);
-	}
-
-	DWORD WINAPI timeGetTime(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeGetTime\n");
-		return timeGetTime_orig();
-	}
-
-	MMRESULT WINAPI timeSetEvent( UINT uDelay, UINT uResolution, LPTIMECALLBACK fptc, DWORD_PTR dwUser, UINT fuEvent)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeSetEvent\n");
-		return timeSetEvent_orig(uDelay, uResolution, fptc, dwUser, fuEvent);
-	}
-
-	MMRESULT WINAPI timeKillEvent( UINT uTimerID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeKillEvent\n");
-		return timeKillEvent_orig( uTimerID);
-	}
-
-	MMRESULT WINAPI timeGetDevCaps( LPTIMECAPS ptc, UINT cbtc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeGetDevCaps\n");
-		return timeGetDevCaps_orig( ptc, cbtc);
-	}
-
-	MMRESULT WINAPI timeBeginPeriod( UINT uPeriod)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeBeginPeriod\n");
-		return timeBeginPeriod_orig( uPeriod);
-	}
-
-	MMRESULT WINAPI timeEndPeriod( UINT uPeriod)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"timeEndPeriod\n");
-		return timeEndPeriod_orig( uPeriod);
-	}
-
-	UINT WINAPI joyGetNumDevs(void)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetNumDevs\n");
-		return joyGetNumDevs_orig();
-	}
-
-	MMRESULT WINAPI joyConfigChanged(DWORD dwFlags)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyConfigChanged\n");
-		return joyConfigChanged_orig(dwFlags);
-	}
-
-	MMRESULT WINAPI joyGetDevCapsA( UINT_PTR uJoyID, LPJOYCAPSA pjc, UINT cbjc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetDevCapsA\n");
-		return joyGetDevCapsA_orig( uJoyID, pjc, cbjc);
-	}
-
-	MMRESULT WINAPI joyGetDevCapsW( UINT_PTR uJoyID, LPJOYCAPSW pjc, UINT cbjc)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetDevCapsW\n");
-		return joyGetDevCapsW_orig( uJoyID, pjc, cbjc);
-	}
-
-	MMRESULT WINAPI joyGetPos( UINT uJoyID, LPJOYINFO pji)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetPos\n");
-		return joyGetPos_orig( uJoyID, pji);
-	}
-
-	MMRESULT WINAPI joyGetPosEx( UINT uJoyID, LPJOYINFOEX pji)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetPosEx\n");
-		return joyGetPosEx_orig( uJoyID, pji);
-	}
-
-	MMRESULT WINAPI joyGetThreshold( UINT uJoyID, LPUINT puThreshold)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyGetThreshold\n");
-		return joyGetThreshold_orig( uJoyID, puThreshold);
-	}
-
-	MMRESULT WINAPI joyReleaseCapture( UINT uJoyID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joyReleaseCapture\n");
-		return joyReleaseCapture_orig( uJoyID);
-	}
-
-	MMRESULT WINAPI joySetCapture( HWND hwnd, UINT uJoyID, UINT uPeriod, BOOL fChanged)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joySetCapture\n");
-		return joySetCapture_orig(hwnd, uJoyID, uPeriod, fChanged);
-	}
-
-	MMRESULT WINAPI joySetThreshold( UINT uJoyID, UINT uThreshold)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"joySetThreshold\n");
-		return joySetThreshold_orig( uJoyID, uThreshold);
-	}
-
-	BOOL WINAPI mciDriverNotify(HANDLE hwndCallback, MCIDEVICEID uDeviceID, UINT uStatus)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciDriverNotify\n");
-		return mciDriverNotify_orig(hwndCallback, uDeviceID, uStatus);
-	}
-
-	UINT WINAPI  mciDriverYield(UINT uDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciDriverYield\n");
-		return mciDriverYield_orig(uDeviceID);
-	}	
-
-	FOURCC WINAPI mmioStringToFOURCCA( LPCSTR sz, UINT uFlags)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioStringToFOURCCA\n");
-		return mmioStringToFOURCCA_orig( sz, uFlags);
-	}
-
-	FOURCC WINAPI mmioStringToFOURCCW( LPCWSTR sz, UINT uFlags)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioStringToFOURCCW\n");
-		return mmioStringToFOURCCW_orig( sz, uFlags);
-	}
-
-	LPMMIOPROC WINAPI mmioInstallIOProcA( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioInstallIOProcA\n");
-		return mmioInstallIOProcA_orig( fccIOProc, pIOProc, dwFlags);
-	}
-
-	LPMMIOPROC WINAPI mmioInstallIOProcW( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioInstallIOProcW\n");
-		return mmioInstallIOProcW_orig( fccIOProc, pIOProc, dwFlags);
-	}
-
-	HMMIO WINAPI mmioOpenA( LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioOpenA\n");
-		return mmioOpenA_orig( pszFileName, pmmioinfo, fdwOpen);
-	}
-
-	HMMIO WINAPI mmioOpenW( LPWSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioOpenW\n");
-		return mmioOpenW_orig( pszFileName, pmmioinfo, fdwOpen);
-	}
-
-	MMRESULT WINAPI mmioRenameA( LPCSTR pszFileName, LPCSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioRenameA\n");
-		return mmioRenameA_orig( pszFileName, pszNewFileName, pmmioinfo, fdwRename);
-	}
-
-	MMRESULT WINAPI mmioRenameW( LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioRenameW\n");
-		return mmioRenameW_orig( pszFileName, pszNewFileName, pmmioinfo, fdwRename);
-	}
-
-	MMRESULT WINAPI mmioClose( HMMIO hmmio, UINT fuClose)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioClose\n");
-		return mmioClose_orig( hmmio, fuClose);
-	}
-
-	LONG WINAPI mmioRead( HMMIO hmmio, HPSTR pch, LONG cch)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioRead\n");
-		return mmioRead_orig( hmmio, pch, cch);
-	}
-
-	LONG WINAPI mmioWrite( HMMIO hmmio, const char _huge* pch, LONG cch)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioWrite\n");
-		return mmioWrite_orig( hmmio, pch, cch);
-	}
-
-	LONG WINAPI mmioSeek( HMMIO hmmio, LONG lOffset, int iOrigin)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioSeek\n");
-		return mmioSeek_orig(hmmio, lOffset, iOrigin);
-	}
-
-	MMRESULT WINAPI mmioGetInfo( HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuInfo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioGetInfo\n");
-		return mmioGetInfo_orig( hmmio, pmmioinfo, fuInfo);
-	}
-
-	MMRESULT WINAPI mmioSetInfo( HMMIO hmmio, LPCMMIOINFO pmmioinfo, UINT fuInfo)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioSetInfo\n");
-		return mmioSetInfo_orig( hmmio, pmmioinfo, fuInfo);
-	}
-
-	MMRESULT WINAPI mmioSetBuffer( HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT fuBuffer)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioSetBuffer\n");
-		return mmioSetBuffer_orig(hmmio, pchBuffer, cchBuffer, fuBuffer);
-	}
-
-	MMRESULT WINAPI mmioFlush( HMMIO hmmio, UINT fuFlush)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioFlush\n");
-		return mmioFlush_orig( hmmio, fuFlush);
-	}
-
-	MMRESULT WINAPI mmioAdvance( HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuAdvance)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioAdvance\n");
-		return mmioAdvance_orig( hmmio, pmmioinfo, fuAdvance);
-	}
-
-	LRESULT WINAPI mmioSendMessage( HMMIO hmmio, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioSendMessage\n");
-		return mmioSendMessage_orig(hmmio, uMsg, lParam1, lParam2);
-	}
-
-	MMRESULT WINAPI mmioDescend( HMMIO hmmio, LPMMCKINFO pmmcki, const MMCKINFO FAR* pmmckiParent, UINT fuDescend)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioDescend\n");
-		return mmioDescend_orig(hmmio, pmmcki, pmmckiParent, fuDescend);
-	}
-
-	MMRESULT WINAPI mmioAscend( HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuAscend)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioAscend\n");
-		return mmioAscend_orig( hmmio, pmmcki, fuAscend);
-	}
-
-	MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuCreate)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mmioCreateChunk\n");
-		return mmioCreateChunk_orig(hmmio, pmmcki, fuCreate);
-	}
-
-	MCIERROR WINAPI mciSendCommandA( MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSendCommandA\n");
-		return mciSendCommandA_orig( mciId, uMsg, dwParam1, dwParam2);
-	}
-
-	MCIERROR WINAPI mciSendCommandW( MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSendCommandW\n");
-		return mciSendCommandW_orig( mciId, uMsg, dwParam1, dwParam2);
-	}
-
-	MCIERROR  WINAPI mciSendStringA( LPCSTR lpstrCommand, LPSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSendStringA\n");
-		return mciSendStringA_orig( lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
-	}
-
-	MCIERROR  WINAPI mciSendStringW( LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSendStringW\n");
-		return mciSendStringW_orig( lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
-	}
-
-	MCIDEVICEID WINAPI mciGetDeviceIDA( LPCSTR pszDevice)
-	{
-		//OutputDebugString(L"mciGetDeviceIDA\n");
-		return mciGetDeviceIDA_orig( pszDevice);
-	}
-
-	MCIDEVICEID WINAPI mciGetDeviceIDW( LPCWSTR pszDevice)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetDeviceIDW\n");
-		return mciGetDeviceIDW_orig( pszDevice);
-	}
-
-	MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA( DWORD dwElementID, LPCSTR lpstrType )
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetDeviceIDFromElementIDA\n");
-		return mciGetDeviceIDFromElementIDA_orig( dwElementID, lpstrType );
-	}
-
-	MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW( DWORD dwElementID, LPCWSTR lpstrType )
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetDeviceIDFromElementIDW\n");
-		return mciGetDeviceIDFromElementIDW_orig( dwElementID, lpstrType );
-	}
-
-	DWORD_PTR WINAPI  mciGetDriverData(UINT uDeviceID)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetDriverData\n");
-		return mciGetDriverData_orig(uDeviceID);
-	}
-
-	BOOL WINAPI mciGetErrorStringA( MCIERROR mcierr, LPSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetErrorStringA\n");
-		return mciGetErrorStringA_orig( mcierr, pszText, cchText);
-	}
-
-	BOOL WINAPI mciGetErrorStringW( MCIERROR mcierr, LPWSTR pszText, UINT cchText)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetErrorStringW\n");
-		return mciGetErrorStringW_orig( mcierr, pszText, cchText);
-	}
-
-	BOOL WINAPI  mciSetDriverData(UINT uDeviceID, DWORD_PTR dwData)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSetDriverData_type\n");
-		return mciSetDriverData_orig( uDeviceID, dwData );
-	}
-
-	BOOL WINAPI mciSetYieldProc( MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciSetYieldProc\n");
-		return mciSetYieldProc_orig(mciId, fpYieldProc, dwYieldData);
-	}
-
-	BOOL WINAPI  mciFreeCommandResource(UINT uTable)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciFreeCommandResource\n");
-		return mciFreeCommandResource_orig(uTable);
-	}
-
-	HTASK WINAPI mciGetCreatorTask( MCIDEVICEID mciId)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetCreatorTask\n");
-		return mciGetCreatorTask_orig( mciId);
-	}
-
-	YIELDPROC WINAPI mciGetYieldProc( MCIDEVICEID mciId, LPDWORD pdwYieldData)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciGetYieldProc\n");
-		return mciGetYieldProc_orig( mciId, pdwYieldData);
-	}
-
-	UINT WINAPI mciLoadCommandResource(HANDLE hInstance, LPCWSTR lpResName, UINT uType)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciLoadCommandResource");
-		return mciLoadCommandResource_orig(hInstance, lpResName, uType);
-	}
-	
-
-	BOOL WINAPI mciExecute(LPCSTR pszCommand)
-	{
-		ll_winmm_shim_initialize();
-		//OutputDebugString(L"mciExecute\n");
-		return mciExecute_orig(pszCommand);
-	}
-}
diff --git a/indra/media_plugins/winmmshim/forwarding_api.h b/indra/media_plugins/winmmshim/forwarding_api.h
deleted file mode 100644
index 1418fc9e1d..0000000000
--- a/indra/media_plugins/winmmshim/forwarding_api.h
+++ /dev/null
@@ -1,390 +0,0 @@
-/** 
- * @file forwarding_api.h
- * @brief forwards winmm API calls to real winmm.dll
- *
- * $LicenseInfo:firstyear=2010&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// this turns off __declspec(dllimport) for the functions declared in mmsystem.h
-#define _WINMM_
-#include <windows.h>
-#include <mmsystem.h>
-
-void init_function_pointers(HMODULE winmm_handle);
-void ll_winmm_shim_initialize();
-
-typedef VOID (*LPTASKCALLBACK)(DWORD_PTR dwInst);
-
-typedef LRESULT   (WINAPI *CloseDriver_type)( HDRVR hDriver, LPARAM lParam1, LPARAM lParam2);
-extern CloseDriver_type CloseDriver_orig;
-typedef HDRVR     (WINAPI *OpenDriver_type)( LPCWSTR szDriverName, LPCWSTR szSectionName, LPARAM lParam2);
-extern OpenDriver_type OpenDriver_orig;
-typedef LRESULT   (WINAPI *SendDriverMessage_type)( HDRVR hDriver, UINT message, LPARAM lParam1, LPARAM lParam2);
-extern SendDriverMessage_type SendDriverMessage_orig;
-typedef HMODULE   (WINAPI *DrvGetModuleHandle_type)( HDRVR hDriver);
-extern DrvGetModuleHandle_type DrvGetModuleHandle_orig;
-typedef HMODULE   (WINAPI *GetDriverModuleHandle_type)( HDRVR hDriver);
-extern GetDriverModuleHandle_type GetDriverModuleHandle_orig;
-typedef LRESULT   (WINAPI *DefDriverProc_type)( DWORD_PTR dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
-extern DefDriverProc_type DefDriverProc_orig;
-typedef BOOL (WINAPI *DriverCallback_type)(DWORD dwCallBack, DWORD dwFlags, HDRVR hdrvr, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
-extern DriverCallback_type DriverCallback_orig;
-typedef UINT (WINAPI *mmsystemGetVersion_type)(void);
-extern mmsystemGetVersion_type mmsystemGetVersion_orig;
-typedef BOOL (WINAPI *sndPlaySoundA_type)( LPCSTR pszSound, UINT fuSound);
-extern sndPlaySoundA_type sndPlaySoundA_orig;
-typedef BOOL (WINAPI *sndPlaySoundW_type)( LPCWSTR pszSound, UINT fuSound);
-extern sndPlaySoundW_type sndPlaySoundW_orig;
-typedef BOOL (WINAPI *PlaySoundA_type)( LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
-extern PlaySoundA_type PlaySoundA_orig;
-typedef BOOL (WINAPI *PlaySoundW_type)( LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound);
-extern PlaySoundW_type PlaySoundW_orig;
-typedef UINT (WINAPI *waveOutGetNumDevs_type)(void);
-extern waveOutGetNumDevs_type waveOutGetNumDevs_orig;
-typedef MMRESULT (WINAPI *waveOutGetDevCapsA_type)( UINT_PTR uDeviceID, LPWAVEOUTCAPSA pwoc, UINT cbwoc);
-extern waveOutGetDevCapsA_type waveOutGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *waveOutGetDevCapsW_type)( UINT_PTR uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc);
-extern waveOutGetDevCapsW_type waveOutGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *waveOutGetVolume_type)( HWAVEOUT hwo, LPDWORD pdwVolume);
-extern waveOutGetVolume_type waveOutGetVolume_orig;
-typedef MMRESULT (WINAPI *waveOutSetVolume_type)( HWAVEOUT hwo, DWORD dwVolume);
-extern waveOutSetVolume_type waveOutSetVolume_orig;
-typedef MMRESULT (WINAPI *waveOutGetErrorTextA_type)( MMRESULT mmrError, LPSTR pszText, UINT cchText);
-extern waveOutGetErrorTextA_type waveOutGetErrorTextA_orig;
-typedef MMRESULT (WINAPI *waveOutGetErrorTextW_type)( MMRESULT mmrError, LPWSTR pszText, UINT cchText);
-extern waveOutGetErrorTextW_type waveOutGetErrorTextW_orig;
-typedef MMRESULT (WINAPI *waveOutOpen_type)( LPHWAVEOUT phwo, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern waveOutOpen_type waveOutOpen_orig;
-typedef MMRESULT (WINAPI *waveOutClose_type)( HWAVEOUT hwo);
-extern waveOutClose_type waveOutClose_orig;
-typedef MMRESULT (WINAPI *waveOutPrepareHeader_type)( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
-extern waveOutPrepareHeader_type waveOutPrepareHeader_orig;
-typedef MMRESULT (WINAPI *waveOutUnprepareHeader_type)( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
-extern waveOutUnprepareHeader_type waveOutUnprepareHeader_orig;
-typedef MMRESULT (WINAPI *waveOutWrite_type)( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
-extern waveOutWrite_type waveOutWrite_orig;
-typedef MMRESULT (WINAPI *waveOutPause_type)( HWAVEOUT hwo);
-extern waveOutPause_type waveOutPause_orig;
-typedef MMRESULT (WINAPI *waveOutRestart_type)( HWAVEOUT hwo);
-extern waveOutRestart_type waveOutRestart_orig;
-typedef MMRESULT (WINAPI *waveOutReset_type)( HWAVEOUT hwo);
-extern waveOutReset_type waveOutReset_orig;
-typedef MMRESULT (WINAPI *waveOutBreakLoop_type)( HWAVEOUT hwo);
-extern waveOutBreakLoop_type waveOutBreakLoop_orig;
-typedef MMRESULT (WINAPI *waveOutGetPosition_type)( HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt);
-extern waveOutGetPosition_type waveOutGetPosition_orig;
-typedef MMRESULT (WINAPI *waveOutGetPitch_type)( HWAVEOUT hwo, LPDWORD pdwPitch);
-extern waveOutGetPitch_type waveOutGetPitch_orig;
-typedef MMRESULT (WINAPI *waveOutSetPitch_type)( HWAVEOUT hwo, DWORD dwPitch);
-extern waveOutSetPitch_type waveOutSetPitch_orig;
-typedef MMRESULT (WINAPI *waveOutGetPlaybackRate_type)( HWAVEOUT hwo, LPDWORD pdwRate);
-extern waveOutGetPlaybackRate_type waveOutGetPlaybackRate_orig;
-typedef MMRESULT (WINAPI *waveOutSetPlaybackRate_type)( HWAVEOUT hwo, DWORD dwRate);
-extern waveOutSetPlaybackRate_type waveOutSetPlaybackRate_orig;
-typedef MMRESULT (WINAPI *waveOutGetID_type)( HWAVEOUT hwo, LPUINT puDeviceID);
-extern waveOutGetID_type waveOutGetID_orig;
-typedef MMRESULT (WINAPI *waveOutMessage_type)( HWAVEOUT hwo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
-extern waveOutMessage_type waveOutMessage_orig;
-typedef UINT (WINAPI *waveInGetNumDevs_type)(void);
-extern waveInGetNumDevs_type waveInGetNumDevs_orig;
-typedef MMRESULT (WINAPI *waveInGetDevCapsA_type)( UINT_PTR uDeviceID, LPWAVEINCAPSA pwic, UINT cbwic);
-extern waveInGetDevCapsA_type waveInGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *waveInGetDevCapsW_type)( UINT_PTR uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic);
-extern waveInGetDevCapsW_type waveInGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *waveInGetErrorTextA_type)(MMRESULT mmrError, LPSTR pszText, UINT cchText);
-extern waveInGetErrorTextA_type waveInGetErrorTextA_orig;
-typedef MMRESULT (WINAPI *waveInGetErrorTextW_type)(MMRESULT mmrError, LPWSTR pszText, UINT cchText);
-extern waveInGetErrorTextW_type waveInGetErrorTextW_orig;
-typedef MMRESULT (WINAPI *waveInOpen_type)( LPHWAVEIN phwi, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern waveInOpen_type waveInOpen_orig;
-typedef MMRESULT (WINAPI *waveInClose_type)( HWAVEIN hwi);
-extern waveInClose_type waveInClose_orig;
-typedef MMRESULT (WINAPI *waveInPrepareHeader_type)( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
-extern waveInPrepareHeader_type waveInPrepareHeader_orig;
-typedef MMRESULT (WINAPI *waveInUnprepareHeader_type)( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
-extern waveInUnprepareHeader_type waveInUnprepareHeader_orig;
-typedef MMRESULT (WINAPI *waveInAddBuffer_type)( HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
-extern waveInAddBuffer_type waveInAddBuffer_orig;
-typedef MMRESULT (WINAPI *waveInStart_type)( HWAVEIN hwi);
-extern waveInStart_type waveInStart_orig;
-typedef MMRESULT (WINAPI *waveInStop_type)( HWAVEIN hwi);
-extern waveInStop_type waveInStop_orig;
-typedef MMRESULT (WINAPI *waveInReset_type)( HWAVEIN hwi);
-extern waveInReset_type waveInReset_orig;
-typedef MMRESULT (WINAPI *waveInGetPosition_type)( HWAVEIN hwi, LPMMTIME pmmt, UINT cbmmt);
-extern waveInGetPosition_type waveInGetPosition_orig;
-typedef MMRESULT (WINAPI *waveInGetID_type)( HWAVEIN hwi, LPUINT puDeviceID);
-extern waveInGetID_type waveInGetID_orig;
-typedef MMRESULT (WINAPI *waveInMessage_type)( HWAVEIN hwi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
-extern waveInMessage_type waveInMessage_orig;
-typedef UINT (WINAPI *midiOutGetNumDevs_type)(void);
-extern midiOutGetNumDevs_type midiOutGetNumDevs_orig;
-typedef MMRESULT (WINAPI *midiStreamOpen_type)( LPHMIDISTRM phms, LPUINT puDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern midiStreamOpen_type midiStreamOpen_orig;
-typedef MMRESULT (WINAPI *midiStreamClose_type)( HMIDISTRM hms);
-extern midiStreamClose_type midiStreamClose_orig;
-typedef MMRESULT (WINAPI *midiStreamProperty_type)( HMIDISTRM hms, LPBYTE lppropdata, DWORD dwProperty);
-extern midiStreamProperty_type midiStreamProperty_orig;
-typedef MMRESULT (WINAPI *midiStreamPosition_type)( HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
-extern midiStreamPosition_type midiStreamPosition_orig;
-typedef MMRESULT (WINAPI *midiStreamOut_type)( HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh);
-extern midiStreamOut_type midiStreamOut_orig;
-typedef MMRESULT (WINAPI *midiStreamPause_type)( HMIDISTRM hms);
-extern midiStreamPause_type midiStreamPause_orig;
-typedef MMRESULT (WINAPI *midiStreamRestart_type)( HMIDISTRM hms);
-extern midiStreamRestart_type midiStreamRestart_orig;
-typedef MMRESULT (WINAPI *midiStreamStop_type)( HMIDISTRM hms);
-extern midiStreamStop_type midiStreamStop_orig;
-typedef MMRESULT (WINAPI *midiConnect_type)( HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved);
-extern midiConnect_type midiConnect_orig;
-typedef MMRESULT (WINAPI *midiDisconnect_type)( HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved);
-extern midiDisconnect_type midiDisconnect_orig;
-typedef MMRESULT (WINAPI *midiOutGetDevCapsA_type)( UINT_PTR uDeviceID, LPMIDIOUTCAPSA pmoc, UINT cbmoc);
-extern midiOutGetDevCapsA_type midiOutGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *midiOutGetDevCapsW_type)( UINT_PTR uDeviceID, LPMIDIOUTCAPSW pmoc, UINT cbmoc);
-extern midiOutGetDevCapsW_type midiOutGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *midiOutGetVolume_type)( HMIDIOUT hmo, LPDWORD pdwVolume);
-extern midiOutGetVolume_type midiOutGetVolume_orig;
-typedef MMRESULT (WINAPI *midiOutSetVolume_type)( HMIDIOUT hmo, DWORD dwVolume);
-extern midiOutSetVolume_type midiOutSetVolume_orig;
-typedef MMRESULT (WINAPI *midiOutGetErrorTextA_type)( MMRESULT mmrError, LPSTR pszText, UINT cchText);
-extern midiOutGetErrorTextA_type midiOutGetErrorTextA_orig;
-typedef MMRESULT (WINAPI *midiOutGetErrorTextW_type)( MMRESULT mmrError, LPWSTR pszText, UINT cchText);
-extern midiOutGetErrorTextW_type midiOutGetErrorTextW_orig;
-typedef MMRESULT (WINAPI *midiOutOpen_type)( LPHMIDIOUT phmo, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern midiOutOpen_type midiOutOpen_orig;
-typedef MMRESULT (WINAPI *midiOutClose_type)( HMIDIOUT hmo);
-extern midiOutClose_type midiOutClose_orig;
-typedef MMRESULT (WINAPI *midiOutPrepareHeader_type)( HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
-extern midiOutPrepareHeader_type midiOutPrepareHeader_orig;
-typedef MMRESULT (WINAPI *midiOutUnprepareHeader_type)(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
-extern midiOutUnprepareHeader_type midiOutUnprepareHeader_orig;
-typedef MMRESULT (WINAPI *midiOutShortMsg_type)( HMIDIOUT hmo, DWORD dwMsg);
-extern midiOutShortMsg_type midiOutShortMsg_orig;
-typedef MMRESULT (WINAPI *midiOutLongMsg_type)(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
-extern midiOutLongMsg_type midiOutLongMsg_orig;
-typedef MMRESULT (WINAPI *midiOutReset_type)( HMIDIOUT hmo);
-extern midiOutReset_type midiOutReset_orig;
-typedef MMRESULT (WINAPI *midiOutCachePatches_type)( HMIDIOUT hmo, UINT uBank, LPWORD pwpa, UINT fuCache);
-extern midiOutCachePatches_type midiOutCachePatches_orig;
-typedef MMRESULT (WINAPI *midiOutCacheDrumPatches_type)( HMIDIOUT hmo, UINT uPatch, LPWORD pwkya, UINT fuCache);
-extern midiOutCacheDrumPatches_type midiOutCacheDrumPatches_orig;
-typedef MMRESULT (WINAPI *midiOutGetID_type)( HMIDIOUT hmo, LPUINT puDeviceID);
-extern midiOutGetID_type midiOutGetID_orig;
-typedef MMRESULT (WINAPI *midiOutMessage_type)( HMIDIOUT hmo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
-extern midiOutMessage_type midiOutMessage_orig;
-typedef UINT (WINAPI *midiInGetNumDevs_type)(void);
-extern midiInGetNumDevs_type midiInGetNumDevs_orig;
-typedef MMRESULT (WINAPI *midiInGetDevCapsA_type)( UINT_PTR uDeviceID, LPMIDIINCAPSA pmic, UINT cbmic);
-extern midiInGetDevCapsA_type midiInGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *midiInGetDevCapsW_type)( UINT_PTR uDeviceID, LPMIDIINCAPSW pmic, UINT cbmic);
-extern midiInGetDevCapsW_type midiInGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *midiInGetErrorTextA_type)( MMRESULT mmrError, LPSTR pszText, UINT cchText);
-extern midiInGetErrorTextA_type midiInGetErrorTextA_orig;
-typedef MMRESULT (WINAPI *midiInGetErrorTextW_type)( MMRESULT mmrError, LPWSTR pszText, UINT cchText);
-extern midiInGetErrorTextW_type midiInGetErrorTextW_orig;
-typedef MMRESULT (WINAPI *midiInOpen_type)( LPHMIDIIN phmi, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern midiInOpen_type midiInOpen_orig;
-typedef MMRESULT (WINAPI *midiInClose_type)( HMIDIIN hmi);
-extern midiInClose_type midiInClose_orig;
-typedef MMRESULT (WINAPI *midiInPrepareHeader_type)( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
-extern midiInPrepareHeader_type midiInPrepareHeader_orig;
-typedef MMRESULT (WINAPI *midiInUnprepareHeader_type)( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
-extern midiInUnprepareHeader_type midiInUnprepareHeader_orig;
-typedef MMRESULT (WINAPI *midiInAddBuffer_type)( HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
-extern midiInAddBuffer_type midiInAddBuffer_orig;
-typedef MMRESULT (WINAPI *midiInStart_type)( HMIDIIN hmi);
-extern midiInStart_type midiInStart_orig;
-typedef MMRESULT (WINAPI *midiInStop_type)( HMIDIIN hmi);
-extern midiInStop_type midiInStop_orig;
-typedef MMRESULT (WINAPI *midiInReset_type)( HMIDIIN hmi);
-extern midiInReset_type midiInReset_orig;
-typedef MMRESULT (WINAPI *midiInGetID_type)( HMIDIIN hmi, LPUINT puDeviceID);
-extern midiInGetID_type midiInGetID_orig;
-typedef MMRESULT (WINAPI *midiInMessage_type)( HMIDIIN hmi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
-extern midiInMessage_type midiInMessage_orig;
-typedef UINT (WINAPI *auxGetNumDevs_type)(void);
-extern auxGetNumDevs_type auxGetNumDevs_orig;
-typedef MMRESULT (WINAPI *auxGetDevCapsA_type)( UINT_PTR uDeviceID, LPAUXCAPSA pac, UINT cbac);
-extern auxGetDevCapsA_type auxGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *auxGetDevCapsW_type)( UINT_PTR uDeviceID, LPAUXCAPSW pac, UINT cbac);
-extern auxGetDevCapsW_type auxGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *auxSetVolume_type)( UINT uDeviceID, DWORD dwVolume);
-extern auxSetVolume_type auxSetVolume_orig;
-typedef MMRESULT (WINAPI *auxGetVolume_type)( UINT uDeviceID, LPDWORD pdwVolume);
-extern auxGetVolume_type auxGetVolume_orig;
-typedef MMRESULT (WINAPI *auxOutMessage_type)( UINT uDeviceID, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
-extern auxOutMessage_type auxOutMessage_orig;
-typedef UINT (WINAPI *mixerGetNumDevs_type)(void);
-extern mixerGetNumDevs_type mixerGetNumDevs_orig;
-typedef MMRESULT (WINAPI *mixerGetDevCapsA_type)( UINT_PTR uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps);
-extern mixerGetDevCapsA_type mixerGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *mixerGetDevCapsW_type)( UINT_PTR uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps);
-extern mixerGetDevCapsW_type mixerGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *mixerOpen_type)( LPHMIXER phmx, UINT uMxId, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
-extern mixerOpen_type mixerOpen_orig;
-typedef MMRESULT (WINAPI *mixerClose_type)( HMIXER hmx);
-extern mixerClose_type mixerClose_orig;
-typedef DWORD (WINAPI *mixerMessage_type)( HMIXER hmx, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
-extern mixerMessage_type mixerMessage_orig;
-typedef MMRESULT (WINAPI *mixerGetLineInfoA_type)( HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo);
-extern mixerGetLineInfoA_type mixerGetLineInfoA_orig;
-typedef MMRESULT (WINAPI *mixerGetLineInfoW_type)( HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo);
-extern mixerGetLineInfoW_type mixerGetLineInfoW_orig;
-typedef MMRESULT (WINAPI *mixerGetID_type)( HMIXEROBJ hmxobj, UINT FAR *puMxId, DWORD fdwId);
-extern mixerGetID_type mixerGetID_orig;
-typedef MMRESULT (WINAPI *mixerGetLineControlsA_type)( HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls);
-extern mixerGetLineControlsA_type mixerGetLineControlsA_orig;
-typedef MMRESULT (WINAPI *mixerGetLineControlsW_type)( HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls);
-extern mixerGetLineControlsW_type mixerGetLineControlsW_orig;
-typedef MMRESULT (WINAPI *mixerGetControlDetailsA_type)( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
-extern mixerGetControlDetailsA_type mixerGetControlDetailsA_orig;
-typedef MMRESULT (WINAPI *mixerGetControlDetailsW_type)( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
-extern mixerGetControlDetailsW_type mixerGetControlDetailsW_orig;
-typedef MMRESULT (WINAPI *mixerSetControlDetails_type)( HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
-extern mixerSetControlDetails_type mixerSetControlDetails_orig;
-typedef DWORD    (WINAPI *mmGetCurrentTask_type)(void);
-extern mmGetCurrentTask_type mmGetCurrentTask_orig;
-typedef void (WINAPI *mmTaskBlock_type)(DWORD);
-extern mmTaskBlock_type mmTaskBlock_orig;
-typedef UINT (WINAPI *mmTaskCreate_type)(LPTASKCALLBACK, HANDLE*, DWORD_PTR);
-extern mmTaskCreate_type mmTaskCreate_orig;
-typedef BOOL (WINAPI *mmTaskSignal_type)(DWORD);
-extern mmTaskSignal_type mmTaskSignal_orig;
-typedef VOID (WINAPI *mmTaskYield_type)(VOID);
-extern mmTaskYield_type mmTaskYield_orig;
-typedef MMRESULT (WINAPI *timeGetSystemTime_type)( LPMMTIME pmmt, UINT cbmmt);
-extern timeGetSystemTime_type timeGetSystemTime_orig;
-typedef DWORD (WINAPI *timeGetTime_type)(void);
-extern timeGetTime_type timeGetTime_orig;
-typedef MMRESULT (WINAPI *timeSetEvent_type)( UINT uDelay, UINT uResolution, LPTIMECALLBACK fptc, DWORD_PTR dwUser, UINT fuEvent);
-extern timeSetEvent_type timeSetEvent_orig;
-typedef MMRESULT (WINAPI *timeKillEvent_type)( UINT uTimerID);
-extern timeKillEvent_type timeKillEvent_orig;
-typedef MMRESULT (WINAPI *timeGetDevCaps_type)( LPTIMECAPS ptc, UINT cbtc);
-extern timeGetDevCaps_type timeGetDevCaps_orig;
-typedef MMRESULT (WINAPI *timeBeginPeriod_type)( UINT uPeriod);
-extern timeBeginPeriod_type timeBeginPeriod_orig;
-typedef MMRESULT (WINAPI *timeEndPeriod_type)( UINT uPeriod);
-extern timeEndPeriod_type timeEndPeriod_orig;
-typedef UINT (WINAPI *joyGetNumDevs_type)(void);
-extern joyGetNumDevs_type joyGetNumDevs_orig;
-typedef MMRESULT (WINAPI *joyConfigChanged_type)(DWORD dwFlags);
-extern joyConfigChanged_type joyConfigChanged_orig;
-typedef MMRESULT (WINAPI *joyGetDevCapsA_type)( UINT_PTR uJoyID, LPJOYCAPSA pjc, UINT cbjc);
-extern joyGetDevCapsA_type joyGetDevCapsA_orig;
-typedef MMRESULT (WINAPI *joyGetDevCapsW_type)( UINT_PTR uJoyID, LPJOYCAPSW pjc, UINT cbjc);
-extern joyGetDevCapsW_type joyGetDevCapsW_orig;
-typedef MMRESULT (WINAPI *joyGetPos_type)( UINT uJoyID, LPJOYINFO pji);
-extern joyGetPos_type joyGetPos_orig;
-typedef MMRESULT (WINAPI *joyGetPosEx_type)( UINT uJoyID, LPJOYINFOEX pji);
-extern joyGetPosEx_type joyGetPosEx_orig;
-typedef MMRESULT (WINAPI *joyGetThreshold_type)( UINT uJoyID, LPUINT puThreshold);
-extern joyGetThreshold_type joyGetThreshold_orig;
-typedef MMRESULT (WINAPI *joyReleaseCapture_type)( UINT uJoyID);
-extern joyReleaseCapture_type joyReleaseCapture_orig;
-typedef MMRESULT (WINAPI *joySetCapture_type)( HWND hwnd, UINT uJoyID, UINT uPeriod, BOOL fChanged);
-extern joySetCapture_type joySetCapture_orig;
-typedef MMRESULT (WINAPI *joySetThreshold_type)( UINT uJoyID, UINT uThreshold);
-extern joySetThreshold_type joySetThreshold_orig;
-typedef BOOL(WINAPI  *mciDriverNotify_type)(HANDLE hwndCallback, MCIDEVICEID uDeviceID, UINT uStatus);
-extern mciDriverNotify_type mciDriverNotify_orig;
-typedef UINT (WINAPI  *mciDriverYield_type)(UINT uDeviceID);
-extern mciDriverYield_type mciDriverYield_orig;
-typedef FOURCC (WINAPI *mmioStringToFOURCCA_type)( LPCSTR sz, UINT uFlags);
-extern mmioStringToFOURCCA_type mmioStringToFOURCCA_orig;
-typedef FOURCC (WINAPI *mmioStringToFOURCCW_type)( LPCWSTR sz, UINT uFlags);
-extern mmioStringToFOURCCW_type mmioStringToFOURCCW_orig;
-typedef LPMMIOPROC (WINAPI *mmioInstallIOProcA_type)( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags);
-extern mmioInstallIOProcA_type mmioInstallIOProcA_orig;
-typedef LPMMIOPROC (WINAPI *mmioInstallIOProcW_type)( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags);
-extern mmioInstallIOProcW_type mmioInstallIOProcW_orig;
-typedef HMMIO (WINAPI *mmioOpenA_type)( LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen);
-extern mmioOpenA_type mmioOpenA_orig;
-typedef HMMIO (WINAPI *mmioOpenW_type)( LPWSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen);
-extern mmioOpenW_type mmioOpenW_orig;
-typedef MMRESULT (WINAPI *mmioRenameA_type)( LPCSTR pszFileName, LPCSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename);
-extern mmioRenameA_type mmioRenameA_orig;
-typedef MMRESULT (WINAPI *mmioRenameW_type)( LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename);
-extern mmioRenameW_type mmioRenameW_orig;
-typedef MMRESULT (WINAPI *mmioClose_type)( HMMIO hmmio, UINT fuClose);
-extern mmioClose_type mmioClose_orig;
-typedef LONG (WINAPI *mmioRead_type)( HMMIO hmmio, HPSTR pch, LONG cch);
-extern mmioRead_type mmioRead_orig;
-typedef LONG (WINAPI *mmioWrite_type)( HMMIO hmmio, const char _huge* pch, LONG cch);
-extern mmioWrite_type mmioWrite_orig;
-typedef LONG (WINAPI *mmioSeek_type)( HMMIO hmmio, LONG lOffset, int iOrigin);
-extern mmioSeek_type mmioSeek_orig;
-typedef MMRESULT (WINAPI *mmioGetInfo_type)( HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuInfo);
-extern mmioGetInfo_type mmioGetInfo_orig;
-typedef MMRESULT (WINAPI *mmioSetInfo_type)( HMMIO hmmio, LPCMMIOINFO pmmioinfo, UINT fuInfo);
-extern mmioSetInfo_type mmioSetInfo_orig;
-typedef MMRESULT (WINAPI *mmioSetBuffer_type)( HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT fuBuffer);
-extern mmioSetBuffer_type mmioSetBuffer_orig;
-typedef MMRESULT (WINAPI *mmioFlush_type)( HMMIO hmmio, UINT fuFlush);
-extern mmioFlush_type mmioFlush_orig;
-typedef MMRESULT (WINAPI *mmioAdvance_type)( HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuAdvance);
-extern mmioAdvance_type mmioAdvance_orig;
-typedef LRESULT (WINAPI *mmioSendMessage_type)( HMMIO hmmio, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
-extern mmioSendMessage_type mmioSendMessage_orig;
-typedef MMRESULT (WINAPI *mmioDescend_type)( HMMIO hmmio, LPMMCKINFO pmmcki, const MMCKINFO FAR* pmmckiParent, UINT fuDescend);
-extern mmioDescend_type mmioDescend_orig;
-typedef MMRESULT (WINAPI *mmioAscend_type)( HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuAscend);
-extern mmioAscend_type mmioAscend_orig;
-typedef MMRESULT (WINAPI *mmioCreateChunk_type)(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuCreate);
-extern mmioCreateChunk_type mmioCreateChunk_orig;
-typedef MCIERROR (WINAPI *mciSendCommandA_type)( MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
-extern mciSendCommandA_type mciSendCommandA_orig;
-typedef MCIERROR (WINAPI *mciSendCommandW_type)( MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
-extern mciSendCommandW_type mciSendCommandW_orig;
-typedef MCIERROR  (WINAPI *mciSendStringA_type)( LPCSTR lpstrCommand, LPSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback);
-extern mciSendStringA_type mciSendStringA_orig;
-typedef MCIERROR  (WINAPI *mciSendStringW_type)( LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback);
-extern mciSendStringW_type mciSendStringW_orig;
-typedef MCIDEVICEID (WINAPI *mciGetDeviceIDA_type)( LPCSTR pszDevice);
-extern mciGetDeviceIDA_type mciGetDeviceIDA_orig;
-typedef MCIDEVICEID (WINAPI *mciGetDeviceIDW_type)( LPCWSTR pszDevice);
-extern mciGetDeviceIDW_type mciGetDeviceIDW_orig;
-typedef MCIDEVICEID (WINAPI *mciGetDeviceIDFromElementIDA_type)( DWORD dwElementID, LPCSTR lpstrType );
-extern mciGetDeviceIDFromElementIDA_type mciGetDeviceIDFromElementIDA_orig;
-typedef MCIDEVICEID (WINAPI *mciGetDeviceIDFromElementIDW_type)( DWORD dwElementID, LPCWSTR lpstrType );
-extern mciGetDeviceIDFromElementIDW_type mciGetDeviceIDFromElementIDW_orig;
-typedef DWORD_PTR (WINAPI  *mciGetDriverData_type)(UINT uDeviceID);
-extern mciGetDriverData_type mciGetDriverData_orig;
-typedef BOOL (WINAPI *mciGetErrorStringA_type)( MCIERROR mcierr, LPSTR pszText, UINT cchText);
-extern mciGetErrorStringA_type mciGetErrorStringA_orig;
-typedef BOOL (WINAPI *mciGetErrorStringW_type)( MCIERROR mcierr, LPWSTR pszText, UINT cchText);
-extern mciGetErrorStringW_type mciGetErrorStringW_orig;
-typedef BOOL (WINAPI  *mciSetDriverData_type)(UINT uDeviceID, DWORD_PTR dwData);
-extern mciSetDriverData_type mciSetDriverData_orig;
-typedef BOOL (WINAPI *mciSetYieldProc_type)( MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData);
-extern mciSetYieldProc_type mciSetYieldProc_orig;
-typedef BOOL (WINAPI  *mciFreeCommandResource_type)(UINT uTable);
-extern mciFreeCommandResource_type mciFreeCommandResource_orig;
-typedef HTASK (WINAPI *mciGetCreatorTask_type)( MCIDEVICEID mciId);
-extern mciGetCreatorTask_type mciGetCreatorTask_orig;
-typedef YIELDPROC (WINAPI *mciGetYieldProc_type)( MCIDEVICEID mciId, LPDWORD pdwYieldData);
-extern mciGetYieldProc_type mciGetYieldProc_orig;
-typedef UINT (WINAPI *mciLoadCommandResource_type)(HANDLE hInstance, LPCWSTR lpResName, UINT uType);
-extern mciLoadCommandResource_type mciLoadCommandResource_orig;
-typedef BOOL (WINAPI *mciExecute_type)(LPCSTR pszCommand);
-extern mciExecute_type mciExecute_orig;
diff --git a/indra/media_plugins/winmmshim/winmm.def b/indra/media_plugins/winmmshim/winmm.def
deleted file mode 100755
index c55a2845f8..0000000000
--- a/indra/media_plugins/winmmshim/winmm.def
+++ /dev/null
@@ -1,218 +0,0 @@
-; 
-;   winmm.def
-;
-;   Exports for WINMM DLL
-;
-
-LIBRARY WINMM
-EXPORTS
-CloseDriver
-DefDriverProc
-DriverCallback
-DrvGetModuleHandle
-GetDriverModuleHandle
-;MigrateAllDrivers
-;MigrateSoundEvents
-;NotifyCallbackData
-OpenDriver
-;PlaySound
-PlaySoundA
-PlaySoundW
-SendDriverMessage
-;WOW32DriverCallback
-;WOW32ResolveMultiMediaHandle
-;WOWAppExit
-;WinmmLogoff
-;WinmmLogon
-;aux32Message
-auxGetDevCapsA
-auxGetDevCapsW
-auxGetNumDevs
-auxGetVolume
-auxOutMessage
-auxSetVolume
-;gfxAddGfx
-;gfxBatchChange
-;gfxCreateGfxFactoriesList
-;gfxCreateZoneFactoriesList
-;gfxDestroyDeviceInterfaceList
-;gfxEnumerateGfxs
-;gfxLogoff
-;gfxLogon
-;gfxModifyGfx
-;gfxOpenGfx
-;gfxRemoveGfx
-;joy32Message
-joyConfigChanged
-joyGetDevCapsA
-joyGetDevCapsW
-joyGetNumDevs
-joyGetPos
-joyGetPosEx
-joyGetThreshold
-joyReleaseCapture
-joySetCapture
-joySetThreshold
-;mci32Message
-mciDriverNotify
-mciDriverYield
-mciExecute
-mciFreeCommandResource
-mciGetCreatorTask
-mciGetDeviceIDA
-mciGetDeviceIDFromElementIDA
-mciGetDeviceIDFromElementIDW
-mciGetDeviceIDW
-mciGetDriverData
-mciGetErrorStringA
-mciGetErrorStringW
-mciGetYieldProc
-mciLoadCommandResource
-mciSendCommandA
-mciSendCommandW
-mciSendStringA
-mciSendStringW
-mciSetDriverData
-mciSetYieldProc
-;mid32Message
-midiConnect
-midiDisconnect
-midiInAddBuffer
-midiInClose
-midiInGetDevCapsA
-midiInGetDevCapsW
-midiInGetErrorTextA
-midiInGetErrorTextW
-midiInGetID
-midiInGetNumDevs
-midiInMessage
-midiInOpen
-midiInPrepareHeader
-midiInReset
-midiInStart
-midiInStop
-midiInUnprepareHeader
-midiOutCacheDrumPatches
-midiOutCachePatches
-midiOutClose
-midiOutGetDevCapsA
-midiOutGetDevCapsW
-midiOutGetErrorTextA
-midiOutGetErrorTextW
-midiOutGetID
-midiOutGetNumDevs
-midiOutGetVolume
-midiOutLongMsg
-midiOutMessage
-midiOutOpen
-midiOutPrepareHeader
-midiOutReset
-midiOutSetVolume
-midiOutShortMsg
-midiOutUnprepareHeader
-midiStreamClose
-midiStreamOpen
-midiStreamOut
-midiStreamPause
-midiStreamPosition
-midiStreamProperty
-midiStreamRestart
-midiStreamStop
-mixerClose
-mixerGetControlDetailsA
-mixerGetControlDetailsW
-mixerGetDevCapsA
-mixerGetDevCapsW
-mixerGetID
-mixerGetLineControlsA
-mixerGetLineControlsW
-mixerGetLineInfoA
-mixerGetLineInfoW
-mixerGetNumDevs
-mixerMessage
-mixerOpen
-mixerSetControlDetails
-;mmDrvInstall
-mmGetCurrentTask
-mmTaskBlock
-mmTaskCreate
-mmTaskSignal
-mmTaskYield
-mmioAdvance
-mmioAscend
-mmioClose
-mmioCreateChunk
-mmioDescend
-mmioFlush
-mmioGetInfo
-mmioInstallIOProcA
-mmioInstallIOProcW
-mmioOpenA
-mmioOpenW
-mmioRead
-mmioRenameA
-mmioRenameW
-mmioSeek
-mmioSendMessage
-mmioSetBuffer
-mmioSetInfo
-mmioStringToFOURCCA
-mmioStringToFOURCCW
-mmioWrite
-mmsystemGetVersion
-;mod32Message
-;mxd32Message
-sndPlaySoundA
-sndPlaySoundW
-;tid32Message
-timeBeginPeriod
-timeEndPeriod
-timeGetDevCaps
-timeGetSystemTime
-timeGetTime
-timeKillEvent
-timeSetEvent
-waveInAddBuffer
-waveInClose
-waveInGetDevCapsA
-waveInGetDevCapsW
-waveInGetErrorTextA
-waveInGetErrorTextW
-waveInGetID
-waveInGetNumDevs
-waveInGetPosition
-waveInMessage
-waveInOpen
-waveInPrepareHeader
-waveInReset
-waveInStart
-waveInStop
-waveInUnprepareHeader
-waveOutBreakLoop
-waveOutClose
-waveOutGetDevCapsA
-waveOutGetDevCapsW
-waveOutGetErrorTextA
-waveOutGetErrorTextW
-waveOutGetID
-waveOutGetNumDevs
-waveOutGetPitch
-waveOutGetPlaybackRate
-waveOutGetPosition
-waveOutGetVolume
-waveOutMessage
-waveOutOpen
-waveOutPause
-waveOutPrepareHeader
-waveOutReset
-waveOutRestart
-waveOutSetPitch
-waveOutSetPlaybackRate
-waveOutSetVolume
-waveOutUnprepareHeader
-waveOutWrite
-;wid32Message
-;winmmSetDebugLevel
-;wod32Message
-setPluginVolume
-setPluginMute
\ No newline at end of file
diff --git a/indra/media_plugins/winmmshim/winmm_shim.cpp b/indra/media_plugins/winmmshim/winmm_shim.cpp
deleted file mode 100644
index 78f7a9b0da..0000000000
--- a/indra/media_plugins/winmmshim/winmm_shim.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/** 
- * @file winmmshim.cpp
- * @brief controls volume level of process by intercepting calls to winmm.dll
- *
- * $LicenseInfo:firstyear=2010&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010-2014, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-#include "forwarding_api.h"
-#include <xmmintrin.h>
-#include <map>
-#include <math.h>
-
-using std::wstring;
-
-static float sVolumeLevel = 1.f;		// Could be covered by critical section,
-static bool sMute = false;				// not needed with atomicity and alignment.
-static CRITICAL_SECTION sCriticalSection;
-
-BOOL APIENTRY DllMain( HMODULE hModule,
-                       DWORD  ul_reason_for_call,
-                       LPVOID lpReserved
-					 )
-{
-	if (ul_reason_for_call == DLL_PROCESS_ATTACH)
-	{
-		InitializeCriticalSection(&sCriticalSection);
-	}
-	return TRUE;
-}
-
-void ll_winmm_shim_initialize(){
-	static volatile bool initialized = false;
-
-	// do this only once using double-check locking
-	if (!initialized)
-	{
-		EnterCriticalSection(&sCriticalSection);
-		if (!initialized)
-		{	// bind to original winmm.dll
-			TCHAR system_path[MAX_PATH];
-			TCHAR dll_path[MAX_PATH];
-			::GetSystemDirectory(system_path, MAX_PATH);
-
-			// grab winmm.dll from system path, where it should live
-			wsprintf(dll_path, "%s\\winmm.dll", system_path);
-			HMODULE winmm_handle = ::LoadLibrary(dll_path);
-
-			if (winmm_handle != NULL)
-			{	// we have a dll, let's get out pointers!
-				init_function_pointers(winmm_handle);
-				::OutputDebugStringA("WINMM_SHIM.DLL: real winmm.dll initialized successfully\n");
-				initialized = true;		// Last thing after completing setup
-			}
-			else
-			{
-				// failed to initialize real winmm.dll
-				::OutputDebugStringA("WINMM_SHIM.DLL: Failed to initialize real winmm.dll\n");
-			}
-		}
-		LeaveCriticalSection(&sCriticalSection);
-	}
-}
-
-
-extern "C" 
-{
-	// tracks the requested format for a given waveout buffer
-	struct WaveOutFormat
-	{
-		WaveOutFormat(int bits_per_sample)
-		:	mBitsPerSample(bits_per_sample)
-		{}
-		int	mBitsPerSample;
-	};
-	typedef std::map<HWAVEOUT, WaveOutFormat*> wave_out_map_t;
-	static wave_out_map_t sWaveOuts;						// Covered by sCriticalSection
-
-	MMRESULT WINAPI waveOutOpen( LPHWAVEOUT phwo, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
-	{
-		ll_winmm_shim_initialize();
-		if (pwfx->wFormatTag != WAVE_FORMAT_PCM
-			|| (pwfx->wBitsPerSample != 8 && pwfx->wBitsPerSample != 16))
-		{ // uncompressed 8 and 16 bit sound are the only types we support
-			return WAVERR_BADFORMAT;
-		}
-
-		MMRESULT result = waveOutOpen_orig(phwo, uDeviceID, pwfx, dwCallback, dwInstance, fdwOpen);
-		if (result == MMSYSERR_NOERROR 
-			&& ((fdwOpen & WAVE_FORMAT_QUERY) == 0)) // not just querying for format support
-		{	// remember the requested bits per sample, and associate with the given handle
-			WaveOutFormat* wave_outp = new WaveOutFormat(pwfx->wBitsPerSample);
-			EnterCriticalSection(&sCriticalSection);
-			sWaveOuts.insert(std::make_pair(*phwo, wave_outp));
-			LeaveCriticalSection(&sCriticalSection);
-		}
-		return result;
-	}
-
-	MMRESULT WINAPI waveOutClose( HWAVEOUT hwo)
-	{
-		ll_winmm_shim_initialize();
-		EnterCriticalSection(&sCriticalSection);
-		wave_out_map_t::iterator found_it = sWaveOuts.find(hwo);
-		if (found_it != sWaveOuts.end())
-		{	// forget what we know about this handle
-			delete found_it->second;
-			sWaveOuts.erase(found_it);
-		}
-		LeaveCriticalSection(&sCriticalSection);
-		return waveOutClose_orig(hwo);
-	}
-
-	MMRESULT WINAPI waveOutWrite( HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
-	{
-		ll_winmm_shim_initialize();
-		MMRESULT result = MMSYSERR_NOERROR;
-
-		if (sMute)
-		{ // zero out the audio buffer when muted
-			memset(pwh->lpData, 0, pwh->dwBufferLength);
-		}
-		else if (sVolumeLevel != 1.f) 
-		{ // need to apply volume level
-			int bits_per_sample(0);
-			
-			EnterCriticalSection(&sCriticalSection);
-			wave_out_map_t::iterator found_it = sWaveOuts.find(hwo);
-			if (found_it != sWaveOuts.end())
-			{
-				bits_per_sample = found_it->second->mBitsPerSample;
-			}
-			LeaveCriticalSection(&sCriticalSection);
-			if (bits_per_sample)
-			{
-				switch (bits_per_sample)
-				{
-				case 8:
-					{
-						char volume = (char)(sVolumeLevel * 127.f);
-						for (unsigned int i = 0; i < pwh->dwBufferLength; i++)
-						{
-							// unsigned multiply doesn't use most significant bit, so shift by 7 bits
-							// to get resulting value back into 8 bits
-							pwh->lpData[i] = (pwh->lpData[i] * volume) >> 7;
-						}
-						break;
-					}
-				case 16:
-					{
-						short volume_16 = (short)(sVolumeLevel * 32767.f);
-
-						// copy volume level 4 times into 64 bit MMX register
-						__m64 volume_64 = _mm_set_pi16(volume_16, volume_16, volume_16, volume_16);
-						__m64* sample_64;
-						__m64* last_sample_64 =  (__m64*)(pwh->lpData + pwh->dwBufferLength - sizeof(__m64));
-						// for everything that can be addressed in 64 bit multiples...
-						for (sample_64 = (__m64*)pwh->lpData;
-							sample_64 <= last_sample_64;
-							++sample_64)
-						{
-							//...multiply the samples by the volume...
-							__m64 scaled_sample = _mm_mulhi_pi16(*sample_64, volume_64);
-							// ...and shift left 1 bit since an unsigned multiple loses the most significant bit
-							// 0x7FFF * 0x7FFF = 0x3fff0001
-							// 0x3fff0001 << 1 = 0x7ffe0002
-							// notice that the LSB is always 0...should consider dithering
-							*sample_64 =  _mm_slli_pi16(scaled_sample, 1); 
-						}
-
-						// the captain has turned off the MMX sign, you are now free to use floating point registers
-						_mm_empty();
-
-						// finish remaining samples that didn't fit into 64 bit register
-						for (short* sample_16 = (short*)sample_64;
-							sample_16 < (short*)(pwh->lpData + pwh->dwBufferLength);
-							++sample_16)
-						{	
-							*sample_16 = (*sample_16 * volume_16) >> 15;
-						}
-
-						break;
-					}
-				default:
-					// don't do anything
-					break;
-				}
-			}
-		}
-		return waveOutWrite_orig( hwo, pwh, cbwh);
-	}
-
-	void WINAPI setPluginVolume(float volume)
-	{
-		sVolumeLevel = volume;
-	}
-
-	void WINAPI setPluginMute(bool mute)
-	{
-		sMute = mute;
-	}
-}