IOReturn IOAudioEngine::mixOutputSamples(const void *sourceBuf, void *mixBuf, UInt32 firstSampleFrame, UInt32 numSampleFrames, const IOAudioStreamFormat *streamFormat, IOAudioStream *audioStream)
{
IOReturn result = kIOReturnBadArgument;
if (sourceBuf && mixBuf)
{
const float * floatSource1Buf;
const float * floatSource2Buf;
float * floatMixBuf;
UInt32 numSamplesLeft = numSampleFrames * streamFormat->fNumChannels;
__darwin_size_t numSamps = numSamplesLeft;
floatMixBuf = &(((float *)mixBuf)[firstSampleFrame * streamFormat->fNumChannels]);
floatSource2Buf = floatMixBuf;
floatSource1Buf = (const float *)sourceBuf;
__darwin_ptrdiff_t strideOne=1, strideTwo=1, resultStride=1;
vDSP_vadd(floatSource1Buf, strideOne, floatSource2Buf, strideTwo, floatMixBuf, resultStride, numSamps);
result = kIOReturnSuccess;
}
return result;
}
/*******************************************************************************
VectorVectorAdd */
Error_t
VectorVectorAdd(float *dest,
const float *in1,
const float *in2,
unsigned length)
{
#ifdef __APPLE__
// Use the Accelerate framework if we have it
vDSP_vadd(in1, 1, in2, 1, dest, 1, length);
#else
// Otherwise do it manually
unsigned i;
const unsigned end = 4 * (length / 4);
for (i = 0; i < end; i+=4)
{
dest[i] = in1[i] + in2[i];
dest[i + 1] = in1[i + 1] + in2[i + 1];
dest[i + 2] = in1[i + 2] + in2[i + 2];
dest[i + 3] = in1[i + 3] + in2[i + 3];
}
for (i = end; i < length; ++i)
{
dest[i] = in1[i] + in2[i];
}
#endif
return NOERR;
}
void CMPerformFFT( CMFFT *fft, float *input, float *output )
{
int i, n, nby2 ;
n = fft->size ;
nby2 = n/2 ;
switch ( fft->style ) {
case PowerSpectrum:
vDSP_ctoz( ( COMPLEX* )input, 2, &fft->z, 1, nby2 ) ;
if ( fft->window ) {
for ( i = 0; i < nby2; i++ ) {
fft->z.realp[i] *= fft->window[i] ;
fft->z.imagp[i] *= fft->window[i] ;
}
}
vDSP_fft_zript( fft->vfft, &fft->z, 1, &fft->tempBuf, fft->log2n, FFT_FORWARD ) ;
vDSP_vsq( fft->z.realp, 1, fft->z.realp, 1, nby2 ) ;
vDSP_vsq( fft->z.imagp, 1, fft->z.imagp, 1, nby2 ) ;
vDSP_vadd( fft->z.realp, 1, fft->z.imagp, 1, &output[0], 1, nby2 ) ;
break ;
default:
break ;
}
}
void dm_vvadd(const float* input_, float* input2_, float* result_, unsigned long size_) {
#ifdef DSP_USE_ACCELERATE
vDSP_vadd(input_, 1, input2_, 1, result_, 1, size_);
#else // generic
std::transform(input_, input_ + size_, input2_, result_, std::plus<float>());
#endif
}
void siglab_cbPwr(float *src, float *dst, int nfft)
{
// requires dst to be nel/2+1 element or more
// src is in separated Re and Im arrays, A(Im) = A(Re) + NFFT/2
vDSP_vsq(src,1,dst,1,nfft);
int nfft2 = nfft/2;
vDSP_vadd(dst+1,1,dst+nfft2+1,1,dst+1,1,nfft2-1);
}
void IFFT_next(IFFT *unit, int wrongNumSamples){
float *out = OUT(0); // NB not ZOUT0
// Load state from struct into local scope
int pos = unit->m_pos;
int fullbufsize = unit->m_fullbufsize;
int audiosize = unit->m_audiosize;
// int numSamples = unit->mWorld->mFullRate.mBufLength;
int numSamples = unit->m_numSamples;
float *olabuf = unit->m_olabuf;
float fbufnum = ZIN0(0);
// Only run the IFFT if we're receiving a new block of input data - otherwise just output data already received
if (fbufnum >= 0.f){
// Ensure it's in cartesian format, not polar
ToComplexApx(unit->m_fftsndbuf);
float* fftbuf = unit->m_fftsndbuf->data;
scfft_doifft(unit->m_scfft);
// Then shunt the "old" time-domain output down by one hop
int hopsamps = pos;
int shuntsamps = audiosize - hopsamps;
if(hopsamps != audiosize){ // There's only copying to be done if the position isn't all the way to the end of the buffer
memcpy(olabuf, olabuf+hopsamps, shuntsamps * sizeof(float));
}
// Then mix the "new" time-domain data in - adding at first, then just setting (copying) where the "old" is supposed to be zero.
#if SC_DARWIN
vDSP_vadd(olabuf, 1, fftbuf, 1, olabuf, 1, shuntsamps);
#else
// NB we re-use the "pos" variable temporarily here for write rather than read
for(pos = 0; pos < shuntsamps; ++pos){
olabuf[pos] += fftbuf[pos];
}
#endif
memcpy(olabuf + shuntsamps, fftbuf + shuntsamps, (hopsamps) * sizeof(float));
// Move the pointer back to zero, which is where playback will next begin
pos = 0;
} // End of has-the-chain-fired
// Now we can output some stuff, as long as there is still data waiting to be output.
// If there is NOT data waiting to be output, we output zero. (Either irregular/negative-overlap
// FFT firing, or FFT has given up, or at very start of execution.)
if(pos >= audiosize){
ClearUnitOutputs(unit, numSamples);
}else{
memcpy(out, olabuf + pos, numSamples * sizeof(float));
pos += numSamples;
}
unit->m_pos = pos;
}
BEGIN_UGEN_NAMESPACE
#include "../basics/ugen_BinaryOpUGens.h"
void BinaryAddUGenInternal::processBlock(bool& shouldDelete, const unsigned int blockID, const int channel) throw()
{
const int numSamplesToProcess = uGenOutput.getBlockSize();
float* const outputSamples = uGenOutput.getSampleData();
const float* const leftOperandSamples = inputs[LeftOperand].processBlock(shouldDelete, blockID, channel);
const float* const rightOperandSamples = inputs[RightOperand].processBlock(shouldDelete, blockID, channel);
vDSP_vadd(leftOperandSamples, 1, rightOperandSamples, 1, outputSamples, 1, numSamplesToProcess);
}
void add( const float *arrayA, const float *arrayB, float *result, size_t length )
{
vDSP_vadd( arrayA, 1, arrayB, 1, result, 1, length );
}
TriangleFilterBank32 *TriangleFilterBank32_new(size_t filterCount, size_t magnitudeFrameSize, size_t samplerate)
{
TriangleFilterBank32 *self = calloc(1, sizeof(TriangleFilterBank32));
self->filterCount = filterCount;
self->filterFrequencyCount = filterCount + 2;
self->magnitudeFrameSize = magnitudeFrameSize;
self->samplerate = samplerate;
self->filterFrequencies = calloc(self->filterFrequencyCount, sizeof(Float32));
self->filterBank = calloc(self->magnitudeFrameSize * self->filterCount, sizeof(Float32));
Float32 *filterTemp = calloc(self->magnitudeFrameSize * self->filterCount, sizeof(Float32));
Float32 one = 2;
Float32 zero = 0;
vDSP_vgen(&zero, &one, self->filterFrequencies, 1, self->filterFrequencyCount);
for (size_t i = 0; i < self->filterFrequencyCount; ++i) {
self->filterFrequencies[i] = powf(10, self->filterFrequencies[i]);
}
Float32 minusFirstElement = -self->filterFrequencies[0];
vDSP_vsadd(self->filterFrequencies, 1, &minusFirstElement, self->filterFrequencies, 1, self->filterFrequencyCount);
Float32 maximum = self->filterFrequencies[self->filterFrequencyCount - 1];
vDSP_vsdiv(self->filterFrequencies, 1, &maximum, self->filterFrequencies, 1, self->filterFrequencyCount);
Float32 nyquist = self->samplerate / 2;
vDSP_vsmul(self->filterFrequencies, 1, &nyquist, self->filterFrequencies, 1, self->filterFrequencyCount);
Float32 *magnitudeFrequencies = calloc(self->magnitudeFrameSize, sizeof(Float32));
vDSP_vgen(&zero, &nyquist, magnitudeFrequencies, 1, self->magnitudeFrameSize);
Float32 *lower = calloc(self->filterCount, sizeof(Float32));
Float32 *center = calloc(self->filterCount, sizeof(Float32));
Float32 *upper = calloc(self->filterCount, sizeof(Float32));
Float32 *temp1 = (Float32 *)calloc(self->magnitudeFrameSize, sizeof(Float32));
Float32 *temp2 = (Float32 *)calloc(self->magnitudeFrameSize, sizeof(Float32));
cblas_scopy((SInt32)self->filterCount, &self->filterFrequencies[0], 1, lower, 1);
cblas_scopy((SInt32)self->filterCount, &self->filterFrequencies[1], 1, center, 1);
cblas_scopy((SInt32)self->filterCount, &self->filterFrequencies[2], 1, upper, 1);
for (size_t i = 0; i < self->filterCount; ++i) {
Float32 negateLowerValue = -lower[i];
vDSP_vsadd(magnitudeFrequencies, 1, &negateLowerValue, temp1, 1, self->magnitudeFrameSize);
Float32 divider = center[i] - lower[i];
vDSP_vsdiv(temp1, 1, ÷r, temp1, 1, self->magnitudeFrameSize);
for (size_t j = 0; j < self->magnitudeFrameSize; ++j) {
if (!(magnitudeFrequencies[j] > lower[i] && magnitudeFrequencies[j] <= center[i])) {
temp1[j] = 0;
}
}
Float32 minusOne = -1;
vDSP_vsmul(magnitudeFrequencies, 1, &minusOne, temp2, 1, self->magnitudeFrameSize);
vDSP_vsadd(temp2, 1, &upper[i], temp2, 1, self->magnitudeFrameSize);
divider = upper[i] - center[i];
vDSP_vsdiv(temp2, 1, ÷r, temp2, 1, self->magnitudeFrameSize);
for (size_t j = 0; j < self->magnitudeFrameSize; ++j) {
if (!(magnitudeFrequencies[j] > center[i] && magnitudeFrequencies[j] <= upper[i])) {
temp2[j] = 0;
}
}
vDSP_vadd(temp1, 1, temp2, 1, &filterTemp[i * self->magnitudeFrameSize], 1, self->magnitudeFrameSize);
}
vDSP_mtrans(filterTemp, 1, self->filterBank, 1, self->magnitudeFrameSize, self->filterCount);
free(lower);
free(center);
free(upper);
free(temp1);
free(temp2);
free(magnitudeFrequencies);
free(filterTemp);
return self;
}
// apple bug
static void Workaround_vsub(const float *a, int aStride, const float *b, int bStride, float *c, int cStride, int size )
{
const float minusOne = -1.0f;
vDSP_vsmul(a, aStride, &minusOne, c, cStride, size);
vDSP_vadd( c, cStride, b, bStride, c, cStride, size );
}
