Merge branch 'release/26.3' into marchcat/slua-26.3

# Conflicts:
#	.github/workflows/build.yaml
#	autobuild.xml
#	indra/llcommon/llsys.cpp
#	indra/llrender/llimagegl.cpp
#	indra/llrender/llimagegl.h
#	indra/newview/CMakeLists.txt
#	indra/newview/featuretable.txt
#	indra/newview/featuretable_linux.txt
#	indra/newview/featuretable_mac.txt
#	indra/newview/llvoavatar.cpp
#	indra/newview/llvoiceclient.cpp
#	indra/newview/llvoicevivox.cpp
#	indra/newview/viewer_manifest.py

9 files changed, 384 insertions, 52 deletions

diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 19326d301e..075c496ec5 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -988,30 +988,39 @@ namespace ll
 
 U8 const* LLFontManager::loadFont( std::string const &aFilename, long &a_Size)
 {
-    a_Size = 0;
-    std::map< std::string, std::shared_ptr<ll::fonts::LoadedFont> >::iterator itr = m_LoadedFonts.find( aFilename );
-    if( itr != m_LoadedFonts.end() )
+    try
     {
-        ++itr->second->mRefs;
-        // A possible overflow cannot happen here, as it is asserted that the size is less than std::numeric_limits<long>::max() a few lines below.
-        a_Size = static_cast<long>(itr->second->mSize);
-        return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
-    }
+        a_Size = 0;
+        std::map< std::string, std::shared_ptr<ll::fonts::LoadedFont> >::iterator itr = m_LoadedFonts.find(aFilename);
+        if (itr != m_LoadedFonts.end())
+        {
+            ++itr->second->mRefs;
+            // A possible overflow cannot happen here, as it is asserted that the size is less than std::numeric_limits<long>::max() a few lines below.
+            a_Size = static_cast<long>(itr->second->mSize);
+            return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
+        }
 
-    auto strContent = LLFile::getContents(aFilename);
+        auto strContent = LLFile::getContents(aFilename);
 
-    if( strContent.empty() )
-        return nullptr;
+        if (strContent.empty())
+            return nullptr;
 
-    // For fontconfig a type of long is required, std::string::size() returns size_t. I think it is safe to limit this to 2GiB and not support fonts that huge (can that even be a thing?)
-    llassert_always( strContent.size() < std::numeric_limits<long>::max() );
+        // For fontconfig a type of long is required, std::string::size() returns size_t. I think it is safe to limit this to 2GiB and not support fonts that huge (can that even be a thing?)
+        llassert_always(strContent.size() < std::numeric_limits<long>::max());
 
-    a_Size = static_cast<long>(strContent.size());
+        a_Size = static_cast<long>(strContent.size());
 
-    auto pCache = std::make_shared<ll::fonts::LoadedFont>( aFilename,  strContent, a_Size );
-    itr = m_LoadedFonts.insert( std::make_pair( aFilename, pCache ) ).first;
+        auto pCache = std::make_shared<ll::fonts::LoadedFont>(aFilename, strContent, a_Size);
+        itr = m_LoadedFonts.insert(std::make_pair(aFilename, pCache)).first;
 
-    return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
+        return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
+    }
+    catch (const std::bad_alloc&)
+    {
+        LLError::LLUserWarningMsg::showOutOfMemory();
+        LL_ERRS() << "Failed to load font. Out of memory." << LL_ENDL;
+    }
+    return nullptr;
 }
 
 void LLFontManager::unloadAllFonts()
diff --git a/indra/llrender/llfontvertexbuffer.cpp b/indra/llrender/llfontvertexbuffer.cpp
index a223509d30..2a0115265f 100644
--- a/indra/llrender/llfontvertexbuffer.cpp
+++ b/indra/llrender/llfontvertexbuffer.cpp
@@ -237,3 +237,80 @@ void LLFontVertexBuffer::renderBuffers()
     gGL.popUIMatrix();
 }
 
