__private_extern__ void
asl_client_release(asl_client_t *asl)
{
uint32_t i;
if (asl == NULL) return;
if(OSAtomicDecrement32(&asl->refcount) > 0)
return;
free(asl->name);
free(asl->facility);
if (asl->sock >= 0) close(asl->sock);
if (!(asl->options & ASL_OPT_NO_REMOTE)) _asl_notify_close();
if (asl->fd_list != NULL) free(asl->fd_list);
if (asl->fd_mfmt != NULL)
{
for (i = 0; i < asl->fd_count; i++) if (asl->fd_mfmt[i] != NULL) free(asl->fd_mfmt[i]);
free(asl->fd_mfmt);
}
if (asl->fd_tfmt != NULL)
{
for (i = 0; i < asl->fd_count; i++) if (asl->fd_tfmt[i] != NULL) free(asl->fd_tfmt[i]);
free(asl->fd_tfmt);
}
if (asl->fd_encoding != NULL) free(asl->fd_encoding);
memset(asl, 0, sizeof(asl_client_t));
free(asl);
}
void BufferManager::CopyAudioDataToFFTInputBuffer( Float32* inData, UInt32 numFrames )
{
UInt32 framesToCopy = min(numFrames, mFFTInputBufferLen - mFFTInputBufferFrameIndex);
memcpy(mFFTInputBuffer + mFFTInputBufferFrameIndex, inData, framesToCopy * sizeof(Float32));
mFFTInputBufferFrameIndex += framesToCopy * sizeof(Float32);
if (mFFTInputBufferFrameIndex >= mFFTInputBufferLen) {
OSAtomicIncrement32(&mHasNewFFTData);
OSAtomicDecrement32(&mNeedsNewFFTData);
}
}
//---------
ULONG STDMETHODCALLTYPE DeckLink::Release(void) {
int32_t newRefValue;
newRefValue = OSAtomicDecrement32(&referenceCount);
if (newRefValue == 0)
{
delete this;
return 0;
}
return newRefValue;
};
unsigned
Atomic::operator--()
{
#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
return __sync_sub_and_fetch(&_value, 1);
#elif defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED)
return InterlockedDecrement(&_value);
#elif defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC)
return OSAtomicDecrement32(&_value);
#else
# error This implementation should happen inline in the include file
#endif
}
NTSTATUS
SMBReleaseServer(
SMBHANDLE inConnection)
{
refcount_t refcount;
refcount = OSAtomicDecrement32(&inConnection->refcount);
if (refcount == 0) {
smb_ctx_done(inConnection->context);
free(inConnection);
}
return STATUS_SUCCESS;
}
void BufferManager::CopyAudioDataToBuffer( Float32* inData, UInt32 NewNumSamples )
{
if (inData == NULL) return;
for (UInt32 i=0; i<NewNumSamples; i++)
{
if (i + _CurDataIdx >= _BufferLen)
_CurDataIdx = -i;
_AudioDataBuffer[i + _CurDataIdx] = inData[i];
}
_CurDataIdx += NewNumSamples;
// The following segment of codes assume that GetFFTOuput() is being continuously called!
if (_FFTStartIdx < _FFTEndIdx)
{
if (_FFTEndIdx < _CurDataIdx && NeedsNewFFTData())
{
//printf("_CurDataIdx: %ld\n", _CurDataIdx);
OSAtomicIncrement32(&_HasNewFFTData);
OSAtomicDecrement32(&_NeedsNewFFTData);
}
}
else if (_FFTEndIdx < _FFTStartIdx)
{
if (_FFTEndIdx < _CurDataIdx && _CurDataIdx < _FFTStartIdx && NeedsNewFFTData())
{
//printf("_CurDataIdx: %ld\n", _CurDataIdx);
OSAtomicIncrement32(&_HasNewFFTData);
OSAtomicDecrement32(&_NeedsNewFFTData);
}
}
else
printf("BufferManager::CopyAudioDataToBuffer() - this code should never execute!");
}
int asAtomicDec(int &value)
{
return OSAtomicDecrement32((int32_t*)&value);
}
long InterlockedDecrement(long volatile* Addend) {
return OSAtomicDecrement32(reinterpret_cast<int32_t volatile*>(Addend));
}
static inline void CFNotificationObserverRelease(CFAllocatorRef allocator,CFNotificationObserver *observer) {
if (OSAtomicDecrement32(&observer->retainCount) < 0) {
CFRelease(observer->name);
free(observer);
}
}
asDWORD asCAtomic::atomicDec()
{
return OSAtomicDecrement32((int32_t*)&value);
}
inline euint32 AtomicDecrement(volatile esint32* i)
{
return OSAtomicDecrement32(i);
}
template <typename T> static T dec(volatile T*scalar) {
return (T)OSAtomicDecrement32((int32*)scalar);
}
