I’ll keep this short because Triangle, Sawtooth, and Square waves all share something in common: they’re non-sinusoidal. They are all made up of their own unique (and infinite) summation of sinusoids.

A triangle wave can be represented as:

and a sawtooth wave:

 where w = 2πf (f being the frequency of the generated wave).

If the words “non-sinusoidal” or “infinite summation of sinusoids” are confusing, it might be helpful to look at the following animations. As you can see in the equations above, they all end with “…”, this means that the previous pattern continues to infinity. It never ends, so its quite impossible for a computer to represent a square, triangle, or sawtooth wave as an infinite summation of sinusoids. But it can get close! Take a look at these animations that I grabbed from wikipedia:

But I digress, when we have to generate these waves the on the go, it’s not absolutely necessary to have a perfect understanding of the math in the past two posts. However, it is very useful if you ever go into Digital Signal Processing or any music tech field for that matter.

So to get back on topic, here’s the two snippets of code for generating triangle and sawtooth waves:

int triIndex = 0;
void generateTriangle(SInt16 *sampleBuffer, int numFrames, float sampleRate, float frequency, float amp) {
    if(amp>1) amp=1;
    if(amp<0) amp=0;
    amp = amp * SHRT_MAX;
    
    float samplesPerCycle = sampleRate/frequency;
    for(int i = 0; i0.5) {
            sampleBuffer[i] = (SInt16) amp * ((2-2*((fmodf(triIndex, samplesPerCycle)/samplesPerCycle-0.5)/0.5))-1);
        } else {
            sampleBuffer[i] = (SInt16) amp * ((2*((fmodf(triIndex, samplesPerCycle)/samplesPerCycle)/0.5))-1);
        }
        triIndex = triIndex+1;
    }
}

int sawIndex = 0;
void generateSawtooth(SInt16 *sampleBuffer, int numFrames, float sampleRate, float frequency, float amp) {
    if(amp>1) amp=1;
    if(amp<0) amp=0;
    amp = amp * SHRT_MAX;
    
    float samplesPerCycle = sampleRate/frequency;
    for(int i = 0; i=samplesPerCycle) sawIndex-=samplesPerCycle;
    }
}

This is somewhat of a continuation of my last post on Sine Wave Generation, but instead we’ll be producing a square wave! Square waves are really annoying to listen to. So if you’re going to test this at all – make sure you turn down the volume (it can be very unpleasant).

Square waves are a bit more complex than sine waves. Sine waves all have their energy concentrated on one frequency. Square waves are, in reality, somewhat theoretical – it is the result of an infinite summation of sine waves, each weighted differently. Therefore, in real life, it is non-sinusoidal. But it’s still very relevant, so to be thorough – a square wave is:

Obviously, it would be impractical to add a bunch of different sin(C), where C is some number determined by the arguments and equation above, every time we need to compute just one sample. There are a few other solutions. One solution (unnecessarily complicated, but no more difficult than other common methods of audio synthesis) is to use the inverse FFT. Without diving into a lecture about the Fast Fourier Transform (FFT), it’s main use is to take a chunk of audio, and transform it into the frequency domain so that we can see how energy is spread across the frequency spectrum (20Hz – 20,000Hz for humans). Our solution would employ the Inverse FFT (or IFFT) – this does the opposite, you begin with an ideal frequency spectrum and end up with a chunk of audio. It’s very useful, you can essentially draw the frequency spectrum (drawing sound, eh??).

But this is far too complicated for now, because we just want to generate a square wave on the go, and that’s all it is, a square. For every cycle of a square wave, it is either high or low. Therefore its incredibly easy to just loop through the buffer and insert the constant amp, changing the sign every half cycle. My C++ implementation is below.

C++:

int squareIndex = 0;
int amp = SHRT_MAX * 0.8;
void generateSquare(SInt16 *sampleBuffer, int numFrames, float sampleRate, float frequency) {
    float samplesPerCycle = sampleRate/frequency;
    for(int i = 0; i < numFrames; i++) {
        if(fmodf(squareIndex, samplesPerCycle)/samplesPerCycle > 0.5) {
            sampleBuffer[i] = amp;
        } else {
            sampleBuffer[i] = -1*amp;
        }
        squareIndex = squareIndex+1;
        if(squareIndex >= samplesPerCycle) squareIndex-=samplesPerCycle;
    }
}

This is a faux-implementation of how I would fill up a callback buffer:

#define sample_rate 44100.0
#define desired_tone 440.0 //A440
static void playbackCallback(..., int inNumberFrames, SInt16 *ioData) {
    generateSine(ioData, inNumberFrames, sample_rate, desired_tone);
}

Generating a sampled sine wave

Generating basic waveforms is a fundamental concept which all audio DSP engineers should understand. Basic waveforms can be generated on the go, without considering the harmonic properties that define each wave shape. Since these waves are periodic, they can also be produced once, and then stored as in an array or a wavetable (or multiple waves can be produced and stored in a matrix). Wavetables are used very often in audio synthesis (wavetable synthesis) where multiple waveforms are stored, modulated, and post-processed to create new sounds.

I have provided code below that outlines how to produce the simplest of the basic waveforms: The Sine Wave. Because most of my audio developing experience has been on the iPhone, I’ve posted the code in C++.

C++:

#define M_PI 3.14; //M_PI is a pi macro used by many compilers
double theta = 0;
void generateSine(SInt16 *sampleBuffer, int numFrames, float sampleRate, float frequency) {
    float deltaTheta = 2*M_PI*(frequency/sampleRate);
    for(int i = 0; i2*M_PI) theta = theta - 2*M_PI;
    }
}

The idea for this function/method is that you call this method when you have a buffer that must be populated with a sine wave of a given frequency. To use this function, you call it with the following arguments:

• SInt16 *sampleBuffer: a reference of the buffer to be populated.
• int numFrames: the number of samples in *sampleBuffer.
• float sampleRate: the device’s current sampleRate – usually 44100.0 on the iPhone (although you can usually set it yourself, more on this in a few weeks).
• float frequency: the desired output frequency in Hz.

So, to give an example of how I would use these snippets in real life I will leave you with an example. This is a mockup callback for an Audio I/O Framework (based off of iOS). A callback is a function that is called every time the device is about to run out of audio samples to play from the speaker, and alas, must ask you to feed it some more.

#define sample_rate 44100.0
#define desired_tone 440.0 //A440
static void playbackCallback(..., int inNumberFrames, SInt16 *ioData) {
    generateSine(ioData, inNumberFrames, sample_rate, desired_tone);
}