Cutting Your Teeth on FMOD Part 5: Real-time streaming of programmatically-generated audio

This article was inspired by David Gouveia – thanks for the suggestion!

In this article, we shall look at how to generate sounds programmatically using a function which generates each sample one by one, and how to feed these samples into the audio buffer of a playing stream in real-time.

Note: The SimpleFMOD library contains all of the source code and pre-compiled executables for the examples in this series.

What are sound samples?

Figure 1. How a sine wave is represented by sound samples (the red dots) (source: streaming.stanford.edu)

Audio is stored on computers as a series of discrete numbers which are known as samples. Each sample represents nothing more than the volume (sometimes known as the amplitude) of the sound at a specific moment in time.

When you hear a pure tone, for example the dots and dashes of morse code, or a smoke detector which makes a single high-pitch noise when it goes off, you are usually listening to the audio representation of a sine wave. This is generally regarded as the simplest kind of sound. Figure 1 shows how such a sound may be represented by samples. The horizontal axis represents time and the vertical axis represents volume. The black curve shows the sine wave itself, while the red dots show the values of the samples. Hence, you can see how samples got their name: when analog sound is converted to digital, the sound is sampled at fixed time intervals to create an approximation of the original sound.

Notice the difference between the top and bottom graphs: in the bottom graph, the sound wave is sampled twice as often, giving a more accurate digital representation. The number of times a sample is taken per second is called the sample frequency or sample rate, using hertz (Hz) as the unit of measurement. So in the diagrams in Figure 2, the top sine wave has been sampled at 8Hz and the bottom one at 16Hz.

In real life, we need far higher sampling rates than this to reproduce audio accurately on a digital device. The standard for CDs (so-called “CD quality sound”) is 44100 Hz, while Super Audio CDs (SACDs) use a sample rate of 48000 Hz, ie. 48 thousand samples per second.

Figure 2. A square wave

How rapidly the sine wave repeats determines the pitch or frequency of the note. For example, if the sine wave repeats 800 times per second, you get a note playing at 800 Hz. By way of example, the frequency of middle C on a standard piano is around 261.626 Hz.

Sine waves aren’t the only way to produce notes, and different types of repeating pattern produce different types of sound. Figure 2 shows a square wave (repeated 3 times). If you listen to a square wave at 261.626 Hz, you will still be listening to middle C, but the note will sound more harsh to the human ear.

We’ll look at the maths of creating some basic wave types below.

Sound formats

A sound format refers to the way the samples are stored in a piece of audio: the range of numbers which can be used for the volume (and consequently, how many bytes each sample requires), the order the samples are arranged in, and so on.

The volume range allowed is extremely important to accurately reproducing the desired audio (when I talk about volume range, I mean the number of steps in volume available between silent and maximum volume). Clearly, if you only have a choice of 30 volumes, sampling is going to be much less accurate then if you have a choice of 1000 (think about the sine wave in Figure 1 again: the vertical position of the red dot samples is constrained by how many different volume levels can be selected by the sampler; the more volume levels available, the closer each dot can be to the sine wave, and the more accurate the digital representation becomes).

8-bit samples use a single byte (of 8 bits) to store each volume. Since a byte can only store numbers from 0-255, this gives us 256 potential volume levels to sample at. 16-bit samples use 2 bytes (of 8 bits each) to store the volume. With two bytes, we can store numbers from 0-65535 for a total of 65536 potential volume levels. This is the format used by CDs and most MP3s. Note that some modern amplifiers and home cinemas support 24-bit sound, giving 16.7 million volume levels for the highest fidelity re-production.

FMOD supports all of the sound formats you will need, with two that are of particular interest to us:

• FMOD_SOUND_FORMAT_PCM16 – this is the standard, uncompressed 16-bit sample format as described above, where each sample occupies 2 bytes and is a number from -32768 to +32767 (for a total of 65536 volume levels, where 0 is silent and the positive and negative maximums are maximum volume).
• FMOD_SOUND_FORMAT_PCMFLOAT – this is an uncompressed 32-bit sample format. Each sample occupies 4 bytes, but these 4 bytes contain a single floating point number with a (decimal/fractional) value from -1.0 to +1.0 (where 0 is silent and -1 and +1 are maximum volume), rather than a whole number.

