void SharedLock::ReleaseLock(Lock* plock)
{
    OVR_UNUSED(plock);
    OVR_ASSERT(plock == toLock());

    int oldUseCount, oldUseCount_tmp;

    do {
        oldUseCount = UseCount;
        OVR_ASSERT(oldUseCount != (int)LockInitMarker);

        if (oldUseCount == 1)
        {
            // Initialize marker
            int tmp_one = 1;
            int tmp_LockInitMarker = LockInitMarker;
            if (UseCount.compare_exchange_strong(tmp_one, LockInitMarker))
            {
                Destruct<Lock>(toLock());

                do { }
                while (!UseCount.compare_exchange_weak(tmp_LockInitMarker, 0));

                return;
            }
            continue;
        }

        oldUseCount_tmp = oldUseCount;
    } while (!UseCount.compare_exchange_weak(oldUseCount_tmp, oldUseCount - 1,
        std::memory_order_relaxed));
}

void SharedLock::ReleaseLock(Lock* plock)
{
    OVR_UNUSED(plock);
    OVR_ASSERT((plock = toLock()) != 0);

    int oldUseCount;

    do {
        oldUseCount = UseCount;
        OVR_ASSERT(oldUseCount != LockInitMarker);

        if (oldUseCount == 1)
        {
            // Initialize marker
            if (AtomicOps<int>::CompareAndSet_Sync(&UseCount, 1, LockInitMarker))
            {
                Destruct<Lock>(toLock());

                do { }
                while (!AtomicOps<int>::CompareAndSet_Sync(&UseCount, LockInitMarker, 0));

                return;
            }
            continue;
        }

    } while (!AtomicOps<int>::CompareAndSet_NoSync(&UseCount, oldUseCount, oldUseCount - 1));
}

//==============================
// OvrSliderComponent::OnTouchRelative
eMsgStatus OvrSliderComponent::OnTouchRelative( OvrGuiSys & guiSys, VrFrame const & vrFrame,
		VRMenuObject * self, VRMenuEvent const & event )
{
	OVR_UNUSED( vrFrame );

	return MSG_STATUS_CONSUMED;
}

ULONG WINAPI OVRRiftForContext(PVOID context, HANDLE driverHandle)
{
	OVR_UNUSED( driverHandle );
	OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;

    return con->ChildUid;
}

void OvrVideoMenu::Open_Impl( OvrGuiSys & guiSys )
{
	OVR_UNUSED( guiSys );

	ButtonCoolDown = BUTTON_COOL_DOWN_SECONDS;

	OpenTime = vrapi_GetTimeInSeconds();
}

//-------------------------------------------------------------------------------------
// ***** Texture
// 
Texture::Texture(RenderParams* rp, int fmt, const Sizei texSize,
                 ID3D1xSamplerState* sampler, int samples)
    : pParams(rp), Tex(NULL), TexSv(NULL), TexRtv(NULL), TexDsv(NULL),
    TextureSize(texSize),
    Sampler(sampler),
    Samples(samples)
{
    OVR_UNUSED(fmt);    
}

void PerformanceTimer::Shutdown()
{
    DeleteCriticalSection(&TimeCS);

    #if defined(OVR_OS_WIN32) // Desktop Windows only
        MMRESULT mmr = timeEndPeriod(1);
        OVR_ASSERT(TIMERR_NOERROR == mmr);
        OVR_UNUSED(mmr);
    #endif
}

bool    MutexImpl::IsLockedByAnotherThread(Mutex* pmutex)
{
    OVR_UNUSED(pmutex);
    // There could be multiple interpretations of IsLocked with respect to current thread
    if (LockCount == 0)
        return 0;
    if (pthread_self() != LockedBy)
        return 1;
    return 0;
}

void HIDDevice::OnOverlappedEvent(HANDLE hevent)
{
    OVR_UNUSED(hevent);
    OVR_ASSERT(hevent == ReadOverlapped.hEvent);

    if (processReadResult())
    {
        // Proceed to read again.
        initializeRead();
    }
}

