summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/indra_constants.h12
-rw-r--r--indra/llcommon/llapp.cpp1
-rw-r--r--indra/llcommon/llframetimer.cpp1
-rw-r--r--indra/llcommon/llframetimer.h8
-rw-r--r--indra/llcommon/llkeythrottle.h83
-rw-r--r--indra/llcommon/llstring.cpp26
-rw-r--r--indra/llcommon/llstring.h21
-rw-r--r--indra/llcommon/llversionserver.h6
8 files changed, 117 insertions, 41 deletions
diff --git a/indra/llcommon/indra_constants.h b/indra/llcommon/indra_constants.h
index a0b1293639..5697fb9f41 100644
--- a/indra/llcommon/indra_constants.h
+++ b/indra/llcommon/indra_constants.h
@@ -38,7 +38,11 @@
// At 45 Hz collisions seem stable and objects seem
// to settle down at a reasonable rate.
// JC 3/18/2003
-const F32 PHYSICS_TIMESTEP = 1.f / 45.f;
+
+// const F32 PHYSICS_TIMESTEP = 1.f / 45.f;
+// This must be a #define due to anal retentive restrictions on const expressions
+// CG 2008-06-05
+#define PHYSICS_TIMESTEP (1.f / 45.f)
const F32 COLLISION_TOLERANCE = 0.1f;
const F32 HALF_COLLISION_TOLERANCE = COLLISION_TOLERANCE * 0.5f;
@@ -50,9 +54,9 @@ const U32 DAYS_PER_LINDEN_YEAR = 11;
const U32 SEC_PER_LINDEN_DAY = HOURS_PER_LINDEN_DAY * 60 * 60;
const U32 SEC_PER_LINDEN_YEAR = DAYS_PER_LINDEN_YEAR * SEC_PER_LINDEN_DAY;
-const F32 REGION_WIDTH_METERS = 256.f;
-const S32 REGION_WIDTH_UNITS = 256;
-const U32 REGION_WIDTH_U32 = 256;
+static const F32 REGION_WIDTH_METERS = 256.f;
+static const S32 REGION_WIDTH_UNITS = 256;
+static const U32 REGION_WIDTH_U32 = 256;
const F32 REGION_HEIGHT_METERS = 4096.f;
diff --git a/indra/llcommon/llapp.cpp b/indra/llcommon/llapp.cpp
index 2c7c7e38a4..8826251617 100644
--- a/indra/llcommon/llapp.cpp
+++ b/indra/llcommon/llapp.cpp
@@ -224,6 +224,7 @@ LLSD LLApp::getOptionData(OptionPriority level)
void LLApp::stepFrame()
{
LLFrameTimer::updateFrameTime();
+ LLFrameTimer::updateFrameCount();
LLEventTimer::updateClass();
mRunner.run();
}
diff --git a/indra/llcommon/llframetimer.cpp b/indra/llcommon/llframetimer.cpp
index b74151bc2a..a61c5bda81 100644
--- a/indra/llcommon/llframetimer.cpp
+++ b/indra/llcommon/llframetimer.cpp
@@ -53,7 +53,6 @@ void LLFrameTimer::updateFrameTime()
sTotalTime = total_time;
sTotalSeconds = U64_to_F64(sTotalTime) * USEC_TO_SEC_F64;
sFrameTime = U64_to_F64(sTotalTime - sStartTotalTime) * USEC_TO_SEC_F64;
- sFrameCount++;
}
void LLFrameTimer::start()
diff --git a/indra/llcommon/llframetimer.h b/indra/llcommon/llframetimer.h
index 2998560ab9..7ef92f64e4 100644
--- a/indra/llcommon/llframetimer.h
+++ b/indra/llcommon/llframetimer.h
@@ -67,10 +67,14 @@ public:
return sTotalSeconds;
}
- // Call this method once per frame to update the current frame time.
+ // Call this method once per frame to update the current frame time. This is actually called
+ // at some other times as well
static void updateFrameTime();
- static S32 getFrameCount() { return sFrameCount; }
+ // Call this method once, and only once, per frame to update the current frame count.
+ static void updateFrameCount() { sFrameCount++; }
+
+ static U32 getFrameCount() { return sFrameCount; }
static F32 getFrameDeltaTimeF32();
diff --git a/indra/llcommon/llkeythrottle.h b/indra/llcommon/llkeythrottle.h
index d831eadd59..61a43b2dad 100644
--- a/indra/llcommon/llkeythrottle.h
+++ b/indra/llcommon/llkeythrottle.h
@@ -68,20 +68,24 @@ protected:
U32 countLimit;
// maximum number of keys allowed per interval
- U64 interval_usec;
- // each map covers this time period
- U64 start_usec;
+ U64 intervalLength; // each map covers this time period (usec or frame number)
+ U64 startTime; // start of the time period (usec or frame number)
+
// currMap started counting at this time
// prevMap covers the previous interval
LLKeyThrottleImpl() : prevMap(0), currMap(0),
- countLimit(0), interval_usec(0),
- start_usec(0) { };
+ countLimit(0), intervalLength(1),
+ startTime(0) { };
static U64 getTime()
{
return LLFrameTimer::getTotalTime();
}
+ static U64 getFrame() // Return the current frame number
+ {
+ return (U64) LLFrameTimer::getFrameCount();
+ }
};
@@ -89,17 +93,10 @@ template< class T >
class LLKeyThrottle
{
public:
- LLKeyThrottle(U32 limit, F32 interval)
+ LLKeyThrottle(U32 limit, F32 interval, BOOL realtime = TRUE) // realtime = FALSE for frame-based throttle, TRUE for usec real-time throttle
: m(* new LLKeyThrottleImpl<T>)
{
- // limit is the maximum number of keys
- // allowed per interval (in seconds)
- m.countLimit = limit;
- m.interval_usec = (U64)(interval * USEC_PER_SEC);
- m.start_usec = LLKeyThrottleImpl<T>::getTime();
-
- m.prevMap = new typename LLKeyThrottleImpl<T>::EntryMap;
- m.currMap = new typename LLKeyThrottleImpl<T>::EntryMap;
+ setParameters( limit, interval, realtime );
}
~LLKeyThrottle()
@@ -118,18 +115,26 @@ public:
// call each time the key wants use
State noteAction(const T& id, S32 weight = 1)
{
- U64 now = LLKeyThrottleImpl<T>::getTime();
+ U64 now = 0;
+ if ( mIsRealtime )
+ {
+ now = LLKeyThrottleImpl<T>::getTime();
+ }
+ else
+ {
+ now = LLKeyThrottleImpl<T>::getFrame();
+ }
- if (now >= (m.start_usec + m.interval_usec))
+ if (now >= (m.startTime + m.intervalLength))
{
- if (now < (m.start_usec + 2 * m.interval_usec))
+ if (now < (m.startTime + 2 * m.intervalLength))
{
// prune old data
delete m.prevMap;
m.prevMap = m.currMap;
m.currMap = new typename LLKeyThrottleImpl<T>::EntryMap;
- m.start_usec += m.interval_usec;
+ m.startTime += m.intervalLength;
}
else
{
@@ -139,7 +144,7 @@ public:
m.prevMap = new typename LLKeyThrottleImpl<T>::EntryMap;
m.currMap = new typename LLKeyThrottleImpl<T>::EntryMap;
- m.start_usec = now;
+ m.startTime = now;
}
}
@@ -166,7 +171,7 @@ public:
// (now) time.
// compute current, windowed rate
- F64 timeInCurrent = ((F64)(now - m.start_usec) / m.interval_usec);
+ F64 timeInCurrent = ((F64)(now - m.startTime) / m.intervalLength);
F64 averageCount = curr.count + prevCount * (1.0 - timeInCurrent);
curr.blocked |= averageCount > m.countLimit;
@@ -224,8 +229,46 @@ public:
return FALSE;
}
+ // Get the throttling parameters
+ void getParameters( U32 & out_limit, F32 & out_interval, BOOL & out_realtime )
+ {
+ out_limit = m.countLimit;
+ out_interval = m.intervalLength;
+ out_realtime = mIsRealtime;
+ }
+
+ // Set the throttling behavior
+ void setParameters( U32 limit, F32 interval, BOOL realtime )
+ {
+ // limit is the maximum number of keys
+ // allowed per interval (in seconds or frames)
+ mIsRealtime = realtime;
+ m.countLimit = limit;
+ if ( mIsRealtime )
+ {
+ m.intervalLength = (U64)(interval * USEC_PER_SEC);
+ m.startTime = LLKeyThrottleImpl<T>::getTime();
+ }
+ else
+ {
+ m.intervalLength = (U64)interval;
+ m.startTime = LLKeyThrottleImpl<T>::getFrame();
+ }
+
+ if ( m.intervalLength == 0 )
+ { // Don't allow zero intervals
+ m.intervalLength = 1;
+ }
+
+ delete m.prevMap;
+ m.prevMap = new typename LLKeyThrottleImpl<T>::EntryMap;
+ delete m.currMap;
+ m.currMap = new typename LLKeyThrottleImpl<T>::EntryMap;
+ }
+
protected:
LLKeyThrottleImpl<T>& m;
+ BOOL mIsRealtime; // TRUE to be time based (default), FALSE for frame based
};
#endif
diff --git a/indra/llcommon/llstring.cpp b/indra/llcommon/llstring.cpp
index 7a2d42dfaa..3a8756a31f 100644
--- a/indra/llcommon/llstring.cpp
+++ b/indra/llcommon/llstring.cpp
@@ -929,6 +929,32 @@ namespace LLStringFn
}
}
}
+
+ // https://wiki.lindenlab.com/wiki/Unicode_Guidelines has details on
+ // allowable code points for XML. Specifically, they are:
+ // 0x09, 0x0a, 0x0d, and 0x20 on up. JC
+ std::string strip_invalid_xml(const std::string& input)
+ {
+ std::string output;
+ output.reserve( input.size() );
+ std::string::const_iterator it = input.begin();
+ while (it != input.end())
+ {
+ // Must compare as unsigned for >=
+ // Test most likely match first
+ const unsigned char c = (unsigned char)*it;
+ if ( c >= (unsigned char)0x20 // SPACE
+ || c == (unsigned char)0x09 // TAB
+ || c == (unsigned char)0x0a // LINE_FEED
+ || c == (unsigned char)0x0d ) // CARRIAGE_RETURN
+ {
+ output.push_back(c);
+ }
+ ++it;
+ }
+ return output;
+ }
+
}
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 8a1e1fe8cb..18cfe4b64c 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -545,6 +545,13 @@ namespace LLStringFn
*/
void replace_nonprintable_and_pipe(std::basic_string<llwchar>& str,
llwchar replacement);
+
+ /**
+ * @brief Remove all characters that are not allowed in XML 1.0.
+ * Returns a copy of the string with those characters removed.
+ * Works with US ASCII and UTF-8 encoded strings. JC
+ */
+ std::string strip_invalid_xml(const std::string& input);
}
////////////////////////////////////////////////////////////
@@ -739,17 +746,9 @@ LLStringBase<T>::LLStringBase(const T* s, size_type n ) : std::basic_string<T>()
// Init from a substring
template<class T>
-LLStringBase<T>::LLStringBase(const T* s, size_type pos, size_type n ) : std::basic_string<T>()
-{
- if( s )
- {
- assign(s + pos, n);
- }
- else
- {
- assign(LLStringBase<T>::null);
- }
-}
+LLStringBase<T>::LLStringBase(const T* s, size_type pos, size_type n )
+: std::basic_string<T>( (s ? s : std::basic_string<T>() ), pos, n )
+{ }
//static
template<class T>
diff --git a/indra/llcommon/llversionserver.h b/indra/llcommon/llversionserver.h
index 291f6d6347..97472ea208 100644
--- a/indra/llcommon/llversionserver.h
+++ b/indra/llcommon/llversionserver.h
@@ -33,9 +33,9 @@
#define LL_LLVERSIONSERVER_H
const S32 LL_VERSION_MAJOR = 1;
-const S32 LL_VERSION_MINOR = 21;
-const S32 LL_VERSION_PATCH = 1;
-const S32 LL_VERSION_BUILD = 86526;
+const S32 LL_VERSION_MINOR = 22;
+const S32 LL_VERSION_PATCH = 2;
+const S32 LL_VERSION_BUILD = 87048;
const char * const LL_CHANNEL = "Second Life Server";
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-12 04:20:35 +0000