When we create the audio buffer that we’ll fill with samples, we have to specify the format to use so that FMOD knows what type of data we are filling it with. We shall use FMOD_SOUND_FORMAT_PCM16 in the examples here.

The Process

A picture speaks a thousand words, so take a look at Figure 3 to see how the process of generating samples, pushing them into an audio buffer and playing it back will hang together:

Figure 3. The execution flow of an application which generates audio in real-time and feeds it into the audio buffer being played by FMOD.

We first create an audio buffer, specifying such details as the sample rate, number of channels, sound format (as described above) and the total buffer size. We also specify a function – known as a callback – which FMOD calls when the audio buffer is running low on samples to fill it up with new audio data (new samples).

The callback is where we will actually generate the audio. Naturally, we want to fill the buffer ahead of time before new samples are needed, and FMOD wants us to do this in fixed-size blocks. We therefore need to keep track of how far we are into the generation of our desired audio, since the portion of the buffer we are filling bears no relation to the current playback position.

FMOD keeps playing the audio even as the callback to fill the buffer is executing, and the callback itself is not tied to or called at any point directly by your application – only by FMOD itself – hence the need for 3 threads. Fortunately, you don’t have to worry about the multi-threading code as this is all handled for you automatically by FMOD.

The simplest possible example

Initialize FMOD

First, initialize FMOD as described in Cutting Your Teeth on FMOD Part 1: Build environment, initialization and playing sounds.

Describe the audio buffer

To create an audio buffer, we use the FMOD_CREATESOUNDEXINFO struct which can be passed into FMOD::System::createSound() or FMOD::System::createStream():

// The sample rate, number of channels and total time in seconds before the gnerated sample repeats
int sampleRate = 44100;
int channels = 2;
int lengthInSeconds = 5;

// Set up the sound
FMOD_CREATESOUNDEXINFO soundInfo;

memset(&soundInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
soundInfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO);

// The number of samples to fill per call to the PCM read callback (here we go for 1 second's worth)
soundInfo.decodebuffersize  = sampleRate;

// The length of the entire sample in bytes, calculated as:
// Sample rate * number of channels * bits per sample per channel * number of seconds
soundInfo.length            = sampleRate * channels * sizeof(signed short) * lengthInSeconds;

// Number of channels and sample rate
soundInfo.numchannels       = channels;
soundInfo.defaultfrequency  = sampleRate;

// The sound format (here we use 16-bit signed PCM)
soundInfo.format            = FMOD_SOUND_FORMAT_PCM16;

// Callback for generating new samples
soundInfo.pcmreadcallback   = PCMRead;

// Callback for when the user seeks in the playback
soundInfo.pcmsetposcallback = PCMSetPosition;

As you can see, the length of the audio buffer is defined by length (in bytes), and the number of samples to fill per callback is set in decodebuffersize. The callback which will do the sound generation is specified in pcmreadcallback. The sound format is set in format – here we’ve gone for 16-bit PCM data as described above.

Create the audio buffer

Before you create the audio buffer you may wish to increase FMOD’s stream buffer size from the default of 16384 bytes (16K). Optionally:

fmod->setStreamBufferSize(65536, FMOD_TIMEUNIT_RAWBYTES); // 64K in this example

To create the audio buffer, you must supply the FMOD_OPENUSER mode flag to indicate this will be user-generated sound, and pass in the audio buffer description created above:

FMOD::Sound *sound;
fmod->createStream(nullptr, FMOD_OPENUSER, &soundInfo, &sound);

Start playback

If you want to check the position or playback state of the sound elsewhere in your application, you’ll also need to get the sound’s channel, which means starting playback paused:

FMOD::Channel *channel;
fmod->playSound(FMOD_CHANNEL_FREE, sound, true, &channel);

If the audio is to loop indefinitely, set the looping mode as appropriate:

channel->setLoopCount(-1);
channel->setMode(FMOD_LOOP_NORMAL);
channel->setPosition(0, FMOD_TIMEUNIT_MS); // this flushes the buffer to ensure the loop mode takes effect

Note you can also set FMOD_LOOP_NORMAL in the creation mode flags when you call createStream() if you prefer.

Finally, unpause the audio:

channel->setPaused(false);

If you don’t care about looping or retrieving the channel, or you have set the loop mode when you called createStream(), you can forego all of the above sorcery and just start playback normally:

fmod->playSound(FMOD_CHANNEL_FREE, sound, false, nullptr);

Per-frame update and application work

It’s vital to call FMOD::System::update() frequently as your application runs:

bool quit = false;

while (!quit)
{
  fmod->update();

  // do the rest of your application's work here

  if (GetAsyncKeyState('Q'))
    quit = true;
}

This primitive example merely allows playback to continue indefinitely until the user presses Q, causing the while loop to exit.

Clean up

Once you’re done, tidy up your resources:

sound->release();
fmod->release();

Now for the tricky part: generating the actual audio.

Implementing the callback function

We’ll now use what we learned in our examination of samples at the beginning to write a function which generates a sine wave of a specified frequency and volume, at a sample rate which matches that of our audio buffer.

We start by defining some values:

// Generate new samples
// We must fill "length" bytes in the buffer provided by "data"
FMOD_RESULT F_CALLBACK PCMRead(FMOD_SOUND *sound, void *data, unsigned int length)
{
	// Sample rate
	static int const sampleRate = 44100;

	// Frequency to generate (Hz)
	static int const frequency = 800;

	// Volume level (0.0 - 1.0)
	static float const volume = 0.3f;

	// How many samples we have generated so far
	static int samplesElapsed = 0;

We’re going to generate a sine wave playing a note at 800 Hz, with a maximum volume of about one-third (pure sine waves sound remarkably loud), at a sample rate matching that of our buffer. We need the sample rate because we have to know how many samples we should generate for a single repetition of the sine wave. If the buffer uses a sample rate of 44100 Hz and we want a sine wave at 441 Hz, for example, then it is fairly obvious that we will need to generate precisely 100 samples per repetition of the sine wave, giving us 441 repetitions per 44100 samples, ie. 441 repetitions per second, ie. a sine wave frequency of 441 Hz.

Notice that we keep a running count of the number of samples we’ve generated in samplesElapsed so that we know how far into the sine wave we are. This value will be incremented every time we generate a new sample.

Next, we cast the void pointer we received from FMOD into a pointer to the correct sound format we are using. Our linear 16-bit PCM sound format stores data as signed shorts (16-bit values ranging from -32768 to +32767), so we cast like this:

// Get buffer in 16-bit format
signed short *buffer = (signed short *)data;

If we were using the 32-bit PCM floating point format, we would cast like this instead:

float *buffer = (float *)data;

Great! Now we’re ready to fill the buffer with data.

Filling the audio buffer

FMOD has indicated to us how many bytes of the buffer should be filled, but we are going to work one sample at a time, so what we really need to know is how many samples to generate. Since we know the sound format is 16-bit (2 bytes per sample), we can simply divide the fill length by 2 to get the number of samples. However, we have also specified that the audio buffer uses 2 channels (for stereo playback; a 1-channel buffer would be mono playback), so we actually need 2 samples per unit of time, one for the left channel and one for the right. Thus, the actual number of bytes used for a single unit of time is 4, and we divide the fill length by 4 to get the number of sample pairs (left and right) to generate.

If you were using 32-bit PCM floating point format, each sample requires 4 bytes, so a 2-channel audio buffer will require 8 bytes per sample pair.

Armed with this information, we use a loop to generate as many sine wave samples as needed:

// A 2-channel 16-bit stereo stream uses 4 bytes per sample
for (unsigned int sample = 0; sample < length / 4; sample++)
{
	// Get the position in the sample
	double pos = frequency * static_cast<float>(samplesElapsed) / sampleRate;

	// The generator function returns a value from -1 to 1 so we multiply this by the
	// maximum possible volume of a 16-bit PCM sample (32767) to get the true volume to store

	// Generate a sample for the left channel
	*buffer++ = (signed short)(sin(pos * M_PI*2) * 32767.0f * volume);

	// Generate a sample for the right channel
	*buffer++ = (signed short)(sin(pos * M_PI*2) * 32767.0f * volume);

	// Increment number of samples generated
	samplesElapsed++;
}

Okay, let’s step through this and see what is happening.

First, we figure out our position in the sine wave. Considering samplesElapsed / sampleRate in isolation first, if the frequency of the sine wave was 1 Hz (one repetition per second), this would give us a decimal value from 0 to 1 indicating how far (in percent) we are into it (on the horizontal axis). Multiplying this value by the desired frequency gives us a decimal value from 0 to frequency, which, if we just take the decimal part of it and ignore the whole number part, gives us the percentage we are into the sine wave of the desired frequency (the whole number part indicates how many whole repetitions we have gone through).

We then pass this value to the C++ standard math function sin(), multiplied by PI*2 since sin() works in radians. If you are not familiar with this, simply know that while sines calculated from degrees take an input in degrees from 0-359, sines calculated from radians take an input in radians from 0 – PI*2. The behaviour and result is the same, it is simply the scale of the input value which is different; since we have calculated our position in the sine wave as a value from 0-1, we multiply it by PI*2 to scale it up to the length of a single sine wave (which is 360 degrees, or PI*2 radians). Ultimately, sin() returns a value from -1 to 1 indicating the vertical position on the sine curve for the specified horizontal position (which we specified in radians as the input), where 0 is the centre point and 1 and -1 are the upper and lower peaks of the curve respectively.

To scale the value we have obtained to be constrained within the bounds of our desired maximum volume, all we have to do is multiply the result by volume, since our result is between -1 and 1. For example, with our test volume of 0.3, the maximums will become -0.3 and +0.3, which is what we want.

If you are using the 32-bit PCM floating point sound format, you have at this point a value from -1 to 1 indicating the volume of the sample, and you can simply store it in the buffer. For linear 16-bit PCM data, we need to do one more step, which is to scale the calculated volume (of -1 to 1) by the maximum volume that can be stored in a 16-bit signed value, thereby transforming the range -1 to 1 into a range of -32767 to +32767 instead.

In our example, we store the same value twice in the buffer: once for the left channel and once for the right channel. Notice the ordering: for a given time unit, the left channel’s sample is stored first, then the right channel’s sample.

Finally, we increment the number of samples generated and repeat the process all over again until we have generated the desired amount of samples.

Your callback function should return FMOD_OK when finishing:

return FMOD_OK;
}