+// LLFontWidthBuffer
+bool LLFontWidthBuffer::sEnableBufferCollection = true;
+
+LLFontWidthBuffer::LLFontWidthBuffer()
+{
+}
+
+LLFontWidthBuffer::~LLFontWidthBuffer()
+{
+}
+
+void LLFontWidthBuffer::reset()
+{
+    mLastFont = nullptr;
+    mLastOffset = 0;
+    mLastMaxChars = 0;
+    mLastNoPadding = false;
+    mWidth = -1.f;
+    mLastScaleX = 1.f;
+    mLastScaleY = 1.f;
+    mLastVertDPI = 0.f;
+    mLastHorizDPI = 0.f;
+    mLastResGeneration = 0;
+    mLastFontCacheGen = 0;
+}
+
+F32 LLFontWidthBuffer::getWidth(
+    const LLFontGL* fontp,
+    const llwchar* wchars,
+    S32 begin_offset,
+    S32 max_chars,
+    bool no_padding)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
+    if (!fontp || !wchars)
+    {
+        return 0.f;
+    }
+
+    if (!sEnableBufferCollection)
+    {
+        return fontp->getWidthF32(wchars, begin_offset, max_chars, no_padding);
+    }
+
+    // Check if we can use cached width
+    bool needs_recalc = (mWidth < 0.f)
+        || (mLastFont != fontp)
+        || (mLastOffset != begin_offset)
+        || (mLastMaxChars != max_chars)
+        || (mLastNoPadding != no_padding)
+        || (mLastScaleX != LLFontGL::sScaleX)
+        || (mLastScaleY != LLFontGL::sScaleY)
+        || (mLastVertDPI != LLFontGL::sVertDPI)
+        || (mLastHorizDPI != LLFontGL::sHorizDPI)
+        || (mLastResGeneration != LLFontGL::sResolutionGeneration)
+        || (mLastFontCacheGen != fontp->getCacheGeneration());
+
+    if (needs_recalc)
+    {
+        // Calculate width using the font
+        mWidth = fontp->getWidthF32(wchars, begin_offset, max_chars, no_padding);
+
+        // Cache the parameters
+        mLastFont = fontp;
+        mLastOffset = begin_offset;
+        mLastMaxChars = max_chars;
+        mLastNoPadding = no_padding;
+        mLastScaleX = LLFontGL::sScaleX;
+        mLastScaleY = LLFontGL::sScaleY;
+        mLastVertDPI = LLFontGL::sVertDPI;
+        mLastHorizDPI = LLFontGL::sHorizDPI;
+        mLastResGeneration = LLFontGL::sResolutionGeneration;
+        mLastFontCacheGen = fontp->getCacheGeneration();
+    }
+
+    return mWidth;
+}
diff --git a/indra/llrender/llfontvertexbuffer.h b/indra/llrender/llfontvertexbuffer.h
index a9e1e2337c..94b833d227 100644
--- a/indra/llrender/llfontvertexbuffer.h
+++ b/indra/llrender/llfontvertexbuffer.h
@@ -32,6 +32,11 @@
 
 class LLVertexBufferData;
 
+// Rendering fonts is expensive, this class is intended to store
+// vertex buffers for rendered text, so that they can be reused.
+// LLFontVertexBuffer tracks font and rendering parameters, but
+// expects caller to track text changes and call reset() when
+// text changes.
 class LLFontVertexBuffer
 {
 public:
@@ -127,4 +132,45 @@ private:
     static bool sEnableBufferCollection;
 };
 
