void Reverb::initialize(const nsTArray<const float*>& impulseResponseBuffer,
size_t impulseResponseBufferLength,
size_t maxFFTSize, bool useBackgroundThreads)
{
m_impulseResponseLength = impulseResponseBufferLength;
// The reverb can handle a mono impulse response and still do stereo processing
size_t numResponseChannels = impulseResponseBuffer.Length();
m_convolvers.SetCapacity(numResponseChannels);
int convolverRenderPhase = 0;
for (size_t i = 0; i < numResponseChannels; ++i) {
const float* channel = impulseResponseBuffer[i];
size_t length = impulseResponseBufferLength;
nsAutoPtr<ReverbConvolver> convolver(new ReverbConvolver(channel, length, maxFFTSize, convolverRenderPhase, useBackgroundThreads));
m_convolvers.AppendElement(convolver.forget());
convolverRenderPhase += WEBAUDIO_BLOCK_SIZE;
}
// For "True" stereo processing we allocate a temporary buffer to avoid repeatedly allocating it in the process() method.
// It can be bad to allocate memory in a real-time thread.
if (numResponseChannels == 4) {
m_tempBuffer.AllocateChannels(2);
WriteZeroesToAudioBlock(&m_tempBuffer, 0, WEBAUDIO_BLOCK_SIZE);
}
}
/**
\brief inplace cpu based convolution, decides upon input value of nthreads
whether to use single-threaded or multi-threaded implementation
\param[in] im 1D array that contains the data image stack
\param[in] imDim 3D array that contains the shape of the image stack im
\param[in] kernel 1D array that contains the data kernel stack
\param[in] kernelDim 3D array that contains the shape of the kernel stack
kernel
\param[in] nthreads number of threads to use
\return
\retval
*/
void inplace_cpu_convolution(imageType* im,
int* imDim,
imageType* kernel,
int* kernelDim,
int nthreads) {
unsigned image_dim[3];
unsigned kernel_dim[3];
std::copy(imDim, imDim + 3, &image_dim[0]);
std::copy(kernelDim, kernelDim + 3, &kernel_dim[0]);
if (nthreads != 1) {
mvn::cpu::convolve<mvn::cpu::parallel_tag>::type convolver(im, image_dim, kernel, kernel_dim);
mvn::cpu::convolve<mvn::cpu::parallel_tag>::transform_type::set_n_threads(nthreads);
convolver.inplace();
} else {
mvn::cpu::convolve<mvn::cpu::serial_tag>::type convolver(im, image_dim, kernel, kernel_dim);
convolver.inplace();
}
}