Minimal example source code

The following source code puts everything together into a minimalist example (note: the code uses SimpleFMOD to simplify initialization and audio buffer creation), and uses code from the official demo to show playback information:

#include "../SimpleFMOD/SimpleFMOD.h"
#include <functional>
#include <memory>
#include <iostream>

using namespace SFMOD;

// Generate new samples
// We must fill "length" bytes in the buffer provided by "data"
FMOD_RESULT F_CALLBACK PCMRead(FMOD_SOUND *sound, void *data, unsigned int length)
{
	// Sample rate
	static int const sampleRate = 44100;

	// Frequency to generate (Hz)
	static int const frequency = 800;

	// Volume level (0.0 - 1.0)
	static float const volume = 0.3f;

	// How many samples we have generated so far
	static int samplesElapsed = 0;

	// Get buffer in 16-bit format
    signed short *stereo16BitBuffer = (signed short *)data;

	// A 2-channel 16-bit stereo stream uses 4 bytes per sample
    for (unsigned int sample = 0; sample < length / 4; sample++)
    {
		// Get the position in the sample
		double pos = frequency * static_cast<float>(samplesElapsed) / sampleRate;

		// The generator function returns a value from -1 to 1 so we multiply this by the
		// maximum possible volume of a 16-bit PCM sample (32767) to get the true volume to store

		// Generate a sample for the left channel
		*stereo16BitBuffer++ = (signed short)(sin(pos * M_PI*2) * 32767.0f * volume);

		// Generate a sample for the right channel
		*stereo16BitBuffer++ = (signed short)(sin(pos * M_PI*2) * 32767.0f * volume);

		// Increment number of samples generated
		samplesElapsed++;
    }

    return FMOD_OK;
}

FMOD_RESULT F_CALLBACK PCMSetPosition(FMOD_SOUND *sound, int subsound, unsigned int position, FMOD_TIMEUNIT postype)
{
	// If you need to process the user changing the playback position (seeking), do it here

	return FMOD_OK;
}

