Apertura del repositorio

indra/media_plugins/cef/CMakeLists.txt

@@ -0,0 +1,105 @@
+# -*- cmake -*-
+
+project(media_plugin_cef)
+
+include(Boost)
+include(00-Common)
+include(LLCommon)
+include(LLWindow)
+include(Linking)
+include(PluginAPI)
+# include(MediaPluginBase)   # disable Linux volume catcher for the time being
+
+include(CEFPlugin)
+
+
+### media_plugin_cef
+
+if(NOT ADDRESS_SIZE EQUAL 32)
+  if(WINDOWS)
+    ##add_definitions(/FIXED:NO)
+  else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
+    add_definitions(-fPIC)
+  endif(WINDOWS)
+endif(NOT ADDRESS_SIZE EQUAL 32)
+
+set(media_plugin_cef_SOURCE_FILES
+    media_plugin_cef.cpp
+    )
+
+set(media_plugin_cef_HEADER_FILES
+    volume_catcher.h
+    )
+
+add_compile_definitions(LL_VOLUME_CATCHER)
+
+# 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.")
+  if(NOT LINUX_VOLUME_CATCHER)
+    set(LINUX_VOLUME_CATCHER dummy_volume_catcher.cpp)
+    message( "Building with dummy volume catcher" )
+  endif(NOT LINUX_VOLUME_CATCHER)
+
+  list(APPEND media_plugin_cef_SOURCE_FILES ${LINUX_VOLUME_CATCHER})
+  set(CMAKE_SHARED_LINKER_FLAGS  "-Wl,--build-id -Wl,-rpath,'$ORIGIN:$ORIGIN/../../lib'")
+  list(APPEND media_plugin_cef_LINK_LIBRARIES llwindow ${MEDIA_PLUGIN_BASE_LIBRARIES})
+elseif (DARWIN)
+  list(APPEND media_plugin_cef_SOURCE_FILES mac_volume_catcher_null.cpp)
+  find_library(CORESERVICES_LIBRARY CoreServices)
+  find_library(AUDIOUNIT_LIBRARY AudioUnit)
+  set( media_plugin_cef_LINK_LIBRARIES
+       ${CORESERVICES_LIBRARY}     # for Component Manager calls
+       ${AUDIOUNIT_LIBRARY}        # for AudioUnit calls
+       )
+elseif (WINDOWS)
+  list(APPEND media_plugin_cef_SOURCE_FILES windows_volume_catcher.cpp)
+endif (LINUX)
+
+list(APPEND media_plugin_cef_SOURCE_FILES ${media_plugin_cef_HEADER_FILES})
+
+add_library(media_plugin_cef
+    SHARED
+    ${media_plugin_cef_SOURCE_FILES}
+    )
+
+#add_dependencies(media_plugin_cef
+#  ${MEDIA_PLUGIN_BASE_LIBRARIES}
+#)
+
+
+target_link_libraries(media_plugin_cef
+        media_plugin_base
+        ll::cef
+)
+
+if (WINDOWS)
+  set_target_properties(
+    media_plugin_cef
+    PROPERTIES
+    LINK_FLAGS "/MANIFEST:NO /NODEFAULTLIB:LIBCMT /IGNORE:4099"
+    )
+endif (WINDOWS)
+
+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_cef
+    PROPERTIES
+    PREFIX ""
+    BUILD_WITH_INSTALL_RPATH 1
+    INSTALL_NAME_DIR "@executable_path"
+    CXX_FLAGS "-std=c++11 -stdlib=libc++"
+    LINK_FLAGS "-stdlib=libc++ -exported_symbols_list ${CMAKE_CURRENT_SOURCE_DIR}/../base/media_plugin_base.exp"
+  )
+
+  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"
+        "$<TARGET_FILE:media_plugin_cef>"
+    VERBATIM
+    COMMENT "Fixing path to CEF Framework"
+  )
+
+endif (DARWIN)

indra/media_plugins/cef/dummy_volume_catcher.cpp