//-----------------------------------------------------------------------------
void HIDDevice::closeDevice(bool wasUnplugged)
{
    OVR_UNUSED(wasUnplugged);
    OVR_ASSERT(DeviceHandle >= 0);
    
    HIDManager->DevManager->pThread->RemoveSelectFd(this,-1);

	hid_close(DeviceHandle);
	DeviceHandle = NULL;
        
    LogText("OVR::Linux::HIDDevice - HID Device Closed '%s'\n", DevDesc.Path.ToCStr());
}

Matrix4f OvrSceneView::GetEyeProjectionMatrix( const int eye, const float fovDegreesX, const float fovDegreesY ) const
{
	OVR_UNUSED( eye );

	// We may want to make per-eye projection matrices if we move away from nearly-centered lenses.
	// Use an infinite projection matrix because, except for things right up against the near plane,
	// it provides better precision:
	//		"Tightening the Precision of Perspective Rendering"
	//		Paul Upchurch, Mathieu Desbrun
	//		Journal of Graphics Tools, Volume 16, Issue 1, 2012
	return ovrMatrix4f_CreateProjectionFov( fovDegreesX, fovDegreesY, 0.0f, 0.0f, Znear, 0.0f );
}

void RefCountNTSImplCore::checkInvalidDelete(RefCountNTSImplCore *pmem)
{
#ifdef OVR_BUILD_DEBUG    
    if (pmem->RefCount != 0)
	{
		OVR_DEBUG_LOG( ("Invalid delete call on ref-counted object at %p. Please use Release()", pmem) );
		OVR_ASSERT(0);
	}
#else
	OVR_UNUSED( pmem );
#endif
}

void MMapFree(void* memory, size_t size)
{
#if defined(OVR_OS_MS)
    OVR_UNUSED(size);
    VirtualFree(memory, 0, MEM_RELEASE);

#elif defined(OVR_OS_MAC) || defined(OVR_OS_UNIX)
    size_t pageSize = getpagesize();
    size = (((size + (pageSize - 1)) / pageSize) * pageSize);
    munmap(memory, size); // Must supply the size to munmap.
#endif
}

String VideoBrowser::GetPanelTitle( OvrGuiSys & guiSys, const OvrMetaDatum & panelData ) const
{
	OVR_UNUSED( guiSys );
	const OvrVideosMetaDatum * const videosDatum = static_cast< const OvrVideosMetaDatum * const >( &panelData );
	if ( videosDatum != NULL )
	{
		String outStr;
		Videos.GetLocale().GetString( videosDatum->Title.ToCStr(), videosDatum->Title.ToCStr(), outStr );
		return outStr;
	}
	return String();
}

void PerformanceTimer::Initialize()
{
    ::InitializeCriticalSection(&TimeCS);
    MMTimeWrapCounter = 0;
    getFrequency();

    #if defined(OVR_OS_WIN32) // Desktop Windows only
	    // Set Vista flag.  On Vista, we can just use QPC() without all the extra work
        OSVERSIONINFOEXW ver;
	    ZeroMemory(&ver, sizeof(OSVERSIONINFOEXW));
	    ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
	    ver.dwMajorVersion = 6; // Vista+

        DWORDLONG condMask = 0;
        VER_SET_CONDITION(condMask, VER_MAJORVERSION, VER_GREATER_EQUAL);

	    // VerifyVersionInfo returns true if the OS meets the conditions set above
	    UsingVistaOrLater = ::VerifyVersionInfoW(&ver, VER_MAJORVERSION, condMask) != 0;
    #else
        UsingVistaOrLater = true;
    #endif

    if (!UsingVistaOrLater)
    {
        #if defined(OVR_OS_WIN32) // Desktop Windows only
            // The following has the effect of setting the NT timer resolution (NtSetTimerResolution) to 1 millisecond.
            MMRESULT mmr = timeBeginPeriod(1);
            OVR_ASSERT(TIMERR_NOERROR == mmr);
            OVR_UNUSED(mmr);
        #endif

        #if defined(OVR_BUILD_DEBUG) && defined(OVR_OS_WIN32)
            HMODULE hNtDll = ::LoadLibraryW(L"NtDll.dll");
            if (hNtDll)
            {
                pNtQueryTimerResolution = (NtQueryTimerResolutionType)::GetProcAddress(hNtDll, "NtQueryTimerResolution");
                //pNtSetTimerResolution = (NtSetTimerResolutionType)::GetProcAddress(hNtDll, "NtSetTimerResolution");

                if (pNtQueryTimerResolution)
                {
                    ULONG MinimumResolution; // in 100-ns units
                    ULONG MaximumResolution;
                    ULONG ActualResolution;
                    pNtQueryTimerResolution(&MinimumResolution, &MaximumResolution, &ActualResolution);
                    OVR_DEBUG_LOG(("NtQueryTimerResolution = Min %ld us, Max %ld us, Current %ld us", MinimumResolution / 10, MaximumResolution / 10, ActualResolution / 10));
                }

                ::FreeLibrary(hNtDll);
            }
        #endif
    }
}