// Program entry point
int main()
{
	// The sample rate, number of channels and total time in seconds before the gnerated sample repeats
	int sampleRate = 44100;
	int channels = 2;
	int lengthInSeconds = 5;

	// Set up FMOD
	SimpleFMOD fmod;

	// Set up the sound
	FMOD_CREATESOUNDEXINFO soundInfo;

	memset(&soundInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
	soundInfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO);

	// The number of samples to fill per call to the PCM read callback (here we go for 1 second's worth)
	soundInfo.decodebuffersize  = sampleRate;

	// The length of the entire sample in bytes, calculated as:
	// Sample rate * number of channels * bits per sample per channel * number of seconds
	soundInfo.length            = sampleRate * channels * sizeof(signed short) * lengthInSeconds;

	// Number of channels and sample rate
	soundInfo.numchannels       = channels;
	soundInfo.defaultfrequency  = sampleRate;

	// The sound format (here we use 16-bit signed PCM)
	soundInfo.format            = FMOD_SOUND_FORMAT_PCM16;

	// Callback for generating new samples
	soundInfo.pcmreadcallback   = PCMRead;

	// Callback for when the user seeks in the playback
	soundInfo.pcmsetposcallback = PCMSetPosition;

	// Create a user-defined sound with FMOD_OPENUSER
	Song sound = fmod.LoadSong(nullptr, nullptr, FMOD_OPENUSER, soundInfo);

	// Start playback and get the channel and a reference to the sound
	FMOD::Channel *channel = sound.Start();

	// Print instructions
	std::cout <<
		"FMOD Sound Generator Demo - (c) Katy Coe 2013 - www.djkaty.com" << std::endl <<
		"==============================================================" << std::endl << std::endl <<
		"Press:" << std::endl << std::endl <<
		"  P - Toggle pause" << std::endl <<
		"  Q - Quit" << std::endl << std::endl;

	bool quit = false;

	while (!quit)
	{
		// Update FMOD
		fmod.Update();

		// Print statistics
        if (channel)
        {
            unsigned int ms;
            unsigned int lenms;
            bool         paused;

			paused = sound.GetPaused();
            channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
            sound.Get()->getLength(&lenms, FMOD_TIMEUNIT_MS);

            printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused? "Paused " : "Playing");
        }

		// P - Toggle pause
		if (GetAsyncKeyState('P'))
		{
			sound.TogglePause();

			while (GetAsyncKeyState('P'))
				;
		}

		// Q - Quit
		if (GetAsyncKeyState('Q'))
			quit = true;
	}
}

Generating different kinds of sounds

The following functions take the value we calculated in pos above with the whole number part removed (pos - floor(pos)), and return a value from -1 to 1 indicating the amplitude of the sample to create:

// Sine wave
static double Sine(double samplePos)
{
	return sin(samplePos * M_PI*2);
}

// Sawtooth
static double Sawtooth(double samplePos)
{
	if (samplePos == 0)
		return 0.f;

	return (2.f / samplePos) - 1.f;
}

// Square wave
static double Square(double samplePos)
{
	return (samplePos < 0.5f? 1.f : -1.f);
}

// White noise ("static")
static double WhiteNoise(double samplePos)
{
	return static_cast<double>(rand()) / RAND_MAX;
}

You can simply replace the call to sin() in the callback we created earlier to a call to one of these functions instead.

Using a class member as an FMOD callback function

The least troublesome way I found to do this is to set the optional user data you can specify when you populate FMOD_CREATESOUNDEXINFO to a pointer to the object you wish to use, for example:

AudioClassWithCallback ac;

soundInfo.pcmreadcallback = &AudioClassWithCallback::PCMRead;
soundInfo.userdata = ∾

or if you create the structure from within the object itself:

soundInfo.pcmreadcallback = PCMRead;
soundInfo.userdata = this;

Declare the callbacks as static, and at the start of the callback function, add code to query the user data to get the object pointer like this:

FMOD_RESULT AudioClassWithCallback::PCMRead(FMOD_SOUND *sound, void *data, unsigned int length)
{
// Get the object we are using
// Note that FMOD_Sound * must be cast to FMOD::Sound * to access it
AudioClassWithCallback *me;
((FMOD::Sound *) sound)->getUserData((void **) &me);

// ...

You can now access all the members of the object supplied in userdata via the me pointer.

A more complex example

The source code below shows how to wrap an entire sound generator into a class object. Creating an instance of the object generates an audio buffer of the specified sample rate, number of channels and length in time units, and will generate a sound at the specified frequency and volume using an arbitrary function supplied in the constructor arguments. This function can be changed at any time (although there will be some lag as existing samples in the buffer are played back). When the object goes out of scope, the sound resource is released cleanly. The example allows you to switch between generation of the four sound types outlined above.

#include "../SimpleFMOD/SimpleFMOD.h"
#include <functional>
#include <memory>
#include <iostream>

using namespace SFMOD;

// Some example sound generators
// These receive a value from 0.0-1.0 indicating the position in the repeating samples to generate
// and return a value from -1.0 to +1.0 indicating the volume at the current sample position
typedef std::function<double (double)> GeneratorType;

class Generators
{
public:
	// Sine wave
	static double Sine(double samplePos)
	{
		return sin(samplePos * M_PI*2);
	}

	// Sawtooth
	static double Sawtooth(double samplePos)
	{
		if (samplePos == 0)
			return 0.f;

		return (2.f / samplePos) - 1.f;
	}

	// Square wave
	static double Square(double samplePos)
	{
		return (samplePos < 0.5f? 1.f : -1.f);
	}

	// White noise ("static")
	static double WhiteNoise(double samplePos)
	{
		return static_cast<double>(rand()) / RAND_MAX;
	}
};

// Class which generates audio according to the specified function, frequency, sample rate and volume
class Generator
{
private:
	// The sound
	Song sound;

	// Sample rate
	int const sampleRate;

	// Number of channels
	int const channels;

	// Length of sample in seconds before it repeats
	int const lengthInSeconds;

	// Frequency to generate
	int const frequency;

	// Volume (0.0-1.0)
	float const volume;

	// The function to use to generate samples
	GeneratorType generator;

	// How many samples we have generated so far
	int samplesElapsed;

public:
	// Constructor
	Generator(SimpleFMOD &fmod, GeneratorType generator, int frequency, int sampleRate, int channels, int lengthInSeconds, float volume)
		: generator(generator), frequency(frequency), sampleRate(sampleRate), channels(channels),
		  lengthInSeconds(lengthInSeconds), volume(volume), samplesElapsed(0)
	{
		FMOD_CREATESOUNDEXINFO soundInfo;

		memset(&soundInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
		soundInfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO);

		// The number of samples to fill per call to the PCM read callback (here we go for 1 second's worth)
		soundInfo.decodebuffersize  = sampleRate;

		// The length of the entire sample in bytes, calculated as:
		// Sample rate * number of channels * bits per sample per channel * number of seconds
		soundInfo.length            = sampleRate * channels * sizeof(signed short) * lengthInSeconds;

		// Number of channels and sample rate
		soundInfo.numchannels       = channels;
		soundInfo.defaultfrequency  = sampleRate;

		// The sound format (here we use 16-bit signed PCM)
		soundInfo.format            = FMOD_SOUND_FORMAT_PCM16;

		// Callback for generating new samples
		soundInfo.pcmreadcallback   = PCMRead;

		// Callback for when the user seeks in the playback
		soundInfo.pcmsetposcallback = PCMSetPosition;

		// Pointer to the object we are using to generate the samples
		// (our callbacks query this data to access a concrete instance of the class from our static member callback functions)
		soundInfo.userdata = this;

		// Create a user-defined sound with FMOD_OPENUSER
		sound = fmod.LoadSong(nullptr, nullptr, FMOD_OPENUSER, soundInfo);
	}

	// Start playing
	FMOD::Channel *Start()
	{
		return sound.Start();
	}

	// Get reference to sound
	Song &Get()
	{
		return sound;
	}

	// Change the sound being generated
	void SetGenerator(GeneratorType g)
	{
		generator = g;
	}

	// FMOD Callbacks
	static FMOD_RESULT F_CALLBACK PCMRead(FMOD_SOUND *sound, void *data, unsigned int length);
	static FMOD_RESULT F_CALLBACK PCMSetPosition(FMOD_SOUND *sound, int subsound, unsigned int position, FMOD_TIMEUNIT postype);
};

// Generate new samples
// We must fill "length" bytes in the buffer provided by "data"
FMOD_RESULT Generator::PCMRead(FMOD_SOUND *sound, void *data, unsigned int length)
{
	// Get the object we are using
	// Note that FMOD_Sound * must be cast to FMOD::Sound * to access it
	Generator *me;
	((FMOD::Sound *) sound)->getUserData((void **) &me);

	// Get buffer in 16-bit format
    signed short *stereo16BitBuffer = (signed short *)data;

	// A 2-channel 16-bit stereo stream uses 4 bytes per sample
    for (unsigned int sample = 0; sample < length / 4; sample++)
    {
		// Get the position in the sample
		double pos = me->frequency * static_cast<float>(me->samplesElapsed) / me->sampleRate;

		// Modulo it to a value between 0 and 1
		pos = pos - floor(pos);

		// The generator function returns a value from -1 to 1 so we multiply this by the
		// maximum possible volume of a 16-bit PCM sample (32767) to get the true volume to store

		// Generate a sample for the left channel
		*stereo16BitBuffer++ = (signed short)(me->generator(pos) * 32767.0f * me->volume);

		// Generate a sample for the right channel
		if (me->channels == 2)
			*stereo16BitBuffer++ = (signed short)(me->generator(pos) * 32767.0f * me->volume);

		// Increment number of samples generated
		me->samplesElapsed++;
    }

    return FMOD_OK;
}

FMOD_RESULT Generator::PCMSetPosition(FMOD_SOUND *sound, int subsound, unsigned int position, FMOD_TIMEUNIT postype)
{
	// If you need to process the user changing the playback position (seeking), do it here

	return FMOD_OK;
}

// Program entry point
int main()
{
	// The sample rate, number of channels and total time in seconds before the gnerated sample repeats
	int sampleRate = 44100;
	int channels = 2;
	int soundLengthSeconds = 5;

	// Types of sound generator
	GeneratorType generators[] = {
		Generators::Sine,
		Generators::Sawtooth,
		Generators::Square,
		Generators::WhiteNoise
	};

	// Which generator to use
	int generatorId = 0;
	int numGenerators = 4;

	// Frequency to generate (Hz)
	int frequency = 800;

	// Volume level (0.0 - 1.0)
	float volume = 0.3f;

	// Set up FMOD
	SimpleFMOD fmod;

	// Set up sound generator
	Generator generator(fmod, generators[generatorId], frequency, sampleRate, channels, soundLengthSeconds, volume);

	// Start playback and get the channel and a reference to the sound
	FMOD::Channel *channel = generator.Start();
	Song *sound = &generator.Get();

	// Print instructions
	std::cout <<
		"FMOD Sound Generator Demo - (c) Katy Coe 2013 - www.djkaty.com" << std::endl <<
		"==============================================================" << std::endl << std::endl <<
		"Press:" << std::endl << std::endl <<
		"  G - Change sound generator" << std::endl <<
		"  P - Toggle pause" << std::endl <<
		"  Q - Quit" << std::endl << std::endl;

	bool quit = false;

	while (!quit)
	{
		// Update FMOD
		fmod.Update();

		// Print statistics
        if (channel)
        {
            unsigned int ms;
            unsigned int lenms;
            bool         paused;

			paused = sound->GetPaused();
            channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
            sound->Get()->getLength(&lenms, FMOD_TIMEUNIT_MS);

            printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused? "Paused " : "Playing");
        }

		// G - Change generator
		if (GetAsyncKeyState('G'))
		{
			sound->Stop();
			generatorId = (generatorId + 1) % numGenerators;
			generator.SetGenerator(generators[generatorId]);
			sound->Start();

			while (GetAsyncKeyState('G'))
				;
		}

		// P - Toggle pause
		if (GetAsyncKeyState('P'))
		{
			sound->TogglePause();

			while (GetAsyncKeyState('P'))
				;
		}

		// Q - Quit
		if (GetAsyncKeyState('Q'))
			quit = true;
	}
}

I hope you found this tutorial useful! In Part 6 we’ll look at how to capture and record real-time sound card output, and optionally perform frequency analysis on it. Please leave feedback below.