From frequecy domain to time domain

Question

based on my previous question and pitch detector on GitHub. I manage to detect what dominant frequecy have my sample. But like Zaph said, it would be folish to cut off whole sample. My question is if I already convert sample from time to frequency domain so how can I go back and convert frequency to time domain?

My approach time->frequency

ConvertInt16ToFloat(THIS, dataBuffer, outputBufferFrequency, bufferCapacity);

maxFrames = 32;
log2n = log2f(maxFrames);
n = 1 << log2n;
assert(n == maxFrames);
nOver2 = maxFrames/2;
bufferCapacity = maxFrames;
COMPLEX_SPLIT A;
A.realp = (float *)malloc(nOver2 * sizeof(float));
A.imagp = (float *)malloc(nOver2 * sizeof(float));
fftSetup = vDSP_create_fftsetup(log2n, FFT_RADIX2);

vDSP_ctoz((COMPLEX*)outputBuffer, 2, &A, 1, nOver2);

// Carry out a Forward FFT transform.
vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_FORWARD);

// The output signal is now in a split real form. Use the vDSP_ztoc to get
// a split real vector.
vDSP_ztoc(&A, 1, (COMPLEX *)outputBuffer, 2, nOver2);

// Determine the dominant frequency by taking the magnitude squared and
// saving the bin which it resides in.
float dominantFrequency = 0;
int bin = -1;
for (int i=0; i<n; i+=2) {
    float curFreq = MagnitudeSquared(outputBuffer[i], outputBuffer[i+1]);
    if (curFreq > dominantFrequency) {
        dominantFrequency = curFreq;
        bin = (i+1)/2;
    }
}

UPDATE

//First faild approach to convert frequency->ti
vDSP_ctoz((COMPLEX*)outputBufferFrequency, 2, &A, 1, nOver2);

vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_INVERSE);

vDSP_ztoc(&A, 1, (COMPLEX *)outputBufferFrequency, 2, nOver2);

ConvertFloatToInt16(THIS, outputBufferFrequency, outputBufferTime, bufferCapacity);    

// checking is preTimeToFrequency buffer is same as postTimeToFrequency buffer
// and is not, atm.
for (int i=0; i<bufferCapacity; i++) {
    printf("%i != %i",((SInt16*)dataBuffer)[i], ((SInt16*)outputBufferTime)[i]);
    if (((SInt16*)dataBuffer)[i] != ((SInt16*)outputBufferTime)[i]){
        printf("dupa\n");
    }
}

void ConvertInt16ToFloat(RIOInterface* THIS, void *buf, float *outputBuf, size_t capacity) {
    AudioConverterRef converter;
    OSStatus err;

    size_t bytesPerSample = sizeof(float);
    AudioStreamBasicDescription outFormat = {0};
    outFormat.mFormatID = kAudioFormatLinearPCM;
    outFormat.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
    outFormat.mBitsPerChannel = 8 * bytesPerSample;
    outFormat.mFramesPerPacket = 1;
    outFormat.mChannelsPerFrame = 1;
    outFormat.mBytesPerPacket = bytesPerSample * outFormat.mFramesPerPacket;
    outFormat.mBytesPerFrame = bytesPerSample * outFormat.mChannelsPerFrame;
    outFormat.mSampleRate = THIS->sampleRate;

    const AudioStreamBasicDescription inFormat = THIS->streamFormat;

    UInt32 inSize = capacity*sizeof(SInt16);
    UInt32 outSize = capacity*sizeof(float);
    err = AudioConverterNew(&inFormat, &outFormat, &converter);
    err = AudioConverterConvertBuffer(converter, inSize, buf, &outSize, outputBuf);
}

void ConvertFloatToInt16(RIOInterface* dev, float *buf, void *outputBuf, size_t capacity) {
    AudioConverterRef converter;
    OSStatus err;

    size_t bytesPerSample = sizeof(short);
    AudioStreamBasicDescription outFormat = {0};
    outFormat.mFormatID = kAudioFormatLinearPCM;
    outFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
    outFormat.mBitsPerChannel = 8 * bytesPerSample;
    outFormat.mFramesPerPacket = 1;
    outFormat.mChannelsPerFrame = 1;
    outFormat.mBytesPerPacket = bytesPerSample * outFormat.mFramesPerPacket;
    outFormat.mBytesPerFrame = bytesPerSample * outFormat.mChannelsPerFrame;
    outFormat.mSampleRate = dev->sampleRate;

    const AudioStreamBasicDescription inFormat = dev->streamFormat;

    UInt32 inSize = capacity*sizeof(float);
    UInt32 outSize = capacity*sizeof(SInt16);
    err = AudioConverterNew(&inFormat, &outFormat, &converter);
    err = AudioConverterConvertBuffer(converter, inSize, buf, &outSize, outputBuf);
}

UPDATE 2

Second approach after reading this sample code

vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_INVERSE);

vDSP_ztoc(&A, 1, (COMPLEX *)outputBufferFrequency, 2, nOver2);

float scale = 0.5/maxFrames;
vDSP_vsmul(outputBufferFrequency, 1, &scale, outputBufferFrequency, 1, maxFrames);

ConvertFloatToInt16(THIS, outputBufferFrequency, outputBufferTime, bufferCapacity);

SOLVED

Finally! After I read this anwser, read some sample codes I manage to figure out my problem.

My working code.

Variable streamFormat is initialize somewhere eles and I put that initialization ConvertFloatToInt16 just for better view of what I use.

ConvertInt16ToFloat(THIS, dataBuffer, outputBufferFrequency, bufferCapacity);
//TIME -> FREQUENCU
vDSP_ctoz((COMPLEX*)outputBufferFrequency, 2, &A, 1, nOver2);

// Carry out a Forward FFT transform.
vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_FORWARD);

// The output signal is now in a split real form. Use the vDSP_ztoc to get
// a split real vector.
vDSP_ztoc(&A, 1, (COMPLEX *)outputBufferFrequency, 2, nOver2);


//FREQUENCY -> TIME
//Back to time domain
vDSP_ctoz((COMPLEX*)outputBufferFrequency, 2, &A, 1, nOver2);

vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_INVERSE);

float scale = (float) 1.0 / (2 * maxFrames);;

vDSP_vsmul(A.realp, 1, &scale, A.realp, 1, nOver2);
vDSP_vsmul(A.imagp, 1, &scale, A.imagp, 1, nOver2);

vDSP_ztoc(&A, 1, (COMPLEX *)outputBufferFrequency, 2, nOver2);

ConvertFloatToInt16(THIS, outputBufferFrequency, outputBufferTime, bufferCapacity);


void ConvertInt16ToFloat(RIOInterface* THIS, void *buf, float *outputBuf, size_t capacity) {
    AudioConverterRef converter;
    OSStatus err;

    size_t bytesPerSample = sizeof(float);
    AudioStreamBasicDescription outFormat = {0};
    outFormat.mFormatID = kAudioFormatLinearPCM;
    outFormat.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
    outFormat.mBitsPerChannel = 8 * bytesPerSample;
    outFormat.mFramesPerPacket = 1;
    outFormat.mChannelsPerFrame = 1;
    outFormat.mBytesPerPacket = bytesPerSample * outFormat.mFramesPerPacket;
    outFormat.mBytesPerFrame = bytesPerSample * outFormat.mChannelsPerFrame;
    outFormat.mSampleRate = THIS->sampleRate;

    THIS->streamFloatFormat = outFormat;
    const AudioStreamBasicDescription inFormat = THIS->streamFormat;

    UInt32 inSize = capacity*sizeof(SInt16);
    UInt32 outSize = capacity*sizeof(float);
    err = AudioConverterNew(&inFormat, &outFormat, &converter);
    err = AudioConverterConvertBuffer(converter, inSize, buf, &outSize, outputBuf);
}

void ConvertFloatToInt16(RIOInterface* THIS, float *buf, void *outputBuf, size_t capacity) {
    AudioConverterRef converter;
    OSStatus err;

    AudioStreamBasicDescription asbd = {0};
    size_t bytesPerSample;
    bytesPerSample = sizeof(SInt16);
    asbd.mFormatID = kAudioFormatLinearPCM;
    asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
    asbd.mBitsPerChannel = 8 * bytesPerSample;
    asbd.mFramesPerPacket = 1;
    asbd.mChannelsPerFrame = 1;
    asbd.mBytesPerPacket = bytesPerSample * asbd.mFramesPerPacket;
    asbd.mBytesPerFrame = bytesPerSample * asbd.mChannelsPerFrame;
    asbd.mSampleRate = sampleRate;

    THIS->streamFormat = asbd;

    const AudioStreamBasicDescription outFormat = THIS->streamFormat;
    const AudioStreamBasicDescription inFormat = THIS->streamFloatFormat;

    UInt32 inSize = capacity*sizeof(float);
    UInt32 outSize = capacity*sizeof(SInt16);
    err = AudioConverterNew(&inFormat, &outFormat, &converter);
    err = AudioConverterConvertBuffer(converter, inSize, buf, &outSize, outputBuf);
}

Why don't you just save the original time-domain sample and use that? Alternatively you should be able to use an inverse Fourier transform. — David Schwartz, Feb 20 '14 at 11:25
I don't use orginal because I want shift particular frequency — Błażej, Feb 20 '14 at 13:05

Bamsworld · Answer 1 · 2014-02-20T15:05:38.803

An inverse Fourier transform will transform your discrete signal from the frequency domain back to the time domain.

You can perform an inverse Fourier transform like this -

vDSP_fft_zrip(fftSetup, &A, stride, log2n, FFT_INVERSE);

It then must be scaled accordingly. Scaling factors are found in Figure 2-6 Summary of the scaling factors found in vDSP Programming Guide by Apple

A good example can be found here Forward and Inverse FFT using Accelerate.

Also after reading your update, if you are trying to pitch shift a signal in the frequency domain and then transform it back to the time domain there is a quite a lot more involved. May I suggest reading this article on Pitch shifting using the Fourier transform from DSP Dimension.

I update my question about my approach but I guess log2n should be inversed, right? — Błażej, Feb 20 '14 at 13:13

From frequecy domain to time domain

UPDATE

UPDATE 2

SOLVED

1 Answers1