/*
* Copyright (C) 2026 Linux Studio Plugins Project
* (C) 2026 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 4 янв. 2026 г.
*
* lsp-runtime-lib 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, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib 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 lsp-runtime-lib. If not, see .
*/
#include
#ifdef PLATFORM_WINDOWS
#include
#include
#else
#include
#include
#include
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace ipc
{
#if defined(PLATFORM_WINDOWS)
namespace detail
{
struct condition_t
{
::CRITICAL_SECTION sMutex;
::CONDITION_VARIABLE sCondition;
};
} /* namespace detail */
Condition::Condition()
{
pState = new detail::condition_t;
if (pState != NULL)
{
InitializeCriticalSectionAndSpinCount(&pState->sMutex, 0x10);
InitializeConditionVariable(&pState->sCondition);
}
}
Condition::~Condition()
{
if (pState != NULL)
{
DeleteCriticalSection(&pState->sMutex);
delete pState;
}
}
bool Condition::lock() const
{
if (pState == NULL)
return false;
EnterCriticalSection(&pState->sMutex);
return true;
}
bool Condition::try_lock() const
{
return (pState != NULL) ? TryEnterCriticalSection(&pState->sMutex) : false;
}
bool Condition::unlock() const
{
if (pState == NULL)
return false;
HANDLE thread = reinterpret_cast(GetCurrentThreadId());
if (pState->sMutex.OwningThread != thread)
return false;
if (pState->sMutex.RecursionCount <= 0)
return false;
LeaveCriticalSection(&pState->sMutex);
return true;
}
bool Condition::notify() const
{
if (pState == NULL)
return false;
WakeConditionVariable(&pState->sCondition);
return true;
}
bool Condition::notify_all() const
{
if (pState == NULL)
return false;
WakeAllConditionVariable(&pState->sCondition);
return true;
}
status_t Condition::wait()
{
if (pState == NULL)
return STATUS_BAD_STATE;
if (SleepConditionVariableCS(&pState->sCondition, &pState->sMutex, INFINITE))
return STATUS_OK;
const DWORD result = GetLastError();
return (result == ERROR_TIMEOUT) ? STATUS_TIMED_OUT: STATUS_UNKNOWN_ERR;
}
status_t Condition::wait(system::time_millis_t millis)
{
if (pState == NULL)
return STATUS_BAD_STATE;
do
{
const DWORD timeout = (millis >= INFINITE) ? INFINITE - 1 : DWORD(millis);
if (SleepConditionVariableCS(&pState->sCondition, &pState->sMutex, DWORD(millis)))
return STATUS_OK;
const DWORD result = GetLastError();
if (result != ERROR_TIMEOUT)
return STATUS_UNKNOWN_ERR;
millis -= timeout;
} while (millis > 0);
return STATUS_TIMEOUT;
}
#else
Condition::Condition()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&sMutex, &attr);
pthread_mutexattr_destroy(&attr);
pthread_condattr_t cond_attr;
pthread_condattr_init(&cond_attr);
pthread_cond_init(&sCondition, &cond_attr);
pthread_condattr_destroy(&cond_attr);
}
Condition::~Condition()
{
pthread_cond_destroy(&sCondition);
pthread_mutex_destroy(&sMutex);
}
bool Condition::lock() const
{
while (true)
{
switch (pthread_mutex_lock(&sMutex))
{
case 0: return true;
case EBUSY:
sched_yield();
break;
default: return false;
}
}
}
status_t Condition::wait(system::time_millis_t millis)
{
struct timeval now;
struct timespec deadline;
// Set-up the fire time
gettimeofday(&now, NULL);
deadline.tv_nsec = now.tv_usec * 1000 + (millis % 1000) * 1000000;
deadline.tv_sec = now.tv_sec + (millis / 1000) + (deadline.tv_nsec / 1000000000);
deadline.tv_nsec %= 1000000000;
// Perform wait
int result = pthread_cond_timedwait(&sCondition, &sMutex, &deadline);
switch (result)
{
case 0: return STATUS_OK;
case ETIMEDOUT: return STATUS_TIMED_OUT;
case EPERM: return STATUS_BAD_STATE;
default: break;
}
return STATUS_UNKNOWN_ERR;
}
status_t Condition::wait()
{
int result = pthread_cond_wait(&sCondition, &sMutex);
switch (result)
{
case 0: return STATUS_OK;
case ETIMEDOUT: return STATUS_TIMED_OUT;
case EPERM: return STATUS_BAD_STATE;
default: break;
}
return STATUS_UNKNOWN_ERR;
}
#endif /* PLATFORM_LINUX */
} /* namespace ipc */
} /* namespace lsp */