+// Extracting width from a font is expensive, and due to
+// mechanics of font rendering, we need width separately
+// and usually before rendering.
+// LLFontWidthBuffer tracks font and rendering parameters,
+// but expects caller to track text changes and call reset()
+// when text changes.
+class LLFontWidthBuffer
+{
+public:
+    LLFontWidthBuffer();
+    ~LLFontWidthBuffer();
+
+    void reset();
+
+    F32 getWidth(const LLFontGL* fontp,
+        const llwchar* wchars,
+        S32 begin_offset,
+        S32 max_chars,
+        bool no_padding);
+
+    static void enableBufferCollection(bool enable) { sEnableBufferCollection = enable; }
+private:
+        const LLFontGL* mLastFont = nullptr;
+        S32 mLastOffset = 0;
+        S32 mLastMaxChars = 0;
+        bool mLastNoPadding = false;
+        F32 mWidth = -1.f;
+
+        // LLFontGL's values that affect width calculation
+        F32 mLastScaleX = 1.f;
+        F32 mLastScaleY = 1.f;
+        F32 mLastVertDPI = 0.f;
+        F32 mLastHorizDPI = 0.f;
+        S32 mLastResGeneration = 0;
+
+        // Cache generation tracking
+        S32 mLastFontCacheGen = 0;
+
+        static bool sEnableBufferCollection;
+};
+
 #endif
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index 5357a79bae..b43f448305 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -2423,6 +2423,12 @@ void clear_glerror()
     glGetError();
 }
 
+void drain_glerror()
+{
+    // bounded: a lost/reset context can return errors indefinitely
+    for (S32 i = 0; i < 16 && glGetError() != GL_NO_ERROR; ++i) {}
+}
+
 ///////////////////////////////////////////////////////////////
 //
 // LLGLState
diff --git a/indra/llrender/llgl.h b/indra/llrender/llgl.h
index 469802657a..f76ac11de9 100644
--- a/indra/llrender/llgl.h
+++ b/indra/llrender/llgl.h
@@ -174,6 +174,7 @@ void log_glerror();
 void assert_glerror();
 
 void clear_glerror();
+void drain_glerror(); // pops ALL pending GL error flags (bounded so a lost/reset context that returns errors forever cannot hang the caller); use before an attributable glGetError check.
 
 
 # define stop_glerror() assert_glerror()
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 1cb7efafe2..bf8d15ffa9 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -66,8 +66,8 @@ static LLMutex sTexMemMutex;
 static std::unordered_map<U32, U64> sTextureAllocs;
 static U64 sTextureBytes = 0;
 
-// track a texture alloc on the currently bound texture.
-// asserts that no currently tracked alloc exists
+// Per-mip upload paths call this once per level; only free_tex_image
+// removes a texture's accounting entirely.
 void LLImageGLMemory::alloc_tex_image(U32 width, U32 height, U32 intformat, U32 count)
 {
     U32 texUnit = gGL.getCurrentTexUnitIndex();
@@ -80,15 +80,46 @@ void LLImageGLMemory::alloc_tex_image(U32 width, U32 height, U32 intformat, U32
 
     sTexMemMutex.lock();
 
-    // it is a precondition that no existing allocation exists for this texture
-    llassert(sTextureAllocs.find(texName) == sTextureAllocs.end());
-
-    sTextureAllocs[texName] = size;
+    auto iter = sTextureAllocs.find(texName);
+    if (iter != sTextureAllocs.end())
+    {
+        iter->second += size;
+    }
+    else
+    {
+        sTextureAllocs[texName] = size;
+    }
     sTextureBytes += size;
 
     sTexMemMutex.unlock();
 }
 
+// Add mip 1..N bytes to existing accounting. Use after glGenerateMipmap.
+void LLImageGLMemory::account_extra_mip_bytes(U32 base_width, U32 base_height, U32 intformat)
+{
+    U64 extra = 0;
+    U32 w = base_width;
+    U32 h = base_height;
+    while (w > 1 || h > 1)
+    {
+        w = w > 1 ? w >> 1 : 1;
+        h = h > 1 ? h >> 1 : 1;
+        extra += LLImageGL::dataFormatBytes(intformat, w, h);
+    }
+
+    U32 texUnit = gGL.getCurrentTexUnitIndex();
+    U32 texName = gGL.getTexUnit(texUnit)->getCurrTexture();
+
+    sTexMemMutex.lock();
+    auto iter = sTextureAllocs.find(texName);
+    if (iter != sTextureAllocs.end())
+    {
+        iter->second += extra;
+        sTextureBytes += extra;
+    }
+    sTexMemMutex.unlock();
+}
+
 // track texture free on given texName
 void LLImageGLMemory::free_tex_image(U32 texName)
 {
@@ -135,6 +166,8 @@ U64 LLImageGL::getTextureBytesAllocated()
 //statics
 
 U32 LLImageGL::sUniqueCount             = 0;
+std::atomic<U32> LLImageGL::sOOMErrorCount(0);
+thread_local bool LLImageGL::sStampBindFrame = true;
 U32 LLImageGL::sBindCount               = 0;
 S32 LLImageGL::sCount                   = 0;
 
@@ -459,7 +492,7 @@ bool LLImageGL::create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, b
 //----------------------------------------------------------------------------
 
 LLImageGL::LLImageGL(bool usemipmaps/* = true*/, bool allow_compression/* = true*/)
-:   mSaveData(0), mExternalTexture(false)
+:   mExternalTexture(false)
 {
     init(usemipmaps, allow_compression);
     setSize(0, 0, 0);
@@ -468,7 +501,7 @@ LLImageGL::LLImageGL(bool usemipmaps/* = true*/, bool allow_compression/* = true
 }
 
 LLImageGL::LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps/* = true*/, bool allow_compression/* = true*/)
-:   mSaveData(0), mExternalTexture(false)
+:   mExternalTexture(false)
 {
     llassert( components <= 4 );
     init(usemipmaps, allow_compression);
@@ -478,7 +511,7 @@ LLImageGL::LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps/* = t
 }
 
 LLImageGL::LLImageGL(const LLImageRaw* imageraw, bool usemipmaps/* = true*/, bool allow_compression/* = true*/)
-:   mSaveData(0), mExternalTexture(false)
+:   mExternalTexture(false)
 {
     init(usemipmaps, allow_compression);
     setSize(0, 0, 0);
@@ -587,8 +620,6 @@ void LLImageGL::cleanup()
         destroyGLTexture();
     }
     freePickMask();
-
-    mSaveData = NULL; // deletes data
 }
 
 //----------------------------------------------------------------------------
@@ -683,7 +714,10 @@ void LLImageGL::dump()
 //----------------------------------------------------------------------------
 void LLImageGL::forceUpdateBindStats(void) const
 {
-    mLastBindTime = sLastFrameTime;
+    // Intentionally a no-op: mLastBindTime is written only by real bind
+    // paths so the staleness signal reflects actual GPU use. Callers that
+    // still invoke this (avatar "keep alive" sites, deleted-texture
+    // fallback) no longer falsely refresh staleness.
 }
 
 bool LLImageGL::updateBindStats() const
@@ -742,6 +776,7 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
 bool LLImageGL::setImage(const U8* data_in, bool data_hasmips /* = false */, S32 usename /* = 0 */)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
+    LLImageGLStampBypass no_stamp; // upload binds are not visibility
 
     const bool is_compressed = isCompressed();
 
@@ -854,6 +889,7 @@ bool LLImageGL::setImage(const U8* data_in, bool data_hasmips /* = false */, S32
                     {
                         LL_PROFILE_GPU_ZONE("generate mip map");
                         glGenerateMipmap(mTarget);
+                        account_extra_mip_bytes(w, h, mFormatInternal);
                     }
                     stop_glerror();
                 }
@@ -1455,7 +1491,18 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
         LL_PROFILE_ZONE_NUM(width);
         LL_PROFILE_ZONE_NUM(height);
 
-        free_cur_tex_image();
+        // Release prior accounting only on the base mip; per-mip iteration
+        // accumulates the rest via the additive alloc_tex_image.
+        if (miplevel == 0)
+        {
+            free_cur_tex_image();
+        }
+
+        // Drain stale GL errors so an OOM detected below belongs to this alloc.
+        // Otherwise a failed glTexImage2D is swallowed in release while
+        // alloc_tex_image still counts the bytes, inflating the used-VRAM figure.
+        drain_glerror();
+
         const bool use_sub_image = should_stagger_image_set(compress);
         if (!use_sub_image)
         {
@@ -1465,19 +1512,30 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
         else
         {
             // break up calls to a manageable size for the GL command buffer
-            {
-                LL_PROFILE_ZONE_NAMED("glTexImage2D alloc");
-                glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, nullptr);
-            }
+            LL_PROFILE_ZONE_NAMED("glTexImage2D alloc");
+            glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, nullptr);
+        }
 
-            U8* src = (U8*)(pixels);
-            if (src)
+        if (glGetError() == GL_OUT_OF_MEMORY)
+        {
+            ++sOOMErrorCount;
+            LL_WARNS_ONCE("Texture") << "glTexImage2D failed with GL_OUT_OF_MEMORY ("
+                                     << width << "x" << height << " mip " << miplevel
+                                     << ") - not counting bytes" << LL_ENDL;
+        }
+        else
+        {
+            if (use_sub_image)
             {
-                LL_PROFILE_ZONE_NAMED("glTexImage2D copy");
-                sub_image_lines(target, miplevel, 0, 0, width, height, pixformat, pixtype, src, width);
+                U8* src = (U8*)(pixels);
+                if (src)
+                {
+                    LL_PROFILE_ZONE_NAMED("glTexImage2D copy");
+                    sub_image_lines(target, miplevel, 0, 0, width, height, pixformat, pixtype, src, width);
+                }
             }
+            alloc_tex_image(width, height, intformat, 1);
         }
-        alloc_tex_image(width, height, intformat, 1);
     }
     stop_glerror();
 }
@@ -1607,7 +1665,6 @@ bool LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
     {
         destroyGLTexture();
         mCurrentDiscardLevel = discard_level;
-        mLastBindTime = sLastFrameTime;
         mGLTextureCreated = false;
         return true ;
     }
@@ -1623,6 +1680,7 @@ bool LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, bool data_
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     LL_PROFILE_GPU_ZONE("createGLTexture");
     checkActiveThread();
+    LLImageGLStampBypass no_stamp; // creation binds are not visibility
 
     bool main_thread = on_main_thread();
 
@@ -1723,9 +1781,7 @@ bool LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, bool data_
 
 
     mTextureMemory = (S64Bytes)getMipBytes(mCurrentDiscardLevel);
-
-    // mark this as bound at this point, so we don't throw it out immediately
-    mLastBindTime = sLastFrameTime;
+    mGLCreateTime = sLastFrameTime;
 
     checkActiveThread();
     return true;
@@ -1852,12 +1908,13 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
     LLGLint is_compressed = 0;
     if (compressed_ok)
     {
-        glGetTexLevelParameteriv(mTarget, is_compressed, GL_TEXTURE_COMPRESSED, (GLint*)&is_compressed);
+        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_COMPRESSED, (GLint*)&is_compressed);
     }
 
     //-----------------------------------------------------------------------------------------------
     GLenum error ;
-    while((error = glGetError()) != GL_NO_ERROR)
+    S32 error_count = 0 ;
+    while((error = glGetError()) != GL_NO_ERROR && ++error_count <= 16)
     {
         LL_WARNS() << "GL Error happens before reading back texture. Error code: " << error << LL_ENDL ;
     }
@@ -1917,7 +1974,8 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
         LL_WARNS() << "GL Error happens after reading back texture. Error code: " << error << LL_ENDL ;
         imageraw->deleteData() ;
 
-        while((error = glGetError()) != GL_NO_ERROR)
+        error_count = 0 ;
+        while((error = glGetError()) != GL_NO_ERROR && ++error_count <= 16)
         {
             LL_WARNS() << "GL Error happens after reading back texture. Error code: " << error << LL_ENDL ;
         }
@@ -2033,6 +2091,37 @@ S32 LLImageGL::getWidth(S32 discard_level) const
     return width;
 }
 
+// static
+S32 LLImageGL::dimDerivedMaxDiscard(S32 width, S32 height)
+{
+    if (width <= 0 || height <= 0)
+    {
+        return 0;
+    }
+    // max(w,h) - min() caps short on rectangular textures
+    // (1024x512 reaches 1x1 at discard 10, not 9).
+    return (S32)floorf(log2f((F32)llmax(width, height)));
+}
+
+void LLImageGL::stampBound() const
+{
+    // Both stamps skip same-frame re-binds (bindFast runs per draw). They dedupe
+    // separately, so a non-camera pass touching the time stamp first doesn't stop
+    // a real camera bind from setting the frame stamp later the same frame.
+    if (mLastBindTime != sLastFrameTime)
+    {
+        mLastBindTime = sLastFrameTime;
+    }
+    if (sStampBindFrame)
+    {
+        const U32 frame = LLFrameTimer::getFrameCount();
+        if (mLastBindFrame != frame)
+        {
+            mLastBindFrame = frame;
+        }
+    }
+}
+
 S64 LLImageGL::getBytes(S32 discard_level) const
 {
     if (discard_level < 0)
@@ -2455,6 +2544,12 @@ bool LLImageGL::scaleDown(S32 desired_discard)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 
+    // Don't let eviction re-arm the GC: the glGenerateMipmap re-bind below would
+    // otherwise stamp mLastBindFrame, so the next computeDesiredDiscard treats the
+    // just-evicted texture as freshly drawn, un-floors it, and re-fetches - the
+    // evict/refetch oscillation.
+    LLImageGLStampBypass no_stamp;
+
     if (mTarget != GL_TEXTURE_2D
         || mFormatInternal == -1 // not initialized
         )
@@ -2462,7 +2557,12 @@ bool LLImageGL::scaleDown(S32 desired_discard)
         return false;
     }
 
-    desired_discard = llmin(desired_discard, mMaxDiscardLevel);
+    // GL pyramid reaches 1x1 regardless of codec levels;
+    // mMaxDiscardLevel is hardcapped at MAX_DISCARD_LEVEL.
+    S32 dim_max_discard = (mWidth > 0 && mHeight > 0)
+        ? dimDerivedMaxDiscard(mWidth, mHeight)
+        : (S32)mMaxDiscardLevel;
+    desired_discard = llmin(desired_discard, dim_max_discard);
 
     if (desired_discard <= mCurrentDiscardLevel)
     {
@@ -2495,6 +2595,7 @@ bool LLImageGL::scaleDown(S32 desired_discard)
                 LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glGenerateMipmap");
                 gGL.getTexUnit(0)->bind(this);
                 glGenerateMipmap(mTarget);
+                account_extra_mip_bytes(desired_width, desired_height, mFormatInternal);
                 gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
             }
         }
@@ -2540,6 +2641,7 @@ bool LLImageGL::scaleDown(S32 desired_discard)
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glGenerateMipmap");
             glGenerateMipmap(mTarget);
+            account_extra_mip_bytes(desired_width, desired_height, mFormatInternal);
         }
 
         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h
index 773b647d69..67f86cd646 100644
--- a/indra/llrender/llimagegl.h
+++ b/indra/llrender/llimagegl.h
@@ -39,6 +39,7 @@
 #include "llrender.h"
 #include "threadpool.h"
 #include "workqueue.h"
+#include <atomic>
 #include <unordered_set>
 
 #define LL_IMAGEGL_THREAD_CHECK 0 //set to 1 to enable thread debugging for ImageGL
@@ -51,6 +52,11 @@ class LLWindow;
 namespace LLImageGLMemory
 {
     void alloc_tex_image(U32 width, U32 height, U32 intformat, U32 count);
+
+    // Add mip 1..N bytes to existing accounting. Call after glGenerateMipmap
+    // when only the base mip was accounted; without this the bytes counter
+    // undercounts mipmap-generated textures by ~25%.
+    void account_extra_mip_bytes(U32 base_width, U32 base_height, U32 intformat);
     void free_tex_image(U32 texName);
     void free_tex_images(U32 count, const U32* texNames);
     void free_cur_tex_image();
@@ -151,6 +157,15 @@ public:
     S32  getDiscardLevel() const        { return mCurrentDiscardLevel; }
     S32  getMaxDiscardLevel() const     { return mMaxDiscardLevel; }
 
+    // floor(log2(max(w, h))) - deepest GL pyramid level (down to 1x1).
+    // Returns 0 for non-positive inputs.
+    static S32 dimDerivedMaxDiscard(S32 width, S32 height);
+
+    // Record the wall-clock bind time - every bind path that touches a
+    // streaming-managed texture must call this, or the staleness signal
+    // sees the texture as never-bound and ramps it toward eviction.
+    void stampBound() const;
+
     // override the current discard level
     // should only be used for local textures where you know exactly what you're doing
     void setDiscardLevel(S32 level) { mCurrentDiscardLevel = level; }
@@ -224,14 +239,23 @@ public:
 public:
     // Various GL/Rendering options
     S64Bytes mTextureMemory;
-    mutable F32  mLastBindTime; // last time this was bound, by discard level
+    mutable F32  mLastBindTime = 0.f;  // wall-clock time at last stampBound (bind or bind-attempt)
+    mutable U32  mLastBindFrame = 0;   // frame index (LLFrameTimer::getFrameCount) at last CAMERA-pass
+                                       // stampBound; 0 = never. Drives visibility GC + fetch gating.
+    F32          mGLCreateTime = 0.f;  // wall-clock time the GL texture was created
+
+    // When false, stampBound skips the mLastBindFrame stamp (mLastBindTime still
+    // updates). Set false around non-camera passes (probes, shadows, impostors)
+    // and administrative binds (upload, scaleDown - via LLImageGLStampBypass) so
+    // those binds don't count as camera visibility. Thread-local so a GL upload
+    // thread can't flip it on the render thread mid-frame.
+    static thread_local bool sStampBindFrame;
 
 private:
     U32 createPickMask(S32 pWidth, S32 pHeight);
     void freePickMask();
     bool isCompressed();
 
-    LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
     LL::WorkQueue::weak_t mMainQueue;
     U8* mPickMask;  //downsampled bitmap approximation of alpha channel.  NULL if no alpha channel
     U16 mPickMaskWidth;
@@ -285,6 +309,11 @@ public:
     // Global memory statistics
     static U32 sBindCount;                  // Tracks number of texture binds for current frame
     static U32 sUniqueCount;                // Tracks number of unique texture binds for current frame
+    // glTexImage2D GL_OUT_OF_MEMORY failures detected (bytes NOT counted for
+    // these). Written from whichever thread runs texture creation; read by
+    // the streaming 1Hz pressure log. Nonzero = the driver is refusing
+    // allocations and the VRAM budget is unreliable.
+    static std::atomic<U32> sOOMErrorCount;
     static LLImageGL* sDefaultGLTexture ;
     static bool sAutomatedTest;
     static bool sCompressTextures;          //use GL texture compression
@@ -339,6 +368,19 @@ public:
 
 };
 
+// RAII: suppress the mLastBindFrame stamp for the current scope. Use around
+// administrative binds (upload, create, scaleDown) so they don't count as
+// camera visibility - otherwise the GC's own scaleDown re-stamps what it just
+// aged out and oscillates. Saves/restores, so it nests correctly.
+class LLImageGLStampBypass
+{
+public:
+    LLImageGLStampBypass() : mPrev(LLImageGL::sStampBindFrame) { LLImageGL::sStampBindFrame = false; }
+    ~LLImageGLStampBypass() { LLImageGL::sStampBindFrame = mPrev; }
+private:
+    bool mPrev;
+};
+
 class LLImageGLThread : public LLSimpleton<LLImageGLThread>, LL::ThreadPool
 {
 public:
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index ab88e4868e..8b2fdc8c9d 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -193,6 +193,10 @@ void LLTexUnit::bindFast(LLTexture* texture)
     glActiveTexture(GL_TEXTURE0 + mIndex);
     gGL.mCurrTextureUnitIndex = mIndex;
     mCurrTexture = gl_tex->getTexName();
+    mCurrTexType = gl_tex->getTarget();
+    // bindFast bypasses updateBindStats(); stamp directly so the staleness
+    // signal sees per-frame use of batched textures.
+    gl_tex->stampBound();
     if (!mCurrTexture)
     {
         LL_PROFILE_ZONE_NAMED("MISSING TEXTURE");
@@ -237,6 +241,11 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
                         texture->setActive() ;
                         texture->updateBindStatsForTester() ;
                     }
+                    // updateBindStats only stamps time; the GC and fetch gate use
+                    // the frame stamp, so stamp it here too or bind()-drawn faces
+                    // (bump/material/media) oscillate. Admin/non-camera binds are
+                    // already suppressed via LLImageGLStampBypass / sStampBindFrame.
+                    gl_tex->stampBound();
                     mHasMipMaps = gl_tex->mHasMipMaps;
                     if (gl_tex->mTexOptionsDirty)
                     {
@@ -245,11 +254,17 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
                         setTextureFilteringOption(gl_tex->mFilterOption);
                     }
                 }
+                else
+                {
+                    // Already current - still being used, keep it fresh.
+                    gl_tex->stampBound();
+                }
             }
             else
             {
                 //if deleted, will re-generate it immediately
                 texture->forceImmediateUpdate() ;
+                gl_tex->stampBound();
 
                 gl_tex->forceUpdateBindStats() ;
                 return texture->bindDefaultImage(mIndex);
@@ -311,6 +326,8 @@ bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind, S32
         glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
         stop_glerror();
         texture->updateBindStats();
+        // Frame-stamp fresh binds too - see bind(LLTexture*) above.
+        texture->stampBound();
         mHasMipMaps = texture->mHasMipMaps;
         if (texture->mTexOptionsDirty)
         {
@@ -321,6 +338,11 @@ bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind, S32
             stop_glerror();
         }
     }
+    else
+    {
+        // Already current - still being used, keep it fresh.
+        texture->stampBound();
+    }
 
     stop_glerror();
 
@@ -1642,7 +1664,16 @@ LLVertexBuffer* LLRender::genBuffer(U32 attribute_mask, S32 count)
     LLVertexBuffer * vb = new LLVertexBuffer(attribute_mask);
     vb->allocateBuffer(count, 0);
 
-    vb->setBuffer();
+    // Non-Apple path uses glBufferSubData inside setXxxData, so the VBO
+    // must already be bound. On Apple, the VBO is lazily created in
+    // _unmapBuffer (LLAppleVBOPool); calling setBuffer() here would bind
+    // mGLBuffer == 0 and then setupVertexBuffer would issue
+    // glVertexAttribIPointer with a non-null offset against no bound
+    // GL_ARRAY_BUFFER -> GL_INVALID_OPERATION in core profile.
+    if (!gGLManager.mIsApple)
+    {
+        vb->setBuffer();
+    }
 
     vb->setPositionData(mVerticesp.get());
 
@@ -1657,6 +1688,9 @@ LLVertexBuffer* LLRender::genBuffer(U32 attribute_mask, S32 count)
     }
 
 #if LL_DARWIN
+    // unmapBuffer creates the GL buffer, uploads, and leaves it bound,
+    // drawBuffer's later setBuffer() then runs setupVertexBuffer against
+    // a valid VBO.
     vb->unmapBuffer();
 #endif
     vb->unbind();
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index f6738364a6..d8a620cf5b 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1023,8 +1023,23 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
 
             llifstream instream(meta_out_path, std::ifstream::in | std::ifstream::binary);
             LLSD in_data;
-            // todo: this is likely very expensive to parse, should use binary
-            LLSDSerialize::fromBinary(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
+            try
+            {
+                LLSDSerialize::fromBinary(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
+            }
+            catch( std::bad_alloc& )
+            {
+                // Try to get a bit more memory back before we try to clear the cache.
+                in_data.clear();
+                // Just in case it was somehow the cause, clear cache.
+                clearShaderCache();
+                // If user run out of memory this early in init,
+                // we don't want to keep going just to crash again.
+                // Notify user and close.
+                LLError::LLUserWarningMsg::showOutOfMemory();
+                LL_ERRS("ShaderMgr") << "Failed to parse shader cache metadata, potentially due to size. Purged cache." << LL_ENDL;
+                return;
+            }
             instream.close();
 
             if (old_cache_version == current_cache_version