Additive synthesis is a powerful technique used in audio synthesis to create complex sounds by adding together multiple sine waves of different frequencies and amplitudes. In this blog post, we will explore how to implement additive synthesis in C++ to generate interesting and dynamic audio.

Getting Started

To begin with, we need a basic understanding of audio processing in C++. We can use a library like PortAudio or RtAudio to handle the low-level audio I/O and buffer management for us. Let’s assume we have set up the necessary audio framework and are ready to write our own audio synthesis code.

Additive Synthesis Algorithm

The main idea behind additive synthesis is to generate a waveform by summing multiple sine waves with different frequencies and amplitudes. Each sine wave is called a “partial” and represents a single harmonic component of the final sound.

Here is a simplified version of the additive synthesis algorithm in C++:

#include <cmath>

double sampleRate = 44100; // the sample rate of the audio
double frequency = 440; // the frequency of the note we want to generate
double duration = 2; // the duration of the note in seconds

int numPartials = 10; // the number of partials to generate
double amplitude = 0.2; // the overall amplitude of the sound

double generateSample(double time) {
  double sample = 0;
  
  for (int i = 1; i <= numPartials; i++) {
    // Calculate the frequency and amplitude for each partial
    double partialFrequency = frequency * i;
    double partialAmplitude = amplitude / i;
    
    // Generate the sample for the current partial
    double partialSample = sin(2 * M_PI * partialFrequency * time);
    
    // Add the partial sample to the final sample
    sample += partialSample * partialAmplitude;
  }
  
  return sample;
}

int main() {
  // Generate audio samples for the duration of the note
  for (double time = 0; time < duration; time += 1 / sampleRate) {
    double sample = generateSample(time);
    
    // Output the audio sample to the audio buffer
    // (code for writing the sample to the audio buffer goes here)
  }
  
  // Wait for the audio playback to finish
  // (code for waiting goes here)
  
  return 0;
}

Explaining the Code

• We start by defining some parameters like the sample rate, frequency, duration, number of partials, and overall amplitude.
• Inside the generateSample function, we calculate the frequency and amplitude for each partial based on their position and the desired overall amplitude.
• The main loop in the main function iterates over time and calls the generateSample function to generate audio samples at each time step.
• The generated sample is then output to the audio buffer for playback.
• Finally, we wait for the audio playback to finish before exiting the program.

Conclusion

Additive synthesis is a fundamental technique in audio synthesis that allows us to create a wide variety of sounds. In this blog post, we explored how to implement additive synthesis in C++ by generating and summing multiple sine waves. By adjusting the frequency, amplitude, and number of partials, you can create interesting and dynamic audio output. Have fun experimenting with different parameters and exploring the world of audio synthesis!

#audio #additiveSynthesis