OSStatus
MD_CriticalRegionEnter(MDCriticalRegionID inCriticalRegionID, Duration inTimeout)
{
MDCriticalRegionDataPtr criticalRegion = (MDCriticalRegionDataPtr)inCriticalRegionID;
MPTaskID currentTaskID = MPCurrentTaskID();
OSStatus err = noErr;
if (criticalRegion == NULL)
return paramErr;
// if I'm inside the critical region...
if (currentTaskID == criticalRegion->mMPTaskID)
{
// bump my depth
criticalRegion->mDepthCount++;
// and continue
return noErr;
}
// wait for the ready semaphore
err = MPWaitOnSemaphore(criticalRegion->mMPSemaphoreID, inTimeout);
// we didn't get it. return the error
if (noErr != err) return err;
// we got it!
criticalRegion->mMPTaskID = currentTaskID;
criticalRegion->mDepthCount = 1;
return noErr;
}
bool cFUSemaphore::Down(uint32 blockTime)
{
#if defined(WIN32)
return WaitForSingleObject(semaphoreHandle, blockTime) == WAIT_OBJECT_0;
#elif defined(FP_APPLE)
return MPWaitOnSemaphore(semaphoreHandle, (blockTime == (uint32)-1) ? kDurationForever : blockTime) == noErr;
#elif defined(LINUX) || defined(ANDROID) || defined(IOS)
if (blockTime == (uint32) -1)
{
return sem_wait(&semaphoreHandle) == 0;
}
else
{
#ifdef IOS
//f**k because I am f*****g lazy to implement this so...
return sem_wait(&semaphoreHandle) == 0;
#else
// The basic POSIX semaphore does not support a block time, but rather a deadline.
timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
deadline.tv_nsec += (blockTime * 1000);
return sem_timedwait(&semaphoreHandle, &deadline) == 0;
#endif
}
#endif
}
static
int buff_wait(struct buffer *buffer)
{
if (MPWaitOnSemaphore(buffer->semaphore, kDurationForever) != noErr) {
audio_error = _("MPWaitOnSemaphore() failed");
return -1;
}
return 0;
}
wxMutexError wxMutexInternal::Lock()
{
wxCHECK_MSG( m_isOk , wxMUTEX_MISC_ERROR , wxT("Invalid Mutex") ) ;
OSStatus err = MPWaitOnSemaphore( m_semaphore, kDurationForever);
if ( err)
{
wxLogSysError(wxT("Could not lock mutex"));
return wxMUTEX_MISC_ERROR;
}
return wxMUTEX_NO_ERROR;
}
wxSemaError wxSemaphoreInternal::WaitTimeout( unsigned long milliseconds )
{
OSStatus err = MPWaitOnSemaphore( m_semaphore, milliseconds );
if (err != noErr)
{
if (err == kMPTimeoutErr)
return wxSEMA_TIMEOUT;
return wxSEMA_MISC_ERROR;
}
return wxSEMA_NO_ERROR;
}
wxMutexError wxMutexInternal::TryLock()
{
wxCHECK_MSG( m_isOk, wxMUTEX_MISC_ERROR, wxT("Invalid Mutex") );
OSStatus err = MPWaitOnSemaphore( m_semaphore, kDurationImmediate );
if (err != noErr)
{
if (err == kMPTimeoutErr)
return wxMUTEX_BUSY;
wxLogSysError( wxT("Could not try lock mutex") );
return wxMUTEX_MISC_ERROR;
}
return wxMUTEX_NO_ERROR;
}
bool hsGlobalSemaphore::Wait(hsMilliseconds timeToWait)
{
Duration duration;
if (timeToWait == kPosInfinity32)
duration = kDurationForever;
else
duration = 0; // THEY DON'T IMPLEMENT delay times yet !!!
OSStatus status = MPWaitOnSemaphore(fSemaId, duration);
/*
if (status == kMPTimeoutErr)
return false;
*/
hsThrowIfOSErr(status);
return true;
}
