Rye/linden264

indra/cmake/Boost.cmake

@@ -1,8 +1,8 @@
 include_guard()
 add_library(ll::boost INTERFACE IMPORTED)
 
-find_package(Boost CONFIG REQUIRED COMPONENTS context dll fiber filesystem program_options url)
-target_link_libraries(ll::boost INTERFACE Boost::disable_autolinking Boost::headers Boost::dll Boost::fiber Boost::context Boost::filesystem Boost::program_options Boost::url)
+find_package(Boost CONFIG REQUIRED COMPONENTS context dll fiber filesystem process program_options url)
+target_link_libraries(ll::boost INTERFACE Boost::disable_autolinking Boost::headers Boost::dll Boost::fiber Boost::context Boost::filesystem Boost::process Boost::program_options Boost::url)
 
 if(WINDOWS)
     find_package(Boost CONFIG REQUIRED COMPONENTS stacktrace_windbg)
@@ -11,3 +11,8 @@ else()
     find_package(Boost CONFIG REQUIRED COMPONENTS stacktrace_basic)
     target_link_libraries(ll::boost INTERFACE Boost::stacktrace_basic)
 endif()
+
+if(WINDOWS)
+    # Boost.Process v2 needs ntdll (NtSuspendProcess/NtResumeProcess)
+    target_link_libraries(ll::boost INTERFACE ntdll)
+endif(WINDOWS)

indra/cmake/Linking.cmake

@@ -60,6 +60,7 @@ else()
   find_library(COREAUDIO_LIBRARY CoreAudio)
   find_library(COREGRAPHICS_LIBRARY CoreGraphics)
   find_library(AUDIOTOOLBOX_LIBRARY AudioToolbox)
+  find_library(UNIFORMTYPEIDENTIFIERS_LIBRARY UniformTypeIdentifiers)
 
   target_link_libraries( ll::oslibraries INTERFACE
           ${COCOA_LIBRARY}
@@ -70,6 +71,7 @@ else()
           ${COREAUDIO_LIBRARY}
           ${AUDIOTOOLBOX_LIBRARY}
           ${COREGRAPHICS_LIBRARY}
+          ${UNIFORMTYPEIDENTIFIERS_LIBRARY}
           Threads::Threads
           )
 endif()

indra/llappearance/llpolymesh.cpp

@@ -862,6 +862,7 @@ LLPolyMesh *LLPolyMesh::getMesh(const std::string &name, LLPolyMesh* reference_m
 //-----------------------------------------------------------------------------
 void LLPolyMesh::freeAllMeshes()
 {
+    LL_PROFILE_ZONE_SCOPED;
         // delete each item in the global lists
         for_each(sGlobalSharedMeshList.begin(), sGlobalSharedMeshList.end(), DeletePairedPointer());
         sGlobalSharedMeshList.clear();

indra/llappearance/lltexlayer.cpp

@@ -1427,6 +1427,15 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
                 // We should only be doing this when we believe something has changed with respect to the user's appearance.
         {
             LL_DEBUGS("Morph") << "gl alpha cache of morph mask not found, doing readback: " << getName() << LL_ENDL;
+
+            // Replace the cached mask without leaking its old allocation.
+            alpha_cache_t::iterator cached = mAlphaCache.find(cache_index);
+            if (cached != mAlphaCache.end())
+            {
+                ll_aligned_free_32(cached->second);
+                mAlphaCache.erase(cached);
+            }
+
             // clear out a slot if we have filled our cache
             S32 max_cache_entries = getTexLayerSet()->getAvatarAppearance()->isSelf() ? 4 : 1;
             while ((S32)mAlphaCache.size() >= max_cache_entries)
@@ -1463,6 +1472,7 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
                     U8* temp = (U8*)ll_aligned_malloc_32(mem_size << 2); // allocate same size, but RGBA
                     if (!temp)
                     {
+                        ll_aligned_free_32(alpha_data);
                         LLError::LLUserWarningMsg::showOutOfMemory();
                         LL_ERRS() << "Failed to allocate temporary memory for morph texture readback: " << (S32)(mem_size << 2) << LL_ENDL;
                         return;
@@ -1505,6 +1515,7 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
                     U8* temp_data = (U8*)ll_aligned_malloc_32(mem_size * TEMP_BYTES_PER_PIXEL);
                     if (!temp_data)
                     {
+                        ll_aligned_free_32(alpha_data);
                         LLError::LLUserWarningMsg::showOutOfMemory();
                         LL_ERRS() << "Failed to allocate temporary memory for morph texture: " << (S32)(mem_size * TEMP_BYTES_PER_PIXEL) << LL_ENDL;
                         return;

indra/llappearance/llwearable.cpp

@@ -727,17 +727,22 @@ void LLWearable::writeToAvatar(LLAvatarAppearance* avatarp)
     if (!avatarp) return;
 
     // Pull params
-    for( const LLVisualParam* param = avatarp->getFirstVisualParam(); param; param = avatarp->getNextVisualParam() )
+    // Iterate over wearable's params first since they should be fewer than avatar params.
+    // Wearables are cloned from avatar params by mType, so they should be always be a
+    // subset of the avatar's params and a situation where mType param doesn't exist in
+    // a wearable yet exist in the avatar should not happen.
+    for (const visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
     {
+        LLVisualParam* wearable_param = vp_pair.second;
+
         // cross-wearable parameters are not authoritative, as they are driven by a different wearable. So don't copy the values to the
         // avatar object if cross wearable. Cross wearable params get their values from the avatar, they shouldn't write the other way.
-        if( (((LLViewerVisualParam*)param)->getWearableType() == mType) && (!((LLViewerVisualParam*)param)->getCrossWearable()) )
-        {
-            S32 param_id = param->getID();
-            F32 weight = getVisualParamWeight(param_id);
+        if (((LLViewerVisualParam*)wearable_param)->getCrossWearable())
+            continue;
 
-            avatarp->setVisualParamWeight( param_id, weight);
-        }
+        F32 weight = wearable_param->getWeight();
+        // Silently fails if param was not found
+        avatarp->setVisualParamWeight(vp_pair.first, mType, weight);
     }
 }
 

indra/llaudio/llaudioengine_openal.cpp

@@ -164,9 +164,122 @@ bool LLAudioEngine_OpenAL::init(void* userdata, const std::string &app_title)
         mDisconnectPollTimer.reset();
     }
 
+    initSystemDefaultFollowing();
+
     return true;
 }
 
+// ALC_SOFT_system_events tells us when the OS default output device
+// changes; ALC_SOFT_reopen_device lets us move onto it without tearing
+// down the context. Both are needed, and both only matter while the user
+// is running on the system default — a pinned device stays pinned.
+void LLAudioEngine_OpenAL::initSystemDefaultFollowing()
+{
+    mFollowSystemDefault = false;
+    mEventControlSOFT    = nullptr;
+    mEventCallbackSOFT   = nullptr;
+
+    if (alcIsExtensionPresent(mALCDevice, "ALC_SOFT_reopen_device") != ALC_TRUE ||
+        alcIsExtensionPresent(mALCDevice, "ALC_SOFT_system_events") != ALC_TRUE)
+    {
+        LL_INFOS() << "LLAudioEngine_OpenAL::init() ALC_SOFT_system_events / "
+                      "ALC_SOFT_reopen_device unavailable; a restart is needed "
+                      "to pick up OS default device changes." << LL_ENDL;
+        return;
+    }
+
+    mEventControlSOFT = reinterpret_cast<LPALCEVENTCONTROLSOFT>(
+        alcGetProcAddress(mALCDevice, "alcEventControlSOFT"));
+    mEventCallbackSOFT = reinterpret_cast<LPALCEVENTCALLBACKSOFT>(
+        alcGetProcAddress(mALCDevice, "alcEventCallbackSOFT"));
+    if (!mEventControlSOFT || !mEventCallbackSOFT)
+    {
+        mEventControlSOFT  = nullptr;
+        mEventCallbackSOFT = nullptr;
+        LL_WARNS() << "LLAudioEngine_OpenAL::init() ALC_SOFT_system_events "
+                      "advertised but its entry points did not resolve."
+                   << LL_ENDL;
+        return;
+    }
+
+    // Subscribe regardless of the current preference: the user can move
+    // back to "default" at runtime, and re-arming then would mean
+    // resolving entry points against a device we may no longer hold.
+    mDefaultDeviceChanged = false;
+    mEventCallbackSOFT(&LLAudioEngine_OpenAL::onDeviceEventSOFT, this);
+    ALCenum events[] = { ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT };
+    mEventControlSOFT(1, events, ALC_TRUE);
+
+    mFollowSystemDefault = mPreferredDevice.empty();
+    if (mFollowSystemDefault)
+    {
+        LL_INFOS() << "LLAudioEngine_OpenAL::init() following the OS default "
+                      "output device." << LL_ENDL;
+    }
+    else
+    {
+        LL_INFOS() << "LLAudioEngine_OpenAL::init() output device pinned to '"
+                   << mPreferredDevice << "'; OS default changes ignored."
+                   << LL_ENDL;
+    }
+}
+
+// static
+void ALC_APIENTRY LLAudioEngine_OpenAL::onDeviceEventSOFT(ALCenum event_type, ALCenum device_type,
+                                                          ALCdevice* /*device*/, ALCsizei /*length*/,
+                                                          const ALCchar* /*message*/, void* user_param) noexcept
+{
+    // Runs on OpenAL's own event thread. Do nothing here but raise the
+    // flag — idle() does the reopen on the main thread, where the rest
+    // of the engine's AL state is owned.
+    if (event_type != ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT) return;
+
+    // The same event reports the default CAPTURE device changing. Reopening
+    // playback for that would interrupt audio because the user picked a
+    // different microphone.
+    if (device_type != ALC_PLAYBACK_DEVICE_SOFT) return;
+
+    if (auto* self = static_cast<LLAudioEngine_OpenAL*>(user_param))
+    {
+        self->mDefaultDeviceChanged = true;
+    }
+}
+
+void LLAudioEngine_OpenAL::reopenOnDefaultDevice()
+{
+    if (!mFollowSystemDefault || !mALCDevice) return;
+
+    using ReopenFn = ALCboolean (ALC_APIENTRY *)(ALCdevice*, const ALCchar*,
+                                                 const ALCint*);
+    auto reopen = reinterpret_cast<ReopenFn>(
+        alcGetProcAddress(mALCDevice, "alcReopenDeviceSOFT"));
+    if (!reopen) return;
+
+    LL_INFOS() << "LLAudioEngine_OpenAL: OS default output device changed; "
+                  "reopening (was '" << mActiveDevice << "')" << LL_ENDL;
+
+    // Clear any pending device error so the failure branch reports ours.
+    (void)alcGetError(mALCDevice);
+
+    if (reopen(mALCDevice, nullptr, nullptr) != ALC_TRUE)
+    {
+        LL_WARNS() << "LLAudioEngine_OpenAL::reopenOnDefaultDevice() "
+                      "alcReopenDeviceSOFT failed: 0x" << std::hex
+                   << alcGetError(mALCDevice) << std::dec << LL_ENDL;
+        return;
+    }
+
+    if (const char* opened = alcGetString(mALCDevice, ALC_ALL_DEVICES_SPECIFIER))
+    {
+        mActiveDevice = opened;
+    }
+    LL_INFOS() << "LLAudioEngine_OpenAL::reopenOnDefaultDevice() now on '"
+               << mActiveDevice << "'" << LL_ENDL;
+
+    // The Sound prefs combo shows the active device, so let it refresh.
+    mDevicesChangedSignal();
+}
+
 // virtual
 std::string LLAudioEngine_OpenAL::getDriverName(bool verbose)
 {
@@ -218,6 +331,18 @@ void LLAudioEngine_OpenAL::shutdown()
     // ordering.
     shutdownEfx();
 
+    // Unhook the OS default-device callback before the device is closed,
+    // so OpenAL's event thread can't call back into a half-torn engine.
+    if (mEventControlSOFT && mEventCallbackSOFT)
+    {
+        ALCenum events[] = { ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT };
+        mEventControlSOFT(1, events, ALC_FALSE);
+        mEventCallbackSOFT(nullptr, nullptr);
+    }
+    mFollowSystemDefault = false;
+    mEventControlSOFT    = nullptr;
+    mEventCallbackSOFT   = nullptr;
+
     LL_INFOS() << "About to LLAudioEngine::shutdown()" << LL_ENDL;
     LLAudioEngine::shutdown();
 
@@ -300,6 +425,12 @@ void LLAudioEngine_OpenAL::setOutputDevice(const std::string& id)
         return;  // already running on this device
     }
     mPreferredDevice = id;
+    // Following the OS default is only correct while the user is ON the
+    // default; picking a device pins it, picking "default" resumes. Set it
+    // here so the early exits below cannot leave it disagreeing with
+    // mPreferredDevice.
+    mFollowSystemDefault  = mPreferredDevice.empty() && mEventControlSOFT != nullptr;
+    mDefaultDeviceChanged = false;
 
     if (!mALCDevice)
     {
@@ -361,6 +492,13 @@ void LLAudioEngine_OpenAL::idle()
     // independent of any of it and just rides on top once a second.
     LLAudioEngine::idle();
 
+    // Raised on OpenAL's event thread by onDeviceEventSOFT.
+    if (mDefaultDeviceChanged)
+    {
+        mDefaultDeviceChanged = false;
+        reopenOnDefaultDevice();
+    }
+
     if (!mDisconnectExtAvailable || !mALCDevice) return;
 
     // Polling ALC_CONNECTED on every frame would generate an ALC call

indra/llaudio/llaudioengine_openal.h

@@ -36,6 +36,7 @@
 #include "llaudioengine.h"
 #include "lllistener_openal.h"
 #include "llwindgen.h"
+#include "llatomic.h"
 
 #include <deque>
 #include <memory>
@@ -151,6 +152,23 @@ class LLAudioEngine_OpenAL : public LLAudioEngine
         int          mConsecutiveDisconnects = 0;
         LLFrameTimer mDisconnectPollTimer;
 
+        // ALC_SOFT_system_events + ALC_SOFT_reopen_device let us follow
+        // the OS default output device while the viewer is running. Only
+        // armed when the user hasn't pinned a specific device — if
+        // mPreferredDevice names one, following the OS default would drag
+        // them off their choice. mDefaultDeviceChanged is written from
+        // OpenAL's own event thread and consumed in idle().
+        bool                   mFollowSystemDefault  = false;
+        LPALCEVENTCONTROLSOFT  mEventControlSOFT     = nullptr;
+        LPALCEVENTCALLBACKSOFT mEventCallbackSOFT    = nullptr;
+        LLAtomicBool           mDefaultDeviceChanged{false};
+
+        void initSystemDefaultFollowing();
+        static void ALC_APIENTRY onDeviceEventSOFT(ALCenum event_type, ALCenum device_type,
+                                                   ALCdevice* device, ALCsizei length,
+                                                   const ALCchar* message, void* user_param) noexcept;
+        void reopenOnDefaultDevice();
+
         // Pre-allocated buffer pool. Replaces the historical per-frame
         // alGenBuffers / alDeleteBuffers churn that ran every update
         // tick. At initWind we gen MAX_NUM_WIND_BUFFERS buffer ids

indra/llcharacter/llcharacter.cpp

@@ -319,6 +319,31 @@ bool LLCharacter::setVisualParamWeight(S32 index, F32 weight)
     return false;
 }
 
+//-----------------------------------------------------------------------------
+// setVisualParamWeight()
+//-----------------------------------------------------------------------------
+bool LLCharacter::setVisualParamWeight(S32 index, S32 type, F32 weight)
+{
+    visual_param_index_map_t::iterator index_iter = mVisualParamIndexMap.find(index);
+    if (index_iter != mVisualParamIndexMap.end())
+    {
+        LLVisualParam* param = index_iter->second;
+        if (param->getWearableType() == type)
+        {
+            param->setWeight(weight);
+            return true;
+        }
+        else
+        {
+            // setVisualParamWeight at the moment is only used in writeToAvatar.
+            // The type is supposed to match since wearable is a subset of avatar by type.
+            llassert(false);
+            LL_WARNS() << "Visual param index " << index << " is not of type " << type << LL_ENDL;
+        }
+    }
+    return false;
+}
+
 //-----------------------------------------------------------------------------
 // getVisualParamWeight()
 //-----------------------------------------------------------------------------

indra/llcharacter/llcharacter.h

@@ -202,6 +202,7 @@ class LLCharacter
     virtual bool setVisualParamWeight(const LLVisualParam *which_param, F32 weight);
     virtual bool setVisualParamWeight(const char* param_name, F32 weight);
     virtual bool setVisualParamWeight(S32 index, F32 weight);
+    virtual bool setVisualParamWeight(S32 index, S32 type, F32 weight);
 
     // get visual param weight by param or name
     F32 getVisualParamWeight(LLVisualParam *distortion);

indra/llcharacter/llvisualparam.h

@@ -119,6 +119,7 @@ class alignas(16) LLVisualParam
     //  Pure virtuals
     //virtual bool          parseData( LLXmlTreeNode *node ) = 0;
     virtual void            apply( ESex avatar_sex ) = 0;
+    virtual S32             getWearableType() const = 0;
     //  Default functions
     virtual void            setWeight(F32 weight);
     virtual void            setAnimationTarget( F32 target_value);

indra/llcommon/llapr.cpp

@@ -135,11 +135,35 @@ apr_pool_t* LLAPRPool::getAPRPool()
 bool _ll_apr_warn_status(apr_status_t status, const char* file, int line)
 {
     if(APR_SUCCESS == status) return false;
-
-    char buf[MAX_STRING];   /* Flawfinder: ignore */
+    char buf[MAX_STRING];
     apr_strerror(status, buf, sizeof(buf));
-    LL_WARNS("APR") << "APR: " << file << ":" << line << " " << buf << LL_ENDL;
 
+#ifdef LL_WINDOWS
+    // On Windows, APR error strings may be in the system's ANSI code page (e.g., Cyrillic)
+    // Convert to UTF-8 for proper logging
+    std::string error_msg = buf;
+    int wlen = MultiByteToWideChar(CP_ACP, 0, buf, -1, nullptr, 0);
+    if (wlen > 0)
+    {
+        std::wstring wbuf(wlen, L'\0');
+        MultiByteToWideChar(CP_ACP, 0, buf, -1, &wbuf[0], wlen);
+
+        int utf8len = WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, nullptr, 0, nullptr, nullptr);
+        if (utf8len > 0)
+        {
+            std::string utf8buf(utf8len, '\0');
+            WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, &utf8buf[0], utf8len, nullptr, nullptr);
+            error_msg = utf8buf.c_str(); // Remove null terminator
+        }
+        LL_WARNS("APR") << "APR: " << file << ":" << line << " " << error_msg << " (0x" << std::hex << status << std::dec << ")" << LL_ENDL;
+    }
+    else
+    {
+        LL_WARNS("APR") << "APR: " << file << ":" << line << " " << buf << " (0x" << std::hex << status << std::dec << ")" << LL_ENDL;
+    }
+#else
+    LL_WARNS("APR") << "APR: " << file << ":" << line << " " << buf << " (0x" << std::hex << status << std::dec << ")" << LL_ENDL;
+#endif
     return true;
 }