static void
si_async_workunit_release(si_async_workunit_t *r)
{
if (r == NULL) return;
if (OSAtomicDecrement32Barrier(&(r->refcount)) != 0) return;
#ifdef CALL_TRACE
fprintf(stderr, "** %s freeing worklist item %p\n", __func__, r);
#endif
si_async_worklist_remove_unit(r);
if (r->resitem != NULL) si_item_release(r->resitem);
if (r->reslist != NULL) si_list_release(r->reslist);
if (r->str1 != NULL) free(r->str1);
if (r->str2 != NULL) free(r->str2);
if (r->str3 != NULL) free(r->str3);
/* release send-once right if it has not been used */
if (r->send != MACH_PORT_NULL) mach_port_deallocate(mach_task_self(), r->send);
/* release receive right */
mach_port_mod_refs(mach_task_self(), r->port, MACH_PORT_RIGHT_RECEIVE, -1);
free(r);
}
void BufferManager::GetFFTOutput( Float32* outFFTData )
{
mFFTHelper->ComputeFFT(mFFTInputBuffer, outFFTData);
mFFTInputBufferFrameIndex = 0;
OSAtomicDecrement32Barrier(&mHasNewFFTData);
OSAtomicIncrement32Barrier(&mNeedsNewFFTData);
}
U_CAPI int32_t U_EXPORT2
umtx_atomic_dec(int32_t *p) {
int32_t retVal;
if (pDecFn) {
retVal = (*pDecFn)(gIncDecContext, p);
} else {
#if !ICU_USE_THREADS
/* ICU thread support compiled out. */
retVal = --(*p);
#elif U_PLATFORM_HAS_WIN32_API
retVal = InterlockedDecrement((LONG*)p);
#elif defined(USE_MAC_OS_ATOMIC_INCREMENT)
retVal = OSAtomicDecrement32Barrier(p);
#elif (U_HAVE_GCC_ATOMICS == 1)
retVal = __sync_sub_and_fetch(p, 1);
#elif defined (POSIX)
umtx_lock(&gIncDecMutex);
retVal = --(*p);
umtx_unlock(&gIncDecMutex);
#else
/* Unknown Platform. */
retVal = --(*p);
#endif
}
return retVal;
}
/**
* Retain or release the list for reading. This method is async-safe.
*
* This must be issued prior to attempting to iterate the list, and must called again once reads have completed.
*
* @param enable If true, the list will be retained. If false, released.
*/
template <typename V> void async_list<V>::set_reading (bool enable) {
if (enable) {
/* Increment and issue a barrier. Once issued, no items will be deallocated while a reference is held. */
OSAtomicIncrement32Barrier(&_refcount);
} else {
/* Increment and issue a barrier. Once issued, items may again be deallocated. */
OSAtomicDecrement32Barrier(&_refcount);
}
}
//------------------------------------------------------------------------
int32 FAtomicDecrement (volatile int32& var)
{
#if WINDOWS
return InterlockedExchangeAdd (&var, -1);
#elif MAC
return OSAtomicDecrement32Barrier (NATIVE_ATOMIC_TYPE &var) + 1;
#else
return var--;
#endif
}
void FFTBufferManager::GrabAudioData(AudioBufferList *inBL)
{
if (mAudioBufferSize < inBL->mBuffers[0].mDataByteSize) return;
UInt32 bytesToCopy = min(inBL->mBuffers[0].mDataByteSize, mAudioBufferSize - mAudioBufferCurrentIndex);
memcpy(mAudioBuffer+mAudioBufferCurrentIndex, inBL->mBuffers[0].mData, bytesToCopy);
mAudioBufferCurrentIndex += bytesToCopy / sizeof(int32_t);
if (mAudioBufferCurrentIndex >= mAudioBufferSize / sizeof(int32_t))
{
OSAtomicIncrement32Barrier(&mHasAudioData);
OSAtomicDecrement32Barrier(&mNeedsAudioData);
}
}
void FFTBufferManager::GrabAudioData2(SInt16 *samples,int nb)
{
// if (mAudioBufferSize < inBL->mBuffers[0].mDataByteSize) return;
UInt32 bytesToCopy = min(nb, mAudioBufferSize - mAudioBufferCurrentIndex);
memcpy(mAudioBuffer+mAudioBufferCurrentIndex, samples, bytesToCopy);
mAudioBufferCurrentIndex += bytesToCopy / sizeof(int32_t);
if (mAudioBufferCurrentIndex >= mAudioBufferSize / sizeof(int32_t))
{
OSAtomicIncrement32Barrier(&mHasAudioData);
OSAtomicDecrement32Barrier(&mNeedsAudioData);
}
}
Boolean FFTBufferManager::ComputeFFT(int32_t *outFFTData, float_t *outMajorPitch)
{
if (HasNewAudioData())
{
SpectrumAnalysisProcess(mSpectrumAnalysis, mAudioBuffer, outFFTData, outMajorPitch, true);
OSAtomicDecrement32Barrier(&mHasAudioData);
OSAtomicIncrement32Barrier(&mNeedsAudioData);
mAudioBufferCurrentIndex = 0;
return true;
}
else if (mNeedsAudioData == 0)
OSAtomicIncrement32Barrier(&mNeedsAudioData);
return false;
}
void BufferManager::GetFFTOutput( Float32* outFFTData )
{
if (HasNewFFTData())
{
Float32* _FFTBuffer = GetFFTBuffers();
_WaveFFTCepstrumHelper->ComputeABSFFT(_FFTBuffer, outFFTData);
ManageFFTBuffer();
free(_FFTBuffer);
OSAtomicDecrement32Barrier(&_HasNewFFTData);
OSAtomicIncrement32Barrier(&_NeedsNewFFTData);
}
}
int AtomicRefCount::decrement()
{
#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
return (int) ::InterlockedDecrement( (volatile LONG*)&m_count );
#elif defined( __APPLE__ )
return (int) OSAtomicDecrement32Barrier( (volatile int32_t*)&m_count );
#elif defined( HAVE_GCC_ATOMIC_BUILTINS )
// Use the gcc intrinsic for atomic decrement if supported.
return (int) __sync_sub_and_fetch( &m_count, 1 );
#else
// Fallback to using a lock
MutexGuard m( m_lock );
return --m_count;
#endif
}
void
si_module_release(si_mod_t *si)
{
int32_t i;
if (si == NULL) return;
if (si->flags & SI_MOD_FLAG_STATIC) return;
i = OSAtomicDecrement32Barrier(&si->refcount);
if (i > 0) return;
pthread_mutex_lock(&module_mutex);
for (i = 0; (i < module_count) && (module_list[i] != si); i++);
if (i >= module_count)
{
pthread_mutex_unlock(&module_mutex);
return;
}
if (module_count == 1)
{
free(module_list);
module_list = NULL;
module_count = 0;
pthread_mutex_unlock(&module_mutex);
return;
}
for (i++; i < module_count; i++) module_list[i - 1] = module_list[i];
module_count--;
module_list = (si_mod_t **)reallocf(module_list, module_count * sizeof(si_mod_t *));
if (module_list == NULL) module_count = 0;
pthread_mutex_unlock(&module_mutex);
if (si->vtable->sim_close != NULL) si->vtable->sim_close(si);
if (si->bundle != NULL) dlclose(si->bundle);
free(si->name);
free(si);
}
U_CAPI int32_t U_EXPORT2
umtx_atomic_dec(int32_t *p) {
int32_t retVal;
if (pDecFn) {
retVal = (*pDecFn)(gIncDecContext, p);
} else {
#if defined (U_WINDOWS) && ICU_USE_THREADS == 1
retVal = InterlockedDecrement((LONG*)p);
#elif defined(USE_MAC_OS_ATOMIC_INCREMENT)
retVal = OSAtomicDecrement32Barrier(p);
#elif defined (POSIX) && ICU_USE_THREADS == 1
umtx_lock(&gIncDecMutex);
retVal = --(*p);
umtx_unlock(&gIncDecMutex);
#else
/* Unknown Platform, or ICU thread support compiled out. */
retVal = --(*p);
#endif
}
return retVal;
}
void RefCounted::unrefer()
{
#ifdef _WINDOWS
if (InterlockedDecrement(&(this->mRefCount)) <= 0)
{
delete this;
}
#else
#ifdef MACOSX
if (OSAtomicDecrement32Barrier(&(this->mRefCount)) <= 0)
{
delete this;
}
#else
dlib::auto_mutex lock(sRefMutex);
if (--mRefCount <= 0)
{
delete this;
}
#endif
#endif
}
Boolean FFTBufferManager::ComputeFFT(int32_t *outFFTData)
{
if (HasNewAudioData())
{
// for(int i=0;i<mFFTLength;i++)
// {
// if(mAudioBuffer[i]>0.15)
// printf("%f\n",mAudioBuffer[i]);
// }
//Generate a split complex vector from the real data
# define NOISE_FILTER 0.01;
for(int i=0;i<4096;i++)
{
//DENOISE
if(mAudioBuffer[i]>0)
{
mAudioBuffer[i] -= NOISE_FILTER;
if(mAudioBuffer[i] < 0)
{
mAudioBuffer[i] = 0;
}
}
else if(mAudioBuffer[i]<0)
{
mAudioBuffer[i] += NOISE_FILTER;
if(mAudioBuffer[i]>0)
{
mAudioBuffer[i] = 0;
}
}
else
{
mAudioBuffer[i] = 0;
}
}
vDSP_ctoz((COMPLEX *)mAudioBuffer, 2, &mDspSplitComplex, 1, mFFTLength);
//Take the fft and scale appropriately
vDSP_fft_zrip(mSpectrumAnalysis, &mDspSplitComplex, 1, mLog2N, kFFTDirection_Forward);
vDSP_vsmul(mDspSplitComplex.realp, 1, &mFFTNormFactor, mDspSplitComplex.realp, 1, mFFTLength);
vDSP_vsmul(mDspSplitComplex.imagp, 1, &mFFTNormFactor, mDspSplitComplex.imagp, 1, mFFTLength);
//Zero out the nyquist value
mDspSplitComplex.imagp[0] = 0.0;
//Convert the fft data to dB
Float32 tmpData[mFFTLength];
vDSP_zvmags(&mDspSplitComplex, 1, tmpData, 1, mFFTLength);
//In order to avoid taking log10 of zero, an adjusting factor is added in to make the minimum value equal -128dB
vDSP_vsadd(tmpData, 1, &mAdjust0DB, tmpData, 1, mFFTLength);
Float32 one = 1;
vDSP_vdbcon(tmpData, 1, &one, tmpData, 1, mFFTLength, 0);
//Convert floating point data to integer (Q7.24)
vDSP_vsmul(tmpData, 1, &m24BitFracScale, tmpData, 1, mFFTLength);
for(UInt32 i=0; i<mFFTLength; ++i)
outFFTData[i] = (SInt32) tmpData[i];
for(int i=0;i<mFFTLength/4;i++)
{
printf("%i:::%i\n",i,outFFTData[i]/16777216+120);
}
OSAtomicDecrement32Barrier(&mHasAudioData);
OSAtomicIncrement32Barrier(&mNeedsAudioData);
mAudioBufferCurrentIndex = 0;
return true;
}
else if (mNeedsAudioData == 0)
OSAtomicIncrement32Barrier(&mNeedsAudioData);
return false;
}
int32_t TS_AtomicDec(TS_Atomic32 * aToDec){
return OSAtomicDecrement32Barrier(aToDec);
}
