void FftConvolver::setResponse(int length, float* newResponse) {
	int neededLength= kiss_fftr_next_fast_size_real	(block_size+length);
	int newTailSize=neededLength-block_size;
	if(neededLength !=fft_size || tail_size !=newTailSize) {
		if(workspace) freeArray(workspace);
		workspace=allocArray<float>(neededLength);
		if(tail) freeArray(tail);
		tail=allocArray<float>(newTailSize);
		fft_size=neededLength/2+1;
		workspace_size=neededLength;
		tail_size=newTailSize;
		if(fft) kiss_fftr_free(fft);
		fft = kiss_fftr_alloc(workspace_size, 0, nullptr, nullptr);
		if(ifft) kiss_fftr_free(ifft);
		ifft=kiss_fftr_alloc(workspace_size, 1, nullptr, nullptr);
		if(response_fft) freeArray(response_fft);
		response_fft=allocArray<kiss_fft_cpx>(fft_size);
		if(block_fft) freeArray(block_fft);
		block_fft=allocArray<kiss_fft_cpx>(fft_size);
	}
	memset(workspace, 0, sizeof(float)*workspace_size);
	memset(tail, 0, sizeof(float)*tail_size);
	//Store the fft of the response.
	std::copy(newResponse, newResponse+length, workspace);
	kiss_fftr(fft, workspace, response_fft);
}
// ----------------------------------------------------------------------------
ofOpenALSoundPlayer::~ofOpenALSoundPlayer(){
    unloadSound();
    close();
    if(fftCfg!=0) kiss_fftr_free(fftCfg);
    //kiss_fftr_free(fftCfg);
    //players.erase(this);
}
Exemple #3
0
HrtfData::~HrtfData() {
    if(temporary_buffer1) freeArray(temporary_buffer1);
    if(temporary_buffer2) freeArray(temporary_buffer2);
    if(hrirs == nullptr) return; //we never loaded one.
    for(int i = 0; i < elev_count; i++) {
        //The staticResamplerKernel allocates with new[], not allocArray.
        for(int j = 0; j < azimuth_counts[i]; j++) delete[] hrirs[i][j];
        delete[] hrirs[i];
    }
    delete[] hrirs;
    delete[] azimuth_counts;
    freeArray(fft_time_data);
    freeArray(fft_data);
    kiss_fftr_free(fft);
    kiss_fftr_free(ifft);
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer::initSystemFFT(int bands){
	if(int(systemBins.size())==bands) return;
	int signalSize = (bands-1)*2;
	if(systemFftCfg!=0) kiss_fftr_free(systemFftCfg);
	systemFftCfg = kiss_fftr_alloc(signalSize, 0, NULL, NULL);
	systemCx_out.resize(bands);
	systemBins.resize(bands);
	createWindow(signalSize);
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer_TimelineAdditions::initFFT(int bands){
	if(int(bins.size())==bands) return;
	int signalSize = (bands-1)*2;
	if(fftCfg!=0) kiss_fftr_free(fftCfg);
	fftCfg = kiss_fftr_alloc(signalSize, 0, NULL, NULL);
	cx_out.resize(bands);
	bins.resize(bands);
	createWindow(signalSize);
}
Exemple #6
0
int main(int argc, char *argv[])
{
	const char *filename_wav, *filename_png;
	kiss_fftr_cfg fft;
	int err = 0;

	for (;;) {

		const int c = getopt(argc, argv, "h");
		if (0 > c)
			break;

		switch (c) {

		case '?':
			err = EINVAL;
			/*@fallthrough@*/
		case 'h':
			usage();
			return err;
		}
	}

	if (argc < 3 || argc != (optind + 2)) {
		usage();
		return -EINVAL;
	}

	filename_wav = argv[optind++];
	filename_png = argv[optind++];

	fft = kiss_fftr_alloc(NUM_FFT, 0, 0, 0);
	if (!fft) {
		err = ENOMEM;
		goto out;
	}

	err = read_wav(fft, filename_wav);
	if (err)
		goto out;
 
	err = plot_spectrum(filename_png);
	if (err)
		goto out;

 out:
	if (fft)
		kiss_fftr_free(fft);

	tmr_debug();
	mem_debug();

	return err;
}
// ----------------------------------------------------------------------------
ofOpenALSoundPlayer::~ofOpenALSoundPlayer(){
	unloadSound();
	kiss_fftr_free(fftCfg);
	players.erase(this);
}
FFTLib::~FFTLib() {
    kiss_fftr_free(m_cfg);
    KISS_FFT_FREE(m_output);
    KISS_FFT_FREE(m_input);
    KISS_FFT_FREE(m_window);
}
// ----------------------------------------------------------------------------
ofOpenALSoundPlayer_TimelineAdditions::~ofOpenALSoundPlayer_TimelineAdditions(){
	unloadSound();
	kiss_fftr_free(fftCfg);
	players.erase(this);
}
SjOscSpectrum::~SjOscSpectrum()
{
	kiss_fftr_free(m_kiss_fft_setup);
}
FftConvolver::~FftConvolver() {
	if(workspace) freeArray(workspace);
	if(tail) freeArray(tail);
	if(fft) kiss_fftr_free(fft);
	if(ifft) kiss_fftr_free(ifft);
}
Exemple #12
0
void FFTCorrelation::convolve(const float *left, const int leftSize,
                               const float *right, const int rightSize,
                               float *out_convolved)
{
    QTime time;
    time.start();


    // To avoid issues with repetition (we are dealing with cosine waves
    // in the fourier domain) we need to pad the vectors to at least twice their size,
    // otherwise convolution would convolve with the repeated pattern as well
    int largestSize = leftSize;
    if (rightSize > largestSize) {
        largestSize = rightSize;
    }

    // The vectors must have the same size (same frequency resolution!) and should
    // be a power of 2 (for FFT).
    int size = 64;
    while (size/2 < largestSize) {
        size = size << 1;
    }

    kiss_fftr_cfg fftConfig = kiss_fftr_alloc(size, false, NULL,NULL);
    kiss_fftr_cfg ifftConfig = kiss_fftr_alloc(size, true, NULL,NULL);
    kiss_fft_cpx leftFFT[size/2];
    kiss_fft_cpx rightFFT[size/2];
    kiss_fft_cpx correlatedFFT[size/2];


    // Fill in the data into our new vectors with padding
    float leftData[size];
    float rightData[size];
    float convolved[size];

    std::fill(leftData, leftData+size, 0);
    std::fill(rightData, rightData+size, 0);

    std::copy(left, left+leftSize, leftData);
    std::copy(right, right+rightSize, rightData);

    // Fourier transformation of the vectors
    kiss_fftr(fftConfig, leftData, leftFFT);
    kiss_fftr(fftConfig, rightData, rightFFT);

    // Convolution in spacial domain is a multiplication in fourier domain. O(n).
    for (int i = 0; i < size/2; i++) {
        correlatedFFT[i].r = leftFFT[i].r*rightFFT[i].r - leftFFT[i].i*rightFFT[i].i;
        correlatedFFT[i].i = leftFFT[i].r*rightFFT[i].i + leftFFT[i].i*rightFFT[i].r;
    }

    // Inverse fourier tranformation to get the convolved data.
    // Insert one element at the beginning to obtain the same result
    // that we also get with the nested for loop correlation.
    *out_convolved = 0;
    int out_size = leftSize+rightSize+1;

    kiss_fftri(ifftConfig, correlatedFFT, convolved);
    std::copy(convolved, convolved+out_size-1, out_convolved+1);

    // Finally some cleanup.
    kiss_fftr_free(fftConfig);
    kiss_fftr_free(ifftConfig);

    std::cout << "FFT convolution computed. Time taken: " << time.elapsed() << " ms" << std::endl;
}