Pitch shifting in C++

03 Oct 2023

Pitch shifting is a popular audio processing technique that allows for the alteration of audio frequencies. It is commonly used in applications such as music production, audio post-production, and even voice manipulation. In this blog post, we will explore how to implement pitch shifting in C++, using simple and efficient algorithms.

Understanding the Basics

Before we dive into the implementation details, let’s understand the basics of pitch shifting. The fundamental concept behind pitch shifting is altering the playback speed of an audio signal without changing its duration. By increasing or decreasing the playback speed, we can effectively raise or lower the pitch of the audio.

Implementing Pitch Shifting in C++

To implement pitch shifting in C++, we will use the Fast Fourier Transform (FFT) algorithm. This algorithm allows us to convert a time-domain audio signal into a frequency-domain representation, which we can manipulate to change the pitch.

Before diving into the code, we need to set up our development environment. You’ll need a C++ compiler and a library that provides FFT functionality, such as FFTW or KissFFT.

Let’s take a look at a simplified code snippet to illustrate the pitch shifting process:

#include <iostream>
#include <complex>
#include <fftw3.h>

const double PITCH_SHIFT_FACTOR = 1.5; // Adjust this factor to change the pitch

void pitchShift(const double* input, double* output, int sampleRate, int bufferSize) {
    // Perform FFT on input buffer
    fftw_complex* fftInput = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * bufferSize);
    fftw_complex* fftOutput = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * bufferSize);
    fftw_plan plan = fftw_plan_dft_1d(bufferSize, fftInput, fftOutput, FFTW_FORWARD, FFTW_ESTIMATE);

    // Copy input signal to FFT input buffer
    for (int i = 0; i < bufferSize; i++) {
        fftInput[i][0] = input[i];
        fftInput[i][1] = 0;
    }

    // Perform FFT
    fftw_execute(plan);

    // Adjust frequency bins according to pitch shift factor
    for (int i = 0; i < bufferSize; i++) {
        double freqBin = (double)i * sampleRate / bufferSize;
        double shiftedBin = freqBin * PITCH_SHIFT_FACTOR;

        int shiftedIndex = (int)(shiftedBin * bufferSize / sampleRate);
        fftOutput[shiftedIndex][0] = fftInput[i][0];
        fftOutput[shiftedIndex][1] = fftInput[i][1];
    }

    // Perform inverse FFT to obtain output signal
    fftw_plan inversePlan = fftw_plan_dft_1d(bufferSize, fftOutput, fftInput, FFTW_BACKWARD, FFTW_ESTIMATE);
    fftw_execute(inversePlan);

    // Copy the real part of inverse FFT result to output buffer
    for (int i = 0; i < bufferSize; i++) {
        output[i] = fftInput[i][0] / bufferSize;
    }

    // Clean up
    fftw_destroy_plan(plan);
    fftw_destroy_plan(inversePlan);
    fftw_free(fftInput);
    fftw_free(fftOutput);
}

int main() {
    // Dummy input and output buffers
    const int bufferSize = 1024;
    double input[bufferSize];
    double output[bufferSize];

    // Populate input buffer with audio data

    pitchShift(input, output, 44100, bufferSize);

    // Process output buffer

    return 0;
}

Final Thoughts

Implementing pitch shifting in C++ allows us to manipulate audio frequencies and create interesting sound effects. The example code provided above demonstrates a basic pitch shifting implementation using the FFT algorithm. Experimenting with different pitch shift factors and fine-tuning the algorithms can help achieve desired audio effects.

Remember, efficient memory usage and careful manipulation of FFT output will result in better sound quality. Happy pitch shifting!

#AudioEffects #PitchShifting