Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 608 insertions, 608 deletions

diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index b1ddfc952c..8a8451b927 100644
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -1,608 +1,608 @@
-/** 
- * @file lltimer.cpp
- * @brief Cross-platform objects for doing timing 
- *
- * $LicenseInfo:firstyear=2000&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$
- */
-
-#include "linden_common.h"
-
-#include "lltimer.h"
-
-#include "u64.h"
-
-#include <chrono>
-#include <thread>
-
-#if LL_WINDOWS
-#	include "llwin32headerslean.h"
-#elif LL_LINUX || LL_DARWIN
-#   include <errno.h>
-#	include <sys/time.h>
-#else 
-#	error "architecture not supported"
-#endif
-
-//
-// Locally used constants
-//
-const U64 SEC_TO_MICROSEC_U64 = 1000000;
-
-//---------------------------------------------------------------------------
-// Globals and statics
-//---------------------------------------------------------------------------
-
-S32 gUTCOffset = 0; // viewer's offset from server UTC, in seconds
-LLTimer* LLTimer::sTimer = NULL;
-
-
-//
-// Forward declarations
-//
-
-
-//---------------------------------------------------------------------------
-// Implementation
-//---------------------------------------------------------------------------
-
-#if LL_WINDOWS
-
-
-#if 0
-void ms_sleep(U32 ms)
-{
-    LL_PROFILE_ZONE_SCOPED;
-    using TimePoint = std::chrono::steady_clock::time_point;
-    auto resume_time = TimePoint::clock::now() + std::chrono::milliseconds(ms);
-    while (TimePoint::clock::now() < resume_time)
-    {
-        std::this_thread::yield(); //note: don't use LLThread::yield here to avoid yielding for too long
-    }
-}
-
-U32 micro_sleep(U64 us, U32 max_yields)
-{
-    // max_yields is unused; just fiddle with it to avoid warnings.
-    max_yields = 0;
-	ms_sleep((U32)(us / 1000));
-    return 0;
-}
-
-#else
-
-U32 micro_sleep(U64 us, U32 max_yields)
-{
-    LL_PROFILE_ZONE_SCOPED
-#if 0
-    LARGE_INTEGER ft;
-    ft.QuadPart = -static_cast<S64>(us * 10);  // '-' using relative time
-
-    HANDLE timer = CreateWaitableTimer(NULL, true, NULL);
-    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
-    WaitForSingleObject(timer, INFINITE);
-    CloseHandle(timer);
-#else
-    Sleep(us / 1000);
-#endif
-
-    return 0;
-}
-
-void ms_sleep(U32 ms)
-{
-    LL_PROFILE_ZONE_SCOPED
-    micro_sleep(ms * 1000, 0);
-}
-
-#endif
-
-#elif LL_LINUX || LL_DARWIN
-static void _sleep_loop(struct timespec& thiswait)
-{
-	struct timespec nextwait;
-	bool sleep_more = false;
-
-	do {
-		int result = nanosleep(&thiswait, &nextwait);
-
-		// check if sleep was interrupted by a signal; unslept
-		// remainder was written back into 't' and we just nanosleep
-		// again.
-		sleep_more = (result == -1 && EINTR == errno);
-
-		if (sleep_more)
-		{
-			if ( nextwait.tv_sec > thiswait.tv_sec ||
-			     (nextwait.tv_sec == thiswait.tv_sec &&
-			      nextwait.tv_nsec >= thiswait.tv_nsec) )
-			{
-				// if the remaining time isn't actually going
-				// down then we're being shafted by low clock
-				// resolution - manually massage the sleep time
-				// downward.
-				if (nextwait.tv_nsec > 1000000) {
-					// lose 1ms
-					nextwait.tv_nsec -= 1000000;
-				} else {
-					if (nextwait.tv_sec == 0) {
-						// already so close to finished
-						sleep_more = false;
-					} else {
-						// lose up to 1ms
-						nextwait.tv_nsec = 0;
-					}
-				}
-			}
-			thiswait = nextwait;
-		}
-	} while (sleep_more);
-}
-
-U32 micro_sleep(U64 us, U32 max_yields)
-{
-    U64 start = get_clock_count();
-    // This is kernel dependent.  Currently, our kernel generates software clock
-    // interrupts at 250 Hz (every 4,000 microseconds).
-    const S64 KERNEL_SLEEP_INTERVAL_US = 4000;
-
-    // Use signed arithmetic to discover whether a sleep is even necessary. If
-    // either 'us' or KERNEL_SLEEP_INTERVAL_US is unsigned, the compiler
-    // promotes the difference to unsigned. If 'us' is less than half
-    // KERNEL_SLEEP_INTERVAL_US, the unsigned difference will be hugely
-    // positive, resulting in a crazy long wait.
-    auto num_sleep_intervals = (S64(us) - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
-    if (num_sleep_intervals > 0)
-    {
-        U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);
-        struct timespec thiswait;
-        thiswait.tv_sec = sleep_time / 1000000;
-        thiswait.tv_nsec = (sleep_time % 1000000) * 1000l;
-        _sleep_loop(thiswait);
-    }
-
-    U64 current_clock = get_clock_count();
-    U32 yields = 0;
-    while (    (yields < max_yields)
-            && (current_clock - start < us) )
-    {
-        sched_yield();
-        ++yields;
-        current_clock = get_clock_count();
-    }
-    return yields;
-}
-
-void ms_sleep(U32 ms)
-{
-	long mslong = ms; // tv_nsec is a long
-	struct timespec thiswait;
-	thiswait.tv_sec = ms / 1000;
-	thiswait.tv_nsec = (mslong % 1000) * 1000000l;
-    _sleep_loop(thiswait);
-}
-#else
-# error "architecture not supported"
-#endif
-
-//
-// CPU clock/other clock frequency and count functions
-//
-
-#if LL_WINDOWS
-U64 get_clock_count()
-{
-	static bool firstTime = true;
-	static U64 offset;
-		// ensures that callers to this function never have to deal with wrap
-
-	// QueryPerformanceCounter implementation
-	LARGE_INTEGER clock_count;
-	QueryPerformanceCounter(&clock_count);
-	if (firstTime) {
-		offset = clock_count.QuadPart;
-		firstTime = false;
-	}
-	return clock_count.QuadPart - offset;
-}
-
-F64 calc_clock_frequency()
-{
-	__int64 freq;
-	QueryPerformanceFrequency((LARGE_INTEGER *) &freq);
-	return (F64)freq;
-}
-#endif // LL_WINDOWS
-
-
-#if LL_LINUX || LL_DARWIN
-// Both Linux and Mac use gettimeofday for accurate time
-F64 calc_clock_frequency()
-{
-	return 1000000.0; // microseconds, so 1 MHz.
-}
-
-U64 get_clock_count()
-{
-	// Linux clocks are in microseconds
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	return tv.tv_sec*SEC_TO_MICROSEC_U64 + tv.tv_usec;
-}
-#endif
-
-
-TimerInfo::TimerInfo()
-:	mClockFrequency(0.0),
-	mTotalTimeClockCount(0),
-	mLastTotalTimeClockCount(0)
-{}
-
-void TimerInfo::update()
-{
-	mClockFrequency = calc_clock_frequency();
-	mClockFrequencyInv = 1.0/mClockFrequency;
-	mClocksToMicroseconds = mClockFrequencyInv;
-}
-
-TimerInfo& get_timer_info()
-{
-	static TimerInfo sTimerInfo;
-	return sTimerInfo;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-// returns a U64 number that represents the number of 
-// microseconds since the Unix epoch - Jan 1, 1970
-U64MicrosecondsImplicit totalTime()
-{
-	U64 current_clock_count = get_clock_count();
-	if (!get_timer_info().mTotalTimeClockCount || get_timer_info().mClocksToMicroseconds.value() == 0)
-	{
-		get_timer_info().update();
-		get_timer_info().mTotalTimeClockCount = current_clock_count;
-
-#if LL_WINDOWS
-		// Sync us up with local time (even though we PROBABLY don't need to, this is how it was implemented)
-		// Unix platforms use gettimeofday so they are synced, although this probably isn't a good assumption to
-		// make in the future.
-
-		get_timer_info().mTotalTimeClockCount = (U64)(time(NULL) * get_timer_info().mClockFrequency);
-#endif
-
-		// Update the last clock count
-		get_timer_info().mLastTotalTimeClockCount = current_clock_count;
-	}
-	else
-	{
-		if (current_clock_count >= get_timer_info().mLastTotalTimeClockCount)
-		{
-			// No wrapping, we're all okay.
-			get_timer_info().mTotalTimeClockCount += current_clock_count - get_timer_info().mLastTotalTimeClockCount;
-		}
-		else
-		{
-			// We've wrapped.  Compensate correctly
-			get_timer_info().mTotalTimeClockCount += (0xFFFFFFFFFFFFFFFFULL - get_timer_info().mLastTotalTimeClockCount) + current_clock_count;
-		}
-
-		// Update the last clock count
-		get_timer_info().mLastTotalTimeClockCount = current_clock_count;
-	}
-
-	// Return the total clock tick count in microseconds.
-	U64Microseconds time(get_timer_info().mTotalTimeClockCount*get_timer_info().mClocksToMicroseconds);
-	return time;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-LLTimer::LLTimer()
-{
-	if (!get_timer_info().mClockFrequency)
-	{
-		get_timer_info().update();
-	}
-
-	mStarted = true;
-	reset();
-}
-
-LLTimer::~LLTimer()
-{}
-
-// static
-void LLTimer::initClass()
-{
-	if (!sTimer) sTimer = new LLTimer;
-}
-
-// static
-void LLTimer::cleanupClass()
-{
-	delete sTimer; sTimer = NULL;
-}
-
-// static
-U64MicrosecondsImplicit LLTimer::getTotalTime()
-{
-	// simply call into the implementation function.
-	U64MicrosecondsImplicit total_time = totalTime();
-	return total_time;
-}	
-
-// static
-F64SecondsImplicit LLTimer::getTotalSeconds()
-{
-	return F64Microseconds(U64_to_F64(getTotalTime()));
-}
-
-void LLTimer::reset()
-{
-	mLastClockCount = get_clock_count();
-	mExpirationTicks = 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-U64 LLTimer::getCurrentClockCount()
-{
-	return get_clock_count();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void LLTimer::setLastClockCount(U64 current_count)
-{
-	mLastClockCount = current_count;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static
-U64 getElapsedTimeAndUpdate(U64& lastClockCount)
-{
-	U64 current_clock_count = get_clock_count();
-	U64 result;
-
-	if (current_clock_count >= lastClockCount)
-	{
-		result = current_clock_count - lastClockCount;
-	}
-	else
-	{
-		// time has gone backward
-		result = 0;
-	}
-
-	lastClockCount = current_clock_count;
-
-	return result;
-}
-
-
-F64SecondsImplicit LLTimer::getElapsedTimeF64() const
-{
-	U64 last = mLastClockCount;
-	return (F64)getElapsedTimeAndUpdate(last) * get_timer_info().mClockFrequencyInv;
-}
-
-F32SecondsImplicit LLTimer::getElapsedTimeF32() const
-{
-	return (F32)getElapsedTimeF64();
-}
-
-F64SecondsImplicit LLTimer::getElapsedTimeAndResetF64()
-{
-	return (F64)getElapsedTimeAndUpdate(mLastClockCount) * get_timer_info().mClockFrequencyInv;
-}
-
-F32SecondsImplicit LLTimer::getElapsedTimeAndResetF32()
-{
-	return (F32)getElapsedTimeAndResetF64();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void LLTimer::setTimerExpirySec(F32SecondsImplicit expiration)
-{
-	mExpirationTicks = get_clock_count()
-		+ (U64)((F32)(expiration * get_timer_info().mClockFrequency.value()));
-}
-
-F32SecondsImplicit LLTimer::getRemainingTimeF32() const
-{
-	U64 cur_ticks = get_clock_count();
-	if (cur_ticks > mExpirationTicks)
-	{
-		return 0.0f;
-	}
-	return F32((mExpirationTicks - cur_ticks) * get_timer_info().mClockFrequencyInv);
-}
-
-
-bool LLTimer::checkExpirationAndReset(F32 expiration)
-{
-	U64 cur_ticks = get_clock_count();
-	if (cur_ticks < mExpirationTicks)
-	{
-		return false;
-	}
-
-	mExpirationTicks = cur_ticks
-		+ (U64)((F32)(expiration * get_timer_info().mClockFrequency));
-	return true;
-}
-
-
-bool LLTimer::hasExpired() const
-{
-	return get_clock_count() >= mExpirationTicks;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-bool LLTimer::knownBadTimer()
-{
-	bool failed = false;
-
-#if LL_WINDOWS
-	WCHAR bad_pci_list[][10] = {L"1039:0530",
-						        L"1039:0620",
-							    L"10B9:0533",
-							    L"10B9:1533",
-							    L"1106:0596",
-							    L"1106:0686",
-							    L"1166:004F",
-							    L"1166:0050",
- 							    L"8086:7110",
-							    L"\0"
-	};
-
-	HKEY hKey = NULL;
-	LONG nResult = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"SYSTEM\\CurrentControlSet\\Enum\\PCI", 0,
-								  KEY_EXECUTE | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hKey);
-	
-	WCHAR name[1024];
-	DWORD name_len = 1024;
-	FILETIME scrap;
-
-	S32 key_num = 0;
-	WCHAR pci_id[10];
-
-	wcscpy(pci_id, L"0000:0000");	 /*Flawfinder: ignore*/
-
-	while (nResult == ERROR_SUCCESS)
-	{
-		nResult = ::RegEnumKeyEx(hKey, key_num++, name, &name_len, NULL, NULL, NULL, &scrap);
-
-		if (nResult == ERROR_SUCCESS)
-		{
-			memcpy(&pci_id[0],&name[4],4);		/* Flawfinder: ignore */
-			memcpy(&pci_id[5],&name[13],4);		/* Flawfinder: ignore */
-
-			for (S32 check = 0; bad_pci_list[check][0]; check++)
-			{
-				if (!wcscmp(pci_id, bad_pci_list[check]))
-				{
-//					LL_WARNS() << "unreliable PCI chipset found!! " << pci_id << endl;
-					failed = true;
-					break;
-				}
-			}
-//			llinfo << "PCI chipset found: " << pci_id << endl;
-			name_len = 1024;
-		}
-	}
-#endif
-	return(failed);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// 
-// NON-MEMBER FUNCTIONS
-//
-///////////////////////////////////////////////////////////////////////////////
-
-time_t time_corrected()
-{
-	return time(NULL) + gUTCOffset;
-}
-
-
-// Is the current computer (in its current time zone)
-// observing daylight savings time?
-bool is_daylight_savings()
-{
-	time_t now = time(NULL);
-
-	// Internal buffer to local server time
-	struct tm* internal_time = localtime(&now);
-
-	// tm_isdst > 0  =>  daylight savings
-	// tm_isdst = 0  =>  not daylight savings
-	// tm_isdst < 0  =>  can't tell
-	return (internal_time->tm_isdst > 0);
-}
-
-
-struct tm* utc_to_pacific_time(time_t utc_time, bool pacific_daylight_time)
-{
-	S32Hours pacific_offset_hours;
-	if (pacific_daylight_time)
-	{
-		pacific_offset_hours = S32Hours(7);
-	}
-	else
-	{
-		pacific_offset_hours = S32Hours(8);
-	}
-
-	// We subtract off the PST/PDT offset _before_ getting
-	// "UTC" time, because this will handle wrapping around
-	// for 5 AM UTC -> 10 PM PDT of the previous day.
-	utc_time -= S32SecondsImplicit(pacific_offset_hours);
- 
-	// Internal buffer to PST/PDT (see above)
-	struct tm* internal_time = gmtime(&utc_time);
-
-	/*
-	// Don't do this, this won't correctly tell you if daylight savings is active in CA or not.
-	if (pacific_daylight_time)
-	{
-		internal_time->tm_isdst = 1;
-	}
-	*/
-
-	return internal_time;
-}
-
-
-void microsecondsToTimecodeString(U64MicrosecondsImplicit current_time, std::string& tcstring)
-{
-	U64 hours;
-	U64 minutes;
-	U64 seconds;
-	U64 frames;
-	U64 subframes;
-
-	hours = current_time / (U64)3600000000ul;
-	minutes = current_time / (U64)60000000;
-	minutes %= 60;
-	seconds = current_time / (U64)1000000;
-	seconds %= 60;
-	frames = current_time / (U64)41667;
-	frames %= 24;
-	subframes = current_time / (U64)42;
-	subframes %= 100;
-
-	tcstring = llformat("%3.3d:%2.2d:%2.2d:%2.2d.%2.2d",(int)hours,(int)minutes,(int)seconds,(int)frames,(int)subframes);
-}
-
-
-void secondsToTimecodeString(F32SecondsImplicit current_time, std::string& tcstring)
-{
-	microsecondsToTimecodeString(current_time, tcstring);
-}
-
-
+/**

+ * @file lltimer.cpp

+ * @brief Cross-platform objects for doing timing

+ *

+ * $LicenseInfo:firstyear=2000&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$

+ */

+

+#include "linden_common.h"

+

+#include "lltimer.h"

+

+#include "u64.h"

+

+#include <chrono>

+#include <thread>

+

+#if LL_WINDOWS

+#   include "llwin32headerslean.h"

+#elif LL_LINUX || LL_DARWIN

+#   include <errno.h>

+#   include <sys/time.h>

+#else

+#   error "architecture not supported"

+#endif

+

+//

+// Locally used constants

+//

+const U64 SEC_TO_MICROSEC_U64 = 1000000;

+

+//---------------------------------------------------------------------------

+// Globals and statics

+//---------------------------------------------------------------------------

+

+S32 gUTCOffset = 0; // viewer's offset from server UTC, in seconds

+LLTimer* LLTimer::sTimer = NULL;

+

+

+//

+// Forward declarations

+//

+

+

+//---------------------------------------------------------------------------

+// Implementation

+//---------------------------------------------------------------------------

+

+#if LL_WINDOWS

+

+

+#if 0

+void ms_sleep(U32 ms)

+{

+    LL_PROFILE_ZONE_SCOPED;

+    using TimePoint = std::chrono::steady_clock::time_point;

+    auto resume_time = TimePoint::clock::now() + std::chrono::milliseconds(ms);

+    while (TimePoint::clock::now() < resume_time)

+    {

+        std::this_thread::yield(); //note: don't use LLThread::yield here to avoid yielding for too long

+    }

+}

+

+U32 micro_sleep(U64 us, U32 max_yields)

+{

+    // max_yields is unused; just fiddle with it to avoid warnings.

+    max_yields = 0;

+    ms_sleep((U32)(us / 1000));

+    return 0;

+}

+

+#else

+

+U32 micro_sleep(U64 us, U32 max_yields)

+{

+    LL_PROFILE_ZONE_SCOPED

+#if 0

+    LARGE_INTEGER ft;

+    ft.QuadPart = -static_cast<S64>(us * 10);  // '-' using relative time

+

+    HANDLE timer = CreateWaitableTimer(NULL, true, NULL);

+    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);

+    WaitForSingleObject(timer, INFINITE);

+    CloseHandle(timer);

+#else

+    Sleep(us / 1000);

+#endif

+

+    return 0;

+}

+

+void ms_sleep(U32 ms)

+{

+    LL_PROFILE_ZONE_SCOPED

+    micro_sleep(ms * 1000, 0);

+}

+

+#endif

+

+#elif LL_LINUX || LL_DARWIN

+static void _sleep_loop(struct timespec& thiswait)

+{

+    struct timespec nextwait;

+    bool sleep_more = false;

+

+    do {

+        int result = nanosleep(&thiswait, &nextwait);

+

+        // check if sleep was interrupted by a signal; unslept

+        // remainder was written back into 't' and we just nanosleep

+        // again.

+        sleep_more = (result == -1 && EINTR == errno);

+

+        if (sleep_more)

+        {

+            if ( nextwait.tv_sec > thiswait.tv_sec ||

+                 (nextwait.tv_sec == thiswait.tv_sec &&

+                  nextwait.tv_nsec >= thiswait.tv_nsec) )

+            {

+                // if the remaining time isn't actually going

+                // down then we're being shafted by low clock

+                // resolution - manually massage the sleep time

+                // downward.

+                if (nextwait.tv_nsec > 1000000) {

+                    // lose 1ms

+                    nextwait.tv_nsec -= 1000000;

+                } else {

+                    if (nextwait.tv_sec == 0) {

+                        // already so close to finished

+                        sleep_more = false;

+                    } else {

+                        // lose up to 1ms

+                        nextwait.tv_nsec = 0;

+                    }

+                }

+            }

+            thiswait = nextwait;

+        }

+    } while (sleep_more);

+}

+

+U32 micro_sleep(U64 us, U32 max_yields)

+{

+    U64 start = get_clock_count();

+    // This is kernel dependent.  Currently, our kernel generates software clock

+    // interrupts at 250 Hz (every 4,000 microseconds).

+    const S64 KERNEL_SLEEP_INTERVAL_US = 4000;

+

+    // Use signed arithmetic to discover whether a sleep is even necessary. If

+    // either 'us' or KERNEL_SLEEP_INTERVAL_US is unsigned, the compiler

+    // promotes the difference to unsigned. If 'us' is less than half

+    // KERNEL_SLEEP_INTERVAL_US, the unsigned difference will be hugely

+    // positive, resulting in a crazy long wait.

+    auto num_sleep_intervals = (S64(us) - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;

+    if (num_sleep_intervals > 0)

+    {

+        U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);

+        struct timespec thiswait;

+        thiswait.tv_sec = sleep_time / 1000000;

+        thiswait.tv_nsec = (sleep_time % 1000000) * 1000l;

+        _sleep_loop(thiswait);

+    }

+

+    U64 current_clock = get_clock_count();

+    U32 yields = 0;

+    while (    (yields < max_yields)

+            && (current_clock - start < us) )

+    {

+        sched_yield();

+        ++yields;

+        current_clock = get_clock_count();

+    }

+    return yields;

+}

+

+void ms_sleep(U32 ms)

+{

+    long mslong = ms; // tv_nsec is a long

+    struct timespec thiswait;

+    thiswait.tv_sec = ms / 1000;

+    thiswait.tv_nsec = (mslong % 1000) * 1000000l;

+    _sleep_loop(thiswait);

+}

+#else

+# error "architecture not supported"

+#endif

+

+//

+// CPU clock/other clock frequency and count functions

+//

+

+#if LL_WINDOWS

+U64 get_clock_count()

+{

+    static bool firstTime = true;

+    static U64 offset;

+        // ensures that callers to this function never have to deal with wrap

+

+    // QueryPerformanceCounter implementation

+    LARGE_INTEGER clock_count;

+    QueryPerformanceCounter(&clock_count);

+    if (firstTime) {

+        offset = clock_count.QuadPart;

+        firstTime = false;

+    }

+    return clock_count.QuadPart - offset;

+}

+

+F64 calc_clock_frequency()

+{

+    __int64 freq;

+    QueryPerformanceFrequency((LARGE_INTEGER *) &freq);

+    return (F64)freq;

+}

+#endif // LL_WINDOWS

+

+

+#if LL_LINUX || LL_DARWIN

+// Both Linux and Mac use gettimeofday for accurate time

+F64 calc_clock_frequency()

+{

+    return 1000000.0; // microseconds, so 1 MHz.

+}

+

+U64 get_clock_count()

+{

+    // Linux clocks are in microseconds

+    struct timeval tv;

+    gettimeofday(&tv, NULL);

+    return tv.tv_sec*SEC_TO_MICROSEC_U64 + tv.tv_usec;

+}

+#endif

+

+

+TimerInfo::TimerInfo()

+:   mClockFrequency(0.0),

+    mTotalTimeClockCount(0),

+    mLastTotalTimeClockCount(0)

+{}

+

+void TimerInfo::update()

+{

+    mClockFrequency = calc_clock_frequency();

+    mClockFrequencyInv = 1.0/mClockFrequency;

+    mClocksToMicroseconds = mClockFrequencyInv;

+}

+

+TimerInfo& get_timer_info()

+{

+    static TimerInfo sTimerInfo;

+    return sTimerInfo;

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+// returns a U64 number that represents the number of

+// microseconds since the Unix epoch - Jan 1, 1970

+U64MicrosecondsImplicit totalTime()

+{

+    U64 current_clock_count = get_clock_count();

+    if (!get_timer_info().mTotalTimeClockCount || get_timer_info().mClocksToMicroseconds.value() == 0)

+    {

+        get_timer_info().update();

+        get_timer_info().mTotalTimeClockCount = current_clock_count;

+

+#if LL_WINDOWS

+        // Sync us up with local time (even though we PROBABLY don't need to, this is how it was implemented)

+        // Unix platforms use gettimeofday so they are synced, although this probably isn't a good assumption to

+        // make in the future.

+

+        get_timer_info().mTotalTimeClockCount = (U64)(time(NULL) * get_timer_info().mClockFrequency);

+#endif

+

+        // Update the last clock count

+        get_timer_info().mLastTotalTimeClockCount = current_clock_count;

+    }

+    else

+    {

+        if (current_clock_count >= get_timer_info().mLastTotalTimeClockCount)

+        {

+            // No wrapping, we're all okay.

+            get_timer_info().mTotalTimeClockCount += current_clock_count - get_timer_info().mLastTotalTimeClockCount;

+        }

+        else

+        {

+            // We've wrapped.  Compensate correctly

+            get_timer_info().mTotalTimeClockCount += (0xFFFFFFFFFFFFFFFFULL - get_timer_info().mLastTotalTimeClockCount) + current_clock_count;

+        }

+

+        // Update the last clock count

+        get_timer_info().mLastTotalTimeClockCount = current_clock_count;

+    }

+

+    // Return the total clock tick count in microseconds.

+    U64Microseconds time(get_timer_info().mTotalTimeClockCount*get_timer_info().mClocksToMicroseconds);

+    return time;

+}

+

+

+///////////////////////////////////////////////////////////////////////////////

+

+LLTimer::LLTimer()

+{

+    if (!get_timer_info().mClockFrequency)

+    {

+        get_timer_info().update();

+    }

+

+    mStarted = true;

+    reset();

+}

+

+LLTimer::~LLTimer()

+{}

+

+// static

+void LLTimer::initClass()

+{

+    if (!sTimer) sTimer = new LLTimer;

+}

+

+// static

+void LLTimer::cleanupClass()

+{

+    delete sTimer; sTimer = NULL;

+}

+

+// static

+U64MicrosecondsImplicit LLTimer::getTotalTime()

+{

+    // simply call into the implementation function.

+    U64MicrosecondsImplicit total_time = totalTime();

+    return total_time;

+}

+

+// static

+F64SecondsImplicit LLTimer::getTotalSeconds()

+{

+    return F64Microseconds(U64_to_F64(getTotalTime()));

+}

+

+void LLTimer::reset()

+{

+    mLastClockCount = get_clock_count();

+    mExpirationTicks = 0;

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+U64 LLTimer::getCurrentClockCount()

+{

+    return get_clock_count();

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+void LLTimer::setLastClockCount(U64 current_count)

+{

+    mLastClockCount = current_count;

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+static

+U64 getElapsedTimeAndUpdate(U64& lastClockCount)

+{

+    U64 current_clock_count = get_clock_count();

+    U64 result;

+

+    if (current_clock_count >= lastClockCount)

+    {

+        result = current_clock_count - lastClockCount;

+    }

+    else

+    {

+        // time has gone backward

+        result = 0;

+    }

+

+    lastClockCount = current_clock_count;

+

+    return result;

+}

+

+

+F64SecondsImplicit LLTimer::getElapsedTimeF64() const

+{

+    U64 last = mLastClockCount;

+    return (F64)getElapsedTimeAndUpdate(last) * get_timer_info().mClockFrequencyInv;

+}

+

+F32SecondsImplicit LLTimer::getElapsedTimeF32() const

+{

+    return (F32)getElapsedTimeF64();

+}

+

+F64SecondsImplicit LLTimer::getElapsedTimeAndResetF64()

+{

+    return (F64)getElapsedTimeAndUpdate(mLastClockCount) * get_timer_info().mClockFrequencyInv;

+}

+

+F32SecondsImplicit LLTimer::getElapsedTimeAndResetF32()

+{

+    return (F32)getElapsedTimeAndResetF64();

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+void LLTimer::setTimerExpirySec(F32SecondsImplicit expiration)

+{

+    mExpirationTicks = get_clock_count()

+        + (U64)((F32)(expiration * get_timer_info().mClockFrequency.value()));

+}

+

+F32SecondsImplicit LLTimer::getRemainingTimeF32() const

+{

+    U64 cur_ticks = get_clock_count();

+    if (cur_ticks > mExpirationTicks)

+    {

+        return 0.0f;

+    }

+    return F32((mExpirationTicks - cur_ticks) * get_timer_info().mClockFrequencyInv);

+}

+

+

+bool LLTimer::checkExpirationAndReset(F32 expiration)

+{

+    U64 cur_ticks = get_clock_count();

+    if (cur_ticks < mExpirationTicks)

+    {

+        return false;

+    }

+

+    mExpirationTicks = cur_ticks

+        + (U64)((F32)(expiration * get_timer_info().mClockFrequency));

+    return true;

+}

+

+

+bool LLTimer::hasExpired() const

+{

+    return get_clock_count() >= mExpirationTicks;

+}

+

+///////////////////////////////////////////////////////////////////////////////

+

+bool LLTimer::knownBadTimer()

+{

+    bool failed = false;

+

+#if LL_WINDOWS

+    WCHAR bad_pci_list[][10] = {L"1039:0530",

+                                L"1039:0620",

+                                L"10B9:0533",

+                                L"10B9:1533",

+                                L"1106:0596",

+                                L"1106:0686",

+                                L"1166:004F",

+                                L"1166:0050",

+                                L"8086:7110",

+                                L"\0"

+    };

+

+    HKEY hKey = NULL;

+    LONG nResult = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"SYSTEM\\CurrentControlSet\\Enum\\PCI", 0,

+                                  KEY_EXECUTE | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hKey);

+

+    WCHAR name[1024];

+    DWORD name_len = 1024;

+    FILETIME scrap;

+

+    S32 key_num = 0;

+    WCHAR pci_id[10];

+

+    wcscpy(pci_id, L"0000:0000");    /*Flawfinder: ignore*/

+

+    while (nResult == ERROR_SUCCESS)

+    {

+        nResult = ::RegEnumKeyEx(hKey, key_num++, name, &name_len, NULL, NULL, NULL, &scrap);

+

+        if (nResult == ERROR_SUCCESS)

+        {

+            memcpy(&pci_id[0],&name[4],4);      /* Flawfinder: ignore */

+            memcpy(&pci_id[5],&name[13],4);     /* Flawfinder: ignore */

+

+            for (S32 check = 0; bad_pci_list[check][0]; check++)

+            {

+                if (!wcscmp(pci_id, bad_pci_list[check]))

+                {

+//                  LL_WARNS() << "unreliable PCI chipset found!! " << pci_id << endl;

+                    failed = true;

+                    break;

+                }

+            }

+//          llinfo << "PCI chipset found: " << pci_id << endl;

+            name_len = 1024;

+        }

+    }

+#endif

+    return(failed);

+}

+

+///////////////////////////////////////////////////////////////////////////////

+//

+// NON-MEMBER FUNCTIONS

+//

+///////////////////////////////////////////////////////////////////////////////

+

+time_t time_corrected()

+{

+    return time(NULL) + gUTCOffset;

+}

+

+

+// Is the current computer (in its current time zone)

+// observing daylight savings time?

+bool is_daylight_savings()

+{

+    time_t now = time(NULL);

+

+    // Internal buffer to local server time

+    struct tm* internal_time = localtime(&now);

+

+    // tm_isdst > 0  =>  daylight savings

+    // tm_isdst = 0  =>  not daylight savings

+    // tm_isdst < 0  =>  can't tell

+    return (internal_time->tm_isdst > 0);

+}

+

+

+struct tm* utc_to_pacific_time(time_t utc_time, bool pacific_daylight_time)

+{

+    S32Hours pacific_offset_hours;

+    if (pacific_daylight_time)

+    {

+        pacific_offset_hours = S32Hours(7);

+    }

+    else

+    {

+        pacific_offset_hours = S32Hours(8);

+    }

+

+    // We subtract off the PST/PDT offset _before_ getting

+    // "UTC" time, because this will handle wrapping around

+    // for 5 AM UTC -> 10 PM PDT of the previous day.

+    utc_time -= S32SecondsImplicit(pacific_offset_hours);

+

+    // Internal buffer to PST/PDT (see above)

+    struct tm* internal_time = gmtime(&utc_time);

+

+    /*

+    // Don't do this, this won't correctly tell you if daylight savings is active in CA or not.

+    if (pacific_daylight_time)

+    {

+        internal_time->tm_isdst = 1;

+    }

+    */

+

+    return internal_time;

+}

+

+

+void microsecondsToTimecodeString(U64MicrosecondsImplicit current_time, std::string& tcstring)

+{

+    U64 hours;

+    U64 minutes;

+    U64 seconds;

+    U64 frames;

+    U64 subframes;

+

+    hours = current_time / (U64)3600000000ul;

+    minutes = current_time / (U64)60000000;

+    minutes %= 60;

+    seconds = current_time / (U64)1000000;

+    seconds %= 60;

+    frames = current_time / (U64)41667;

+    frames %= 24;

+    subframes = current_time / (U64)42;

+    subframes %= 100;

+

+    tcstring = llformat("%3.3d:%2.2d:%2.2d:%2.2d.%2.2d",(int)hours,(int)minutes,(int)seconds,(int)frames,(int)subframes);

+}

+

+

+void secondsToTimecodeString(F32SecondsImplicit current_time, std::string& tcstring)

+{

+    microsecondsToTimecodeString(current_time, tcstring);

+}

+

+