@@ -0,0 +1,57 @@
+/**
+ * @file dummy_volume_catcher.cpp
+ * @brief A null implementation of the "VolumeCatcher" class for platforms where it's not implemented yet.
+ *
+ * @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"
+
+
+class VolumeCatcherImpl
+{
+};
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+    pimpl = NULL;
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+}
+
+void VolumeCatcher::pump()
+{
+}

indra/media_plugins/cef/linux_volume_catcher.cpp

@@ -0,0 +1,512 @@
+/**
+ * @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=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
+ */
+
+/*
+  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 "linden_common.h"
+
+#include "volume_catcher.h"
+
+
+extern "C" {
+#include <pulse/introspect.h>
+#include <pulse/context.h>
+#include <pulse/subscribe.h>
+
+#include <pulse/mainloop.h>
+
+#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"
+#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) { if (REQUIRED) sym_error = true;} } 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"
+
+        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"
+#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_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
+
+    mGotSyms = loadsyms("libpulse.so.0");
+    if (!mGotSyms) return;
+
+    mMainloop = llpa_mainloop_new();
+
+    if (mMainloop)
+    {
+        pa_mainloop_api *api = llpa_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_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()
+{
+    // <FS:Beq> PR#17 makidoll: Fix Linux volume catcher
+    if (mGotSyms && mMainloop) {
+        llpa_mainloop_iterate(mMainloop, 0, NULL);
+    }
+    // </FS:Beq>
+}
+
+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);
+    }
+}
+
+pid_t getParentPid( pid_t aPid )
+{
+    std::stringstream strm;
+    strm << "/proc/" << aPid << "/status";
+    std::ifstream in{ strm.str() };
+
+    if( !in.is_open() )
+        return 0;
+
+    pid_t res {0};
+    while( !in.eof() && res == 0 )
+    {
+        std::string line;
+        line.resize( 1024, 0 );
+        in.getline( &line[0], line.length() );
+
+        auto i = line.find( "PPid:"  );
+
+        if( i == std::string::npos )
+            continue;
+
+        char const *pIn = line.c_str() + 5; // Skip over pid;
+        while( *pIn != 0 && isspace( *pIn ) )
+               ++pIn;
+
+        if( *pIn )
+            res = atoll( pIn );
+    }
+    return res;
+}
+
+
+bool isPluginPid( pid_t aPid )
+{
+    auto myPid = getpid();
+
+    do
+    {
+        if( aPid == myPid )
+            return true;
+        aPid = getParentPid( aPid );
+    } while( aPid > 1 );
+
+    return false;
+}
+
+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;
+        const char* str = llpa_proplist_gets(proplist, PA_PROP_APPLICATION_PROCESS_ID);
+        if (!str)
+        {
+            return;
+        }
+
+        pid_t sinkpid = atoll(str);
+
+        if (isPluginPid( sinkpid )) // 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();
+}

indra/media_plugins/cef/linux_volume_catcher_pa_syms.inc

@@ -0,0 +1,26 @@
+// required symbols to grab
+LL_PA_SYM(true, pa_context_connect, int, pa_context *c, const char *server, pa_context_flags_t flags, const pa_spawn_api *api);
+LL_PA_SYM(true, pa_context_disconnect, void, pa_context *c);
+LL_PA_SYM(true, pa_context_get_sink_input_info, pa_operation*, pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_get_sink_input_info_list, pa_operation*, pa_context *c, pa_sink_input_info_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_get_state, pa_context_state_t, pa_context *c);
+LL_PA_SYM(true, pa_context_new_with_proplist, pa_context*, pa_mainloop_api *mainloop, const char *name, pa_proplist *proplist);
+LL_PA_SYM(true, pa_context_set_sink_input_volume, pa_operation*, pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_set_state_callback, void, pa_context *c, pa_context_notify_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_set_subscribe_callback, void, pa_context *c, pa_context_subscribe_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_subscribe, pa_operation*, pa_context *c, pa_subscription_mask_t m, pa_context_success_cb_t cb, void *userdata);
+LL_PA_SYM(true, pa_context_unref, void, pa_context *c);
+LL_PA_SYM(true, pa_cvolume_set, pa_cvolume*, pa_cvolume *a, unsigned channels, pa_volume_t v);
+LL_PA_SYM(true, pa_operation_unref, void, pa_operation *o);
+LL_PA_SYM(true, pa_proplist_free, void, pa_proplist* p);
+LL_PA_SYM(true, pa_proplist_gets, const char*, pa_proplist *p, const char *key);
+LL_PA_SYM(true, pa_proplist_new, pa_proplist*, void);
+LL_PA_SYM(true, pa_proplist_sets, int, pa_proplist *p, const char *key, const char *value);
+LL_PA_SYM(true, pa_sw_volume_from_linear, pa_volume_t, double v);
+
+LL_PA_SYM(true, pa_mainloop_free, void, pa_mainloop* m);
+LL_PA_SYM(true, pa_mainloop_get_api, pa_mainloop_api*, pa_mainloop* m);
+LL_PA_SYM(true, pa_mainloop_new, pa_mainloop*, void);
+LL_PA_SYM(true, pa_mainloop_iterate, int, pa_mainloop*, int, int*);
+
+// optional symbols to grab

indra/media_plugins/cef/linux_volume_catcher_paglib_syms.inc

@@ -0,0 +1,9 @@
+// <FS:Zi> No longer needed
+/*
+// required symbols to grab
+LL_PA_SYM(true, pa_glib_mainloop_free, void, pa_glib_mainloop* g);
+LL_PA_SYM(true, pa_glib_mainloop_get_api, pa_mainloop_api*, pa_glib_mainloop* g);
+LL_PA_SYM(true, pa_glib_mainloop_new, pa_glib_mainloop *, GMainContext *c);
+
+// optional symbols to grab
+*/

