void CAudioQueueManager::_HandleOutputBuffer(AudioQueueBufferRef outBuffer) {
if (!_isRunning || _soundQBuffer.SoundCount() == 0) {
outBuffer->mAudioDataByteSize = outBuffer->mAudioDataBytesCapacity;
bzero(outBuffer->mAudioData, outBuffer->mAudioDataBytesCapacity);
} else {
int neededFrames = _framesPerBuffer;
unsigned char* buf = (unsigned char*)outBuffer->mAudioData;
int bytesInBuffer = 0;
for ( ; _soundQBuffer.SoundCount() && neededFrames; neededFrames--) {
short* buffer = _soundQBuffer.DequeueSoundBuffer();
memcpy(buf, buffer, _bytesPerQueueBuffer);
_soundQBuffer.EnqueueFreeBuffer(buffer);
OSAtomicAdd32(-_sampleFrameCount, &_samplesInQueue);
buf += _bytesPerQueueBuffer;
bytesInBuffer += _bytesPerQueueBuffer;
}
outBuffer->mAudioDataByteSize = bytesInBuffer;
#if defined(DEBUG_SOUND)
if (outBuffer->mAudioDataByteSize == 0)
printf("audio buffer underrun.");
else if (outBuffer->mAudioDataByteSize < outBuffer->mAudioDataBytesCapacity)
printf("audio buffer less than capacity %u < %u.", (unsigned int)outBuffer->mAudioDataByteSize, (unsigned int)outBuffer->mAudioDataBytesCapacity);
#endif
}
OSStatus res = AudioQueueEnqueueBuffer(_queue, outBuffer, 0, NULL);
if (res != 0)
throw "Unable to enqueue buffer";
}
int _xadd32(ATOM32* addr,int value){
#if defined(WIN32) || defined(_WIN64)
int old = InterlockedExchangeAdd(addr,value);
return old + value;
#elif __APPLE__
return OSAtomicAdd32(value,addr);
#else
return __sync_add_and_fetch(addr,value);
#endif
}
static inline void dgInterlockedDecrement(dgInt32* Addend)
{
#ifdef _WIN32
InterlockedDecrement((long*) Addend);
#elif defined (__APPLE__)
OSAtomicAdd32 (-1, (int32_t*)Addend);
#else
__sync_fetch_and_sub ((int32_t*)Addend, 1 );
#endif
}
vproc_t
vproc_retain(vproc_t vp)
{
int32_t orig = OSAtomicAdd32(1, &vp->refcount) - 1;
if (orig <= 0) {
_vproc_set_crash_log_message("Under-retain / over-release of vproc_t.");
abort();
}
return vp;
}
vproc_t vproc_retain(vproc_t vp)
{
int32_t orig = OSAtomicAdd32(1, &vp->refcount) - 1;
if( orig <= 0 ) {
/* We've gone from 0 to 1, which means that this object was due to be freed. */
__crashreporter_info__ = "Under-retain / over-release of vproc_t.";
abort();
}
return vp;
}
void vproc_release(vproc_t vp)
{
int32_t newval = OSAtomicAdd32(-1, &vp->refcount);
if( newval < 0 ) {
/* We're in negative numbers, which is bad. */
__crashreporter_info__ = "Over-release of vproc_t.";
abort();
} else if( newval == 0 ) {
mach_port_deallocate(mach_task_self(), vp->j_port);
free(vp);
}
}
void
vproc_release(vproc_t vp)
{
int32_t newval = OSAtomicAdd32(-1, &vp->refcount);
if (newval < 0) {
_vproc_set_crash_log_message("Over-release of vproc_t.");
abort();
} else if (newval == 0) {
mach_port_deallocate(mach_task_self(), vp->j_port);
free(vp);
}
}
inline gint
iris_atomics_fetch_and_add (volatile void *ptr,
gint add)
{
#if DARWIN
return OSAtomicAdd32 (add, ptr);
#elif WIN32
return InterlockedAdd (ptr, add) - add;
#else
return __sync_fetch_and_add ((gint*)ptr, add);
#endif
}
static inline void dInterlockedDecrement(int* const Addend)
{
#if (defined (_POSIX_VER))
__sync_fetch_and_sub ((int32_t*)Addend, 1 );
#endif
#if (defined (_MAC_VER))
OSAtomicAdd32 (-1, (int32_t*)Addend);
#endif
#if (defined (_MSC_VER))
InterlockedDecrement((long*) Addend);
#endif
}
template <typename T> static T add(volatile T* scalar,T other) {
return (T)OSAtomicAdd32((int32)other, (int32*)scalar);
}
void CAudioQueueManager::queueBuffer(short* buffer) {
_soundQBuffer.EnqueueSoundBuffer(buffer);
OSAtomicAdd32(_sampleFrameCount, &_samplesInQueue);
}
int CPLAtomicAdd(volatile int* ptr, int increment)
{
return OSAtomicAdd32(increment, (int*)(ptr));
}
static int atomic_exchange_and_add(sp_counted_base_atomic_type volatile * pw, int dv)
{
// Older versions get non-volatile parameter
return OSAtomicAdd32(dv,const_cast<int32_t *>(&pw->i))-dv;
}
int32_t cxAtomicSubInt32(int32_t *p, int32_t x)
{
return OSAtomicAdd32(-x, p);
}
int32_t cxAtomicAddInt32(int32_t *p, int32_t x)
{
return OSAtomicAdd32(x, p);
}
int32_t TS_AtomicGet(TS_Atomic32 * aToGet){
return OSAtomicAdd32(0, aToGet);
}
int32_t OSAtomicDecrement32(volatile int32_t* target) {
OSAtomicAdd32(-1,target);
}
int32_t OSAtomicIncrement32(volatile int32_t* target) {
OSAtomicAdd32(1,target);
}
int32_t OSAtomicAdd32Barrier(int32_t value,volatile int32_t* target) {
return OSAtomicAdd32(value,target);
}
