1 files changed, 477 insertions, 0 deletions

diff --git a/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
new file mode 100644
index 0000000..c4c4181
--- /dev/null
+++ b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
@@ -0,0 +1,477 @@
+/** 
+ * @file linux_volume_catcher.cpp
+ * @brief A Linux-specific, PulseAudio-specific hack to detect and volume-adjust new audio sources
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/*
+  The high-level design is as follows:
+  1) Connect to the PulseAudio daemon
+  2) Watch for the creation of new audio players connecting to the daemon (this includes ALSA clients running on the PulseAudio emulation layer, such as Flash plugins)
+  3) Examine any new audio player's PID to see if it belongs to our own process
+  4) If so, tell PA to adjust the volume of that audio player ('sink input' in PA parlance)
+  5) Keep a list of all living audio players that we care about, adjust the volumes of all of them when we get a new setVolume() call
+ */
+
+# include <set> //imprudence
+
+#include "linden_common.h"
+
+#include "volume_catcher.h"
+
+
+extern "C" {
+#include <glib.h>
+#include <glib-object.h>
+
+#include <pulse/introspect.h>
+#include <pulse/context.h>
+#include <pulse/subscribe.h>
+#include <pulse/glib-mainloop.h> // There's no special reason why we want the *glib* PA mainloop, but the generic polling implementation seems broken.
+
+#include "apr_pools.h"
+#include "apr_dso.h"
+}
+
+////////////////////////////////////////////////////
+
+#define DEBUGMSG(...) do {} while(0)
+#define INFOMSG(...) do {} while(0)
+#define WARNMSG(...) do {} while(0)
+
+#define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) RTN (*ll##PASYM)(__VA_ARGS__) = NULL
+#include "linux_volume_catcher_pa_syms.inc"
+#include "linux_volume_catcher_paglib_syms.inc"
+#undef LL_PA_SYM
+
+static bool sSymsGrabbed = false;
+static apr_pool_t *sSymPADSOMemoryPool = NULL;
+static apr_dso_handle_t *sSymPADSOHandleG = NULL;
+
+bool grab_pa_syms(std::string pulse_dso_name)
+{
+        if (sSymsGrabbed)
+        {
+                // already have grabbed good syms
+                return true;
+        }
+
+        bool sym_error = false;
+        bool rtn = false;
+        apr_status_t rv;
+        apr_dso_handle_t *sSymPADSOHandle = NULL;
+
+#define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##PASYM, sSymPADSOHandle, #PASYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #PASYM); if (REQUIRED) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #PASYM, (void*)ll##PASYM);}while(0)
+
+        //attempt to load the shared library
+        apr_pool_create(&sSymPADSOMemoryPool, NULL);
+  
+        if ( APR_SUCCESS == (rv = apr_dso_load(&sSymPADSOHandle,
+                                               pulse_dso_name.c_str(),
+                                               sSymPADSOMemoryPool) ))
+        {
+                INFOMSG("Found DSO: %s", pulse_dso_name.c_str());
+
+#include "linux_volume_catcher_pa_syms.inc"
+#include "linux_volume_catcher_paglib_syms.inc"
+      
+                if ( sSymPADSOHandle )
+                {
+                        sSymPADSOHandleG = sSymPADSOHandle;
+                        sSymPADSOHandle = NULL;
+                }
+      
+                rtn = !sym_error;
+        }
+        else
+        {
+                INFOMSG("Couldn't load DSO: %s", pulse_dso_name.c_str());
+                rtn = false; // failure
+        }
+
+        if (sym_error)
+        {
+                WARNMSG("Failed to find necessary symbols in PulseAudio libraries.");
+        }
+#undef LL_PA_SYM
+
+        sSymsGrabbed = rtn;
+        return rtn;
+}
+
+
+void ungrab_pa_syms()
+{ 
+        // should be safe to call regardless of whether we've
+        // actually grabbed syms.
+
+        if ( sSymPADSOHandleG )
+        {
+                apr_dso_unload(sSymPADSOHandleG);
+                sSymPADSOHandleG = NULL;
+        }
+        
+        if ( sSymPADSOMemoryPool )
+        {
+                apr_pool_destroy(sSymPADSOMemoryPool);
+                sSymPADSOMemoryPool = NULL;
+        }
+        
+        // NULL-out all of the symbols we'd grabbed
+#define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{ll##PASYM = NULL;}while(0)
+#include "linux_volume_catcher_pa_syms.inc"
+#include "linux_volume_catcher_paglib_syms.inc"
+#undef LL_PA_SYM
+
+        sSymsGrabbed = false;
+}
+////////////////////////////////////////////////////
+
+// PulseAudio requires a chain of callbacks with C linkage
+extern "C" {
+        void callback_discovered_sinkinput(pa_context *context, const pa_sink_input_info *i, int eol, void *userdata);
+        void callback_subscription_alert(pa_context *context, pa_subscription_event_type_t t, uint32_t index, void *userdata);
+        void callback_context_state(pa_context *context, void *userdata);
+}
+
+
+class VolumeCatcherImpl
+{
+public:
+        VolumeCatcherImpl();
+        ~VolumeCatcherImpl();
+
+        void setVolume(F32 volume);
+        void pump(void);
+
+        // for internal use - can't be private because used from our C callbacks
+
+        bool loadsyms(std::string pulse_dso_name);
+        void init();
+        void cleanup();
+
+        void update_all_volumes(F32 volume);
+        void update_index_volume(U32 index, F32 volume);
+        void connected_okay();
+
+        std::set<U32> mSinkInputIndices;
+        std::map<U32,U32> mSinkInputNumChannels;
+        F32 mDesiredVolume;
+        pa_glib_mainloop *mMainloop;
+        pa_context *mPAContext;
+        bool mConnected;
+        bool mGotSyms;
+};
+
+VolumeCatcherImpl::VolumeCatcherImpl()
+        : mDesiredVolume(0.0f),
+          mMainloop(NULL),
+          mPAContext(NULL),
+          mConnected(false),
+          mGotSyms(false)
+{
+        init();
+}
+
+VolumeCatcherImpl::~VolumeCatcherImpl()
+{
+        cleanup();
+}
+
+bool VolumeCatcherImpl::loadsyms(std::string pulse_dso_name)
+{
+        return grab_pa_syms(pulse_dso_name);
+}
+
+void VolumeCatcherImpl::init()
+{
+        // try to be as defensive as possible because PA's interface is a
+        // bit fragile and (for our purposes) we'd rather simply not function
+        // than crash
+
+        // we cheat and rely upon libpulse-mainloop-glib.so.0 to pull-in
+        // libpulse.so.0 - this isn't a great assumption, and the two DSOs should
+        // probably be loaded separately.  Our Linux DSO framework needs refactoring,
+        // we do this sort of thing a lot with practically identical logic...
+        mGotSyms = loadsyms("libpulse-mainloop-glib.so.0");
+        if (!mGotSyms) return;
+
+        // better make double-sure glib itself is initialized properly.
+        if (!g_thread_supported ()) g_thread_init (NULL);
+        g_type_init();
+
+        mMainloop = llpa_glib_mainloop_new(g_main_context_default());
+        if (mMainloop)
+        {
+                pa_mainloop_api *api = llpa_glib_mainloop_get_api(mMainloop);
+                if (api)
+                {
+                        pa_proplist *proplist = llpa_proplist_new();
+                        if (proplist)
+                        {
+                                llpa_proplist_sets(proplist, PA_PROP_APPLICATION_ICON_NAME, "multimedia-player");
+                                llpa_proplist_sets(proplist, PA_PROP_APPLICATION_ID, "com.secondlife.viewer.mediaplugvoladjust");
+                                llpa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, "SL Plugin Volume Adjuster");
+                                llpa_proplist_sets(proplist, PA_PROP_APPLICATION_VERSION, "1");
+
+                                // plain old pa_context_new() is broken!
+                                mPAContext = llpa_context_new_with_proplist(api, NULL, proplist);
+                                llpa_proplist_free(proplist);
+                        }
+                }
+        }
+
+        // Now we've set up a PA context and mainloop, try connecting the
+        // PA context to a PA daemon.
+        if (mPAContext)
+        {
+                llpa_context_set_state_callback(mPAContext, callback_context_state, this);
+                pa_context_flags_t cflags = (pa_context_flags)0; // maybe add PA_CONTEXT_NOAUTOSPAWN?
+                if (llpa_context_connect(mPAContext, NULL, cflags, NULL) >= 0)
+                {
+                        // Okay!  We haven't definitely connected, but we
+                        // haven't definitely failed yet.
+                }
+                else
+                {
+                        // Failed to connect to PA manager... we'll leave
+                        // things like that.  Perhaps we should try again later.
+                }
+        }
+}
+
+void VolumeCatcherImpl::cleanup()
+{
+        mConnected = false;
+
+        if (mGotSyms && mPAContext)
+        {
+                llpa_context_disconnect(mPAContext);
+                llpa_context_unref(mPAContext);
+        }
+        mPAContext = NULL;
+
+        if (mGotSyms && mMainloop)
+        {
+                llpa_glib_mainloop_free(mMainloop);
+        }
+        mMainloop = NULL;
+}
+
+void VolumeCatcherImpl::setVolume(F32 volume)
+{
+        mDesiredVolume = volume;
+        
+        if (!mGotSyms) return;
+
+        if (mConnected && mPAContext)
+        {
+                update_all_volumes(mDesiredVolume);
+        }
+
+        pump();
+}
+
+void VolumeCatcherImpl::pump()
+{
+        gboolean may_block = FALSE;
+        g_main_context_iteration(g_main_context_default(), may_block);
+}
+
+void VolumeCatcherImpl::connected_okay()
+{
+        pa_operation *op;
+
+        // fetch global list of existing sinkinputs
+        if ((op = llpa_context_get_sink_input_info_list(mPAContext,
+                                                        callback_discovered_sinkinput,
+                                                        this)))
+        {
+                llpa_operation_unref(op);
+        }
+
+        // subscribe to future global sinkinput changes
+        llpa_context_set_subscribe_callback(mPAContext,
+                                            callback_subscription_alert,
+                                            this);
+        if ((op = llpa_context_subscribe(mPAContext, (pa_subscription_mask_t)
+                                         (PA_SUBSCRIPTION_MASK_SINK_INPUT),
+                                         NULL, NULL)))
+        {
+                llpa_operation_unref(op);
+        }
+}
+
+void VolumeCatcherImpl::update_all_volumes(F32 volume)
+{
+        for (std::set<U32>::iterator it = mSinkInputIndices.begin();
+             it != mSinkInputIndices.end(); ++it)
+        {
+                update_index_volume(*it, volume);
+        }
+}
+
+void VolumeCatcherImpl::update_index_volume(U32 index, F32 volume)
+{
+        static pa_cvolume cvol;
+        llpa_cvolume_set(&cvol, mSinkInputNumChannels[index],
+                         llpa_sw_volume_from_linear(volume));
+        
+        pa_context *c = mPAContext;
+        uint32_t idx = index;
+        const pa_cvolume *cvolumep = &cvol;
+        pa_context_success_cb_t cb = NULL; // okay as null
+        void *userdata = NULL; // okay as null
+
+        pa_operation *op;
+        if ((op = llpa_context_set_sink_input_volume(c, idx, cvolumep, cb, userdata)))
+        {
+                llpa_operation_unref(op);
+        }
+}
+
+
+void callback_discovered_sinkinput(pa_context *context, const pa_sink_input_info *sii, int eol, void *userdata)
+{
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
+        llassert(impl);
+
+        if (0 == eol)
+        {
+                pa_proplist *proplist = sii->proplist;
+                pid_t sinkpid = atoll(llpa_proplist_gets(proplist, PA_PROP_APPLICATION_PROCESS_ID));
+                
+                if (sinkpid == getpid()) // does the discovered sinkinput belong to this process?
+                {
+                        bool is_new = (impl->mSinkInputIndices.find(sii->index) ==
+                                       impl->mSinkInputIndices.end());
+                        
+                        impl->mSinkInputIndices.insert(sii->index);
+                        impl->mSinkInputNumChannels[sii->index] = sii->channel_map.channels;
+                        
+                        if (is_new)
+                        {
+                                // new!
+                                impl->update_index_volume(sii->index, impl->mDesiredVolume);
+                        }
+                        else
+                        {
+                                // seen it already, do nothing.
+                        }
+                }
+        }
+}
+
+void callback_subscription_alert(pa_context *context, pa_subscription_event_type_t t, uint32_t index, void *userdata)
+{
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
+        llassert(impl);
+
+        switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
+        case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
+                if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+                    PA_SUBSCRIPTION_EVENT_REMOVE)
+                {
+                        // forget this sinkinput, if we were caring about it
+                        impl->mSinkInputIndices.erase(index);
+                        impl->mSinkInputNumChannels.erase(index);
+                }
+                else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+                         PA_SUBSCRIPTION_EVENT_NEW)
+                {
+                        // ask for more info about this new sinkinput
+                        pa_operation *op;
+                        if ((op = llpa_context_get_sink_input_info(impl->mPAContext, index, callback_discovered_sinkinput, impl)))
+                        {
+                                llpa_operation_unref(op);
+                        }
+                }
+                else
+                {
+                        // property change on this sinkinput - we don't care.
+                }
+                break;
+                
+        default:;
+        }
+}
+
+void callback_context_state(pa_context *context, void *userdata)
+{
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
+        llassert(impl);
+        
+        switch (llpa_context_get_state(context))
+        {
+        case PA_CONTEXT_READY:
+                impl->mConnected = true;
+                impl->connected_okay();
+                break;
+        case PA_CONTEXT_TERMINATED:
+                impl->mConnected = false;
+                break;
+        case PA_CONTEXT_FAILED:
+                impl->mConnected = false;
+                break;
+        default:;
+        }
+}
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+        pimpl = new VolumeCatcherImpl();
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+        delete pimpl;
+        pimpl = NULL;
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+        llassert(pimpl);
+        pimpl->setVolume(volume);
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+        // TODO: implement this (if possible)
+}
+
+void VolumeCatcher::pump()
+{
+        llassert(pimpl);
+        pimpl->pump();
+}