indra/media_plugins/cef/mac_volume_catcher.cpp

@@ -0,0 +1,275 @@
+/**
+ * @file mac_volume_catcher.cpp
+ * @brief A macOS specific hack to control the volume level of all audio channels opened by a process.
+ *
+ * @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
+ */
+
+/**************************************************************************************************************
+    This code works by using CaptureComponent to capture the "Default Output" audio component
+    (kAudioUnitType_Output/kAudioUnitSubType_DefaultOutput) and delegating all calls to the original component.
+    It does this just to keep track of all instances of the default output component, so that it can set the
+    kHALOutputParam_Volume parameter on all of them to adjust the output volume.
+**************************************************************************************************************/
+
+#include "volume_catcher.h"
+
+#include <QuickTime/QuickTime.h>
+#include <AudioUnit/AudioUnit.h>
+#include <list>
+
+#if LL_DARWIN
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+struct VolumeCatcherStorage;
+
+class VolumeCatcherImpl
+{
+public:
+
+    void setVolume(F32 volume);
+    void setPan(F32 pan);
+
+    void setInstanceVolume(VolumeCatcherStorage *instance);
+
+    std::list<VolumeCatcherStorage*> mComponentInstances;
+    Component mOriginalDefaultOutput;
+    Component mVolumeAdjuster;
+
+    static VolumeCatcherImpl *getInstance();
+private:
+    // This is a singleton class -- both callers and the component implementation should use getInstance() to find the instance.
+    VolumeCatcherImpl();
+    static VolumeCatcherImpl *sInstance;
+
+    // The singlar instance of this class is expected to last until the process exits.
+    // To ensure this, we declare the destructor here but never define it, so any code which attempts to destroy the instance will not link.
+    ~VolumeCatcherImpl();
+
+    F32 mVolume;
+    F32 mPan;
+};
+
+VolumeCatcherImpl *VolumeCatcherImpl::sInstance = NULL;;
+
+struct VolumeCatcherStorage
+{
+    ComponentInstance self;
+    ComponentInstance delegate;
+};
+
+static ComponentResult volume_catcher_component_entry(ComponentParameters *cp, Handle componentStorage);
+static ComponentResult volume_catcher_component_open(VolumeCatcherStorage *storage, ComponentInstance self);
+static ComponentResult volume_catcher_component_close(VolumeCatcherStorage *storage, ComponentInstance self);
+
+VolumeCatcherImpl *VolumeCatcherImpl::getInstance()
+{
+    if(!sInstance)
+    {
+        sInstance = new VolumeCatcherImpl;
+    }
+
+    return sInstance;
+}
+
+VolumeCatcherImpl::VolumeCatcherImpl()
+{
+    mVolume = 1.0;  // default to full volume
+    mPan = 0.0;     // and center pan
+
+    ComponentDescription desc;
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+    desc.componentFlags = 0;
+    desc.componentFlagsMask = 0;
+
+    // Find the original default output component
+    mOriginalDefaultOutput = FindNextComponent(NULL, &desc);
+
+    // Register our own output component with the same parameters
+    mVolumeAdjuster = RegisterComponent(&desc, NewComponentRoutineUPP(volume_catcher_component_entry), 0, NULL, NULL, NULL);
+
+    // Capture the original component, so we always get found instead.
+    CaptureComponent(mOriginalDefaultOutput, mVolumeAdjuster);
+
+}
+
+static ComponentResult volume_catcher_component_entry(ComponentParameters *cp, Handle componentStorage)
+{
+    ComponentResult result = badComponentSelector;
+    VolumeCatcherStorage *storage = (VolumeCatcherStorage*)componentStorage;
+
+    switch(cp->what)
+    {
+        case kComponentOpenSelect:
+//          std::cerr << "kComponentOpenSelect" << std::endl;
+            result = CallComponentFunctionWithStorageProcInfo((Handle)storage, cp, (ProcPtr)volume_catcher_component_open, uppCallComponentOpenProcInfo);
+        break;
+
+        case kComponentCloseSelect:
+//          std::cerr << "kComponentCloseSelect" << std::endl;
+            result = CallComponentFunctionWithStorageProcInfo((Handle)storage, cp, (ProcPtr)volume_catcher_component_close, uppCallComponentCloseProcInfo);
+            // CallComponentFunctionWithStorageProcInfo
+        break;
+
+        default:
+//          std::cerr << "Delegating selector: " << cp->what << " to component instance " << storage->delegate << std::endl;
+            result = DelegateComponentCall(cp, storage->delegate);
+        break;
+    }
+
+    return result;
+}
+
+static ComponentResult volume_catcher_component_open(VolumeCatcherStorage *storage, ComponentInstance self)
+{
+    ComponentResult result = noErr;
+    VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();
+
+    storage = new VolumeCatcherStorage;
+
+    storage->self = self;
+    storage->delegate = NULL;
+
+    result = OpenAComponent(impl->mOriginalDefaultOutput, &(storage->delegate));
+
+    if(result != noErr)
+    {
+//      std::cerr << "OpenAComponent result = " << result << ", component ref = " << storage->delegate << std::endl;
+
+        // If we failed to open the delagate component, our open is going to fail.  Clean things up.
+        delete storage;
+    }
+    else
+    {
+        // Success -- set up this component's storage
+        SetComponentInstanceStorage(self, (Handle)storage);
+
+        // add this instance to the global list
+        impl->mComponentInstances.push_back(storage);
+
+        // and set up the initial volume
+        impl->setInstanceVolume(storage);
+    }
+
+    return result;
+}
+
+static ComponentResult volume_catcher_component_close(VolumeCatcherStorage *storage, ComponentInstance self)
+{
+    ComponentResult result = noErr;
+
+    if(storage)
+    {
+        if(storage->delegate)
+        {
+            CloseComponent(storage->delegate);
+            storage->delegate = NULL;
+        }
+
+        VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();
+        impl->mComponentInstances.remove(storage);
+        delete[] storage;
+    }
+
+    return result;
+}
+
+void VolumeCatcherImpl::setVolume(F32 volume)
+{
+    VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();
+    impl->mVolume = volume;
+
+    // Iterate through all known instances, setting the volume on each.
+    for(std::list<VolumeCatcherStorage*>::iterator iter = mComponentInstances.begin(); iter != mComponentInstances.end(); ++iter)
+    {
+        impl->setInstanceVolume(*iter);
+    }
+}
+
+void VolumeCatcherImpl::setPan(F32 pan)
+{
+    VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();
+    impl->mPan = pan;
+
+    // TODO: implement this.
+    // This will probably require adding a "panner" audio unit to the chain somehow.
+    // There's also a "3d mixer" component that we might be able to use...
+}
+
+void VolumeCatcherImpl::setInstanceVolume(VolumeCatcherStorage *instance)
+{
+//  std::cerr << "Setting volume on component instance: " << (instance->delegate) << " to " << mVolume << std::endl;
+
+    OSStatus err = noErr;
+
+    if(instance && instance->delegate)
+    {
+        err = AudioUnitSetParameter(
+                instance->delegate,
+                kHALOutputParam_Volume,
+                kAudioUnitScope_Global,
+                0,
+                mVolume,
+                0);
+    }
+
+    if(err)
+    {
+//      std::cerr << "    AudioUnitSetParameter returned " << err << std::endl;
+    }
+}
+
+/////////////////////////////////////////////////////
+
+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.
+}
+
+#if LL_DARWIN
+#pragma GCC diagnostic warning "-Wdeprecated-declarations"
+#endif

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.
+}