void Log::DefaultLogOutput(const char* formattedText, LogMessageType messageType, int bufferSize)
{
    bool debug = IsDebugMessage(messageType);
    OVR_UNUSED(bufferSize);

#if defined(OVR_OS_WIN32)
    // Under Win32, output regular messages to console if it exists; debug window otherwise.
    static DWORD dummyMode;
    static bool  hasConsole = (GetStdHandle(STD_OUTPUT_HANDLE) != INVALID_HANDLE_VALUE) &&
                              (GetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), &dummyMode));

    if (!hasConsole || debug)
    {
        ::OutputDebugStringA(formattedText);
    }

    fputs(formattedText, stdout);

#elif defined(OVR_OS_MS) // Any other Microsoft OSs

    ::OutputDebugStringA(formattedText);

#elif defined(OVR_OS_ANDROID)
    // To do: use bufferSize to deal with the case that Android has a limited output length.
    __android_log_write(ANDROID_LOG_INFO, "OVR", formattedText);

#else
    fputs(formattedText, stdout);

#endif

    if (messageType == Log_Error)
    {
#if defined(OVR_OS_WIN32)
        if (!ReportEventA(hEventSource, EVENTLOG_ERROR_TYPE, 0, 0, NULL, 1, 0, &formattedText, NULL))
        {
            OVR_ASSERT(false);
        }
#elif defined(OVR_OS_MS) // Any other Microsoft OSs
        // TBD
#elif defined(OVR_OS_ANDROID)
        // TBD
#elif defined(OVR_OS_MAC) || defined(OVR_OS_LINUX)
        syslog(LOG_ERR, "%s", formattedText);
#else
        // TBD
#endif
    }

    // Just in case.
    OVR_UNUSED2(formattedText, debug);
}

void MutexImpl::Unlock(Mutex* pmutex)
{
    OVR_UNUSED(pmutex);

    LockCount--;

    // Release mutex
    if ((Recursive ? ReleaseMutex(hMutexOrSemaphore) :
                     ReleaseSemaphore(hMutexOrSemaphore, 1, NULL))  != 0)
    {
        // This used to call Wait handlers if LockCount == 0.
    }
}

void OculusWorldDemoApp::OnMouseMove(int x, int y, int modifiers)
{
    OVR_UNUSED(y);
    if(modifiers & Mod_MouseRelative)
    {
        // Get Delta
        int dx = x;

        // Apply to rotation. Subtract for right body frame rotation,
        // since yaw rotation is positive CCW when looking down on XZ plane.
        ThePlayer.BodyYaw   -= (Sensitivity * dx) / 360.0f;
    }
}

bool ShaderBase::SetUniformBool(const char* name, int n, const bool* v) 
{
    OVR_UNUSED(n);
    for(unsigned i = 0; i < UniformReflSize; i++)
    {
        if (!strcmp(UniformRefl[i].Name, name))
        {
            memcpy(UniformData + UniformRefl[i].Offset, v, UniformRefl[i].Size);
            return 1;
        }
    }
    return 0;
}

//-------------------------------------------------------------------------------------
// ***** Texture
// 
Texture::Texture(RenderDevice* ren, int fmt, int w, int h) :
    Ren(ren),
    Tex(NULL),
    TexSv(NULL),
    TexRtv(NULL),
    TexDsv(NULL),
    Sampler(NULL),
    Width(w),
    Height(h),
    Samples(0)
{
    OVR_UNUSED(fmt);

    Sampler = Ren->GetSamplerState(0);
}