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;
}
bool32 OSXDoNextWorkQueueEntry(platform_work_queue* Queue)
{
bool32 WeShouldSleep = false;
uint32 OriginalNextEntryToRead = Queue->NextEntryToRead;
uint32 NewNextEntryToRead = (OriginalNextEntryToRead + 1) % ArrayCount(Queue->Entries);
if(OriginalNextEntryToRead != Queue->NextEntryToWrite)
{
// NOTE(jeff): OSAtomicCompareAndSwapXXX functions return 1 if the swap took place, 0 otherwise!
uint32 SwapOccurred = OSAtomicCompareAndSwapIntBarrier(OriginalNextEntryToRead,
NewNextEntryToRead,
(int volatile*)&Queue->NextEntryToRead);
if (SwapOccurred)
{
platform_work_queue_entry Entry = Queue->Entries[OriginalNextEntryToRead];
Entry.Callback(Queue, Entry.Data);
//InterlockedIncrement((int volatile *)&Queue->CompletionCount);
OSAtomicIncrement32Barrier((int volatile *)&Queue->CompletionCount);
}
else
{
}
}
else
{
WeShouldSleep = true;
}
return(WeShouldSleep);
}
void BufferManager::GetFFTOutput( Float32* outFFTData )
{
mFFTHelper->ComputeFFT(mFFTInputBuffer, outFFTData);
mFFTInputBufferFrameIndex = 0;
OSAtomicDecrement32Barrier(&mHasNewFFTData);
OSAtomicIncrement32Barrier(&mNeedsNewFFTData);
}
U_CAPI int32_t U_EXPORT2
umtx_atomic_inc(int32_t *p) {
int32_t retVal;
if (pIncFn) {
retVal = (*pIncFn)(gIncDecContext, p);
} else {
#if !ICU_USE_THREADS
/* ICU thread support compiled out. */
retVal = ++(*p);
#elif U_PLATFORM_HAS_WIN32_API
retVal = InterlockedIncrement((LONG*)p);
#elif defined(USE_MAC_OS_ATOMIC_INCREMENT)
retVal = OSAtomicIncrement32Barrier(p);
#elif (U_HAVE_GCC_ATOMICS == 1)
retVal = __sync_add_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);
}
}
si_mod_t *
si_module_retain(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->flags & SI_MOD_FLAG_STATIC) return si;
OSAtomicIncrement32Barrier(&si->refcount);
return si;
}
void CARingBuffer::setCurrentFrameBounds(uint64_t startTime, uint64_t endTime)
{
ByteSpinLocker locker(m_currentFrameBoundsLock);
uint32_t nextPtr = m_timeBoundsQueuePtr + 1;
uint32_t index = nextPtr & kGeneralRingTimeBoundsQueueMask;
m_timeBoundsQueue[index].m_startFrame = startTime;
m_timeBoundsQueue[index].m_endFrame = endTime;
m_timeBoundsQueue[index].m_updateCounter = nextPtr;
OSAtomicIncrement32Barrier(static_cast<int32_t*>(&m_timeBoundsQueuePtr));
}
//------------------------------------------------------------------------
int32 FAtomicIncrement (volatile int32& var)
{
// ATTENTION! Return the value *before* the Increment operation!!!
#if WINDOWS
return InterlockedExchangeAdd (&var, 1);
#elif MAC
return OSAtomicIncrement32Barrier (NATIVE_ATOMIC_TYPE &var) - 1;
#else
return var++;
#endif
}
FFTBufferManager::FFTBufferManager(UInt32 inNumberFrames) :
mNeedsAudioData(0),
mHasAudioData(0),
mNumberFrames(inNumberFrames),
mAudioBufferSize(inNumberFrames * sizeof(int32_t)),
mAudioBufferCurrentIndex(0)
{
mAudioBuffer = (int32_t*)malloc(mAudioBufferSize);
mSpectrumAnalysis = SpectrumAnalysisCreate(mNumberFrames);
OSAtomicIncrement32Barrier(&mNeedsAudioData);
}
void RefCounted::referTo()
{
#ifdef _WINDOWS
InterlockedIncrement(&(this->mRefCount));
#else
#ifdef MACOSX
OSAtomicIncrement32Barrier(&(this->mRefCount));
#else
dlib::auto_mutex lock(sRefMutex);
mRefCount++;
#endif
#endif
}
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);
}
}
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 BufferManager::GetFFTOutput( Float32* outFFTData )
{
if (HasNewFFTData())
{
Float32* _FFTBuffer = GetFFTBuffers();
_WaveFFTCepstrumHelper->ComputeABSFFT(_FFTBuffer, outFFTData);
ManageFFTBuffer();
free(_FFTBuffer);
OSAtomicDecrement32Barrier(&_HasNewFFTData);
OSAtomicIncrement32Barrier(&_NeedsNewFFTData);
}
}
int AtomicRefCount::increment()
{
#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
return (int) ::InterlockedIncrement( (volatile LONG*)&m_count );
#elif defined( __APPLE__ )
return (int) OSAtomicIncrement32Barrier( (volatile int32_t*)&m_count );
#elif defined( HAVE_GCC_ATOMIC_BUILTINS )
// Use the gcc intrinsic for atomic increment if supported.
return (int) __sync_add_and_fetch( &m_count, 1 );
#else
// Fallback to using a lock
MutexGuard m( m_lock );
return ++m_count;
#endif
}
BufferManager::BufferManager( UInt32 NewFramesSize, UInt32 NewSamplingRate, Float32 NewOverlap )
{
_FrameSize = NewFramesSize;
_SamplingRate = NewSamplingRate;
_BufferLen = _SamplingRate * 5; // Store 5 seconds audio data
_CurDataIdx = 0;
_FFTStartIdx = 0;
_FFTEndIdx = NewFramesSize-1;
_Overlap = NewOverlap;
_AudioDataBuffer = (Float32*) calloc(_BufferLen, sizeof(Float32));
_WaveFFTCepstrumHelper = new WaveFFTCepstrumHelper(_FrameSize);
_HasNewFFTData = 0;
_NeedsNewFFTData = 0;
OSAtomicIncrement32Barrier(&_NeedsNewFFTData);
}
FFTBufferManager::FFTBufferManager(UInt32 inNumberFrames) :
mNeedsAudioData(0),
mHasAudioData(0),
mFFTNormFactor(1.0/(2*inNumberFrames)),
mAdjust0DB(1.5849e-13),
m24BitFracScale(16777216.0f),
mFFTLength(inNumberFrames/2),
mLog2N(Log2Ceil(inNumberFrames)),
mNumberFrames(inNumberFrames),
mAudioBufferSize(inNumberFrames * sizeof(Float32)),
mAudioBufferCurrentIndex(0)
{
mAudioBuffer = (Float32*) calloc(mNumberFrames,sizeof(Float32));
mDspSplitComplex.realp = (Float32*) calloc(mFFTLength,sizeof(Float32));
mDspSplitComplex.imagp = (Float32*) calloc(mFFTLength, sizeof(Float32));
mSpectrumAnalysis = vDSP_create_fftsetup(mLog2N, kFFTRadix2);
OSAtomicIncrement32Barrier(&mNeedsAudioData);
}
BufferManager::BufferManager( UInt32 inMaxFramesPerSlice ) :
mDisplayMode(0 /*aurioTouchDisplayModeOscilloscopeWaveform*/),
mDrawBuffers(),
mDrawBufferIndex(0),
mCurrentDrawBufferLen(kDefaultDrawSamples),
mFFTInputBuffer(NULL),
mFFTInputBufferFrameIndex(0),
mFFTInputBufferLen(inMaxFramesPerSlice),
mHasNewFFTData(0),
mNeedsNewFFTData(0),
mFFTHelper(NULL)
{
for(UInt32 i=0; i<kNumDrawBuffers; ++i) {
mDrawBuffers[i] = (Float32*) calloc(inMaxFramesPerSlice, sizeof(Float32));
}
mFFTInputBuffer = (Float32*) calloc(inMaxFramesPerSlice, sizeof(Float32));
mFFTHelper = new FFTHelper(inMaxFramesPerSlice);
OSAtomicIncrement32Barrier(&mNeedsNewFFTData);
}
U_CAPI int32_t U_EXPORT2
umtx_atomic_inc(int32_t *p) {
int32_t retVal;
if (pIncFn) {
retVal = (*pIncFn)(gIncDecContext, p);
} else {
#if defined (U_WINDOWS) && ICU_USE_THREADS == 1
retVal = InterlockedIncrement((LONG*)p);
#elif defined(USE_MAC_OS_ATOMIC_INCREMENT)
retVal = OSAtomicIncrement32Barrier(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;
}
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_AtomicInc(TS_Atomic32 * aToInc){
return OSAtomicIncrement32Barrier(aToInc);
}
void setUIValue(float value) {
_uiValue = value;
OSAtomicIncrement32Barrier(&changeCounter);
}