indra/media_plugins/cef/volume_catcher.h

@@ -0,0 +1,54 @@
+/**
+ * @file volume_catcher.h
+ * @brief Interface to a class with platform-specific implementations that allows control of the audio volume of all sources in the current process.
+ *
+ * @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
+ */
+
+#ifndef VOLUME_CATCHER_H
+#define VOLUME_CATCHER_H
+
+#include "linden_common.h"
+
+class VolumeCatcherImpl;
+
+class VolumeCatcher
+{
+ public:
+    VolumeCatcher();
+    ~VolumeCatcher();
+
+    void setVolume(F32 volume); // 0.0 - 1.0
+
+    // Set the left-right pan of audio sources
+    // where -1.0 = left, 0 = center, and 1.0 = right
+    void setPan(F32 pan);
+
+    void pump(); // call this at least a few times a second if you can - it affects how quickly we can 'catch' a new audio source and adjust its volume
+
+ private:
+    VolumeCatcherImpl *pimpl;
+};
+
+#endif // VOLUME_CATCHER_H

indra/media_plugins/cef/windows_volume_catcher.cpp

@@ -0,0 +1,104 @@
+/**
+ * @file windows_volume_catcher.cpp
+ * @brief A Windows implementation of volume level control of all audio channels opened by a process.
+ *
+ * @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"
+#include <windows.h>
+#include <mmeapi.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;
+
+    // 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)
+{   // 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.
+}
+
+