This is a part of the DIY Synthesizer series of posts where each post is roughly built upon the knowledge of the previous posts. If you are lost, check the earlier posts!
Hello! It’s time for another installment of DIY synth. It’s been so long since the last one, that when I look back at the code in that post now, I’m mortified by some of the stylistic and implementation choices I made, EEK! The curse of learning new stuff… we all experience that from time to time hehe.
Following the previous DIY synth posts, you are now able to do quite a bit of synth stuff, but the only way you have to make percussion is to use recorded sound samples of drums. There’s nothing wrong with that, and in fact is an easy way to get good quality percussion, but if you want to be a purist and synthesize everything yourself, that might make you sad to have to rely on a recorded sample.
In today’s post, I’ll walk you through the process of how to create a simple drum in 3 easy steps.
It may not be the best synthesized drum, but it definitely passes as a drum sound, and I provide links that explain how to refine it further.
Step 1: Sine Wave
Starting out is pretty simple, we just need a tone. Here is a sine wave that lasts 1 second and is a F note in the 1st octave, or approximately 87hz. Drums are low sounds, so we need to start with a low frequency sound.
Step 2:Envelope
There is a concept in audio called an “envelope”. An envelope is just a fancy way of saying that you are changing the volume over time. The envelope is the “shape” of the volume changes over time.
If you notice in step 1 the volume (amplitude of the sine wave) isn’t constant throughout the whole thing, it actually has a part at the beginning that gradually goes from 0 volume to full volume, and at the end, it has a part at the end that goes from full volume to 0 volume (it’s 50 milliseconds on each side if you are curious). That fading is an envelope too and is actually there to prevent “popping” which can occur when you make audio samples that aren’t smooth from one to the next. It might seem like that would be a minor problem, but it’s actually VERY noticeable. Check out the previous DIY synth posts for more info and examples of that!
Anyhow, if you think about the sound that a drum makes when you hit it, it starts out loud right away, and then quickly fades out. You can play with the specific values of the envelope and get a different sound, but what I went with was 10 milliseconds of fading in (0.01 seconds), 10 milliseconds of being at full volume (0.01 seconds), and 175 milliseconds of fading out (0.175 seconds). You can see a picture of the envelope below:
The fade in time is called the “attack”, the time it remains at full volume is called the “hold” and the time that it fades out is called the “release”. There are other common stages to envelopes that you might hear about if looking up more info about them. Two other common parts of an enveloper are “sustain” and “decay” for instance.
Envelopes are a big part of what make notes sound like specific instruments, so have fun playing with those values and listening to the results.
Here is the envelope applied to our low frequency sine wave (which you apply by just multiplying them together!)
Step 3: Frequency Decay
We have something that sounds a little more interesting than a plain vanilla sine tone, but it doesn’t sound much like a drum yet…
What we are missing is that in a real drum, the frequency of the note decays over time. If that isn’t intuitive, don’t worry it wasn’t for me either. It took me a good amount of reading and investigation to find that out a few years back.
To add frequency decay, let’s have the frequency decay 80% of the way (towards frequency 0) over the “release” (fade out) portion of the envelope. So, the frequency will still be F1 through the entire drum note of attack and hold, but then starting with release, it will decay linearly over time for that 175 ms, until at the end, the frequency should only be 20% of 87hz, or about 17hz.
Here’s what we end up with:
drum.wav
Good Enough!
That’s pretty passable as a drum, even if it isn’t the best. A neat thing too is that by changing the starting frequency, you can get different frequencies of your drum and get some different drum sounds.
Here’s a little drum melody showing what i mean:
Sample Code
Here’s the code with everything above implemented, which created the drum melody. It uses only standard include files, and writes a wave file called “out.wav” when you run it. Play around with the code, adjusting envelope times, frequencies, frequency decay, or even change it from using a sine wave to a different wave form (I included some standard wave forms for you).
Often times synthesis / music making is all about just playing around with the knobs that are exposed to you til you find something really interesting.
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
#include
#include
#define _USE_MATH_DEFINES
#include
//=====================================================================================
// SNumeric - uses phantom types to enforce type safety
//=====================================================================================
template
struct SNumeric
{
public:
explicit SNumeric(const T &value) : m_value(value) { }
SNumeric() : m_value() { }
inline T& Value() { return m_value; }
inline const T& Value() const { return m_value; }
typedef SNumeric TType;
typedef T TInnerType;
// Math Operations
TType operator+ (const TType &b) const
{
return TType(this->Value() + b.Value());
}
TType operator- (const TType &b) const
{
return TType(this->Value() - b.Value());
}
TType operator* (const TType &b) const
{
return TType(this->Value() * b.Value());
}
TType operator/ (const TType &b) const
{
return TType(this->Value() / b.Value());
}
TType& operator+= (const TType &b)
{
Value() += b.Value();
return *this;
}
TType& operator-= (const TType &b)
{
Value() -= b.Value();
return *this;
}
TType& operator*= (const TType &b)
{
Value() *= b.Value();
return *this;
}
TType& operator/= (const TType &b)
{
Value() /= b.Value();
return *this;
}
TType& operator++ ()
{
Value()++;
return *this;
}
TType& operator-- ()
{
Value()--;
return *this;
}
// Extended Math Operations
template
T Divide(const TType &b)
{
return ((T)this->Value()) / ((T)b.Value());
}
// Logic Operations
bool operatorValue() < b.Value();
}
bool operatorValue() (const TType &b) const {
return this->Value() > b.Value();
}
bool operator>= (const TType &b) const {
return this->Value() >= b.Value();
}
bool operator== (const TType &b) const {
return this->Value() == b.Value();
}
bool operator!= (const TType &b) const {
return this->Value() != b.Value();
}
private:
T m_value;
};
//=====================================================================================
// Typedefs
//=====================================================================================
typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef int16_t int16;
typedef int32_t int32;
// type safe types!
typedef SNumeric TFrequency;
typedef SNumeric TTimeMs;
typedef SNumeric TSamples;
typedef SNumeric TDecibels;
typedef SNumeric TAmplitude;
typedef SNumeric TChannelCount;
typedef SNumeric TPhase;
//=====================================================================================
// Constants
//=====================================================================================
static const float c_pi = (float)M_PI;
static const float c_twoPi = c_pi * 2.0f;
//=====================================================================================
// Structs
//=====================================================================================
struct SSoundSettings
{
TSamples m_sampleRate;
TTimeMs m_lengthMs;
TChannelCount m_numChannels;
TSamples m_currentSample;
};
struct SDrumSettings
{
TFrequency m_frequency;
TSamples m_attack;
TSamples m_sustain;
TSamples m_release;
TAmplitude m_volume;
};
struct SDrumInstance
{
SDrumInstance(TSamples startTime, const SDrumSettings &settings)
: m_startTime(startTime)
, m_settings(settings)
, m_phase(0.0f)
{
}
const SDrumSettings &m_settings;
TSamples m_startTime;
TPhase m_phase;
};
//=====================================================================================
// Globals
//=====================================================================================
std::vector g_drumInstances;
//=====================================================================================
// Conversion Functions
//=====================================================================================
inline TDecibels AmplitudeToDB(TAmplitude volume)
{
return TDecibels(log10(volume.Value()));
}
inline TAmplitude DBToAmplitude(TDecibels dB)
{
return TAmplitude(pow(10.0f, dB.Value() / 20.0f));
}
TSamples SecondsToSamples(const SSoundSettings &s, float seconds)
{
return TSamples((int)(seconds * (float)s.m_sampleRate.Value()));
}
TSamples MilliSecondsToSamples(const SSoundSettings &s, float milliseconds)
{
return SecondsToSamples(s, milliseconds / 1000.0f);
}
TTimeMs SecondsToMilliseconds(float seconds)
{
return TTimeMs((uint32)(seconds * 1000.0f));
}
TFrequency Frequency(float octave, float note)
{
/* frequency = 440×(2^(n/12))
Notes:
0 = A
1 = A#
2 = B
3 = C
4 = C#
5 = D
6 = D#
7 = E
8 = F
9 = F#
10 = G
11 = G# */
return TFrequency((float)(440 * pow(2.0, ((double)((octave - 4) * 12 + note)) / 12.0)));
}
template
T AmplitudeToAudioSample(const TAmplitude& in)
{
const T c_min = std::numeric_limits::min();
const T c_max = std::numeric_limits::max();
const float c_minFloat = (float)c_min;
const float c_maxFloat = (float)c_max;
float ret = in.Value() * c_maxFloat;
if (ret c_maxFloat)
return c_max;
return (T)ret;
}
//=====================================================================================
// Wave File Writing Code
//=====================================================================================
struct SMinimalWaveFileHeader
{
//the main chunk
unsigned char m_szChunkID[4]; //0
uint32 m_nChunkSize; //4
unsigned char m_szFormat[4]; //8
//sub chunk 1 "fmt "
unsigned char m_szSubChunk1ID[4]; //12
uint32 m_nSubChunk1Size; //16
uint16 m_nAudioFormat; //18
uint16 m_nNumChannels; //20
uint32 m_nSampleRate; //24
uint32 m_nByteRate; //28
uint16 m_nBlockAlign; //30
uint16 m_nBitsPerSample; //32
//sub chunk 2 "data"
unsigned char m_szSubChunk2ID[4]; //36
uint32 m_nSubChunk2Size; //40
//then comes the data!
};
//this writes a wave file
template
bool WriteWaveFile(const char *fileName, const std::vector &samples, const SSoundSettings &sound)
{
//open the file if we can
FILE *file = fopen(fileName, "w+b");
if (!file)
return false;
//calculate bits per sample and the data size
const int32 bitsPerSample = sizeof(T) * 8;
const int dataSize = samples.size() * sizeof(T);
SMinimalWaveFileHeader waveHeader;
//fill out the main chunk
memcpy(waveHeader.m_szChunkID, "RIFF", 4);
waveHeader.m_nChunkSize = dataSize + 36;
memcpy(waveHeader.m_szFormat, "WAVE", 4);
//fill out sub chunk 1 "fmt "
memcpy(waveHeader.m_szSubChunk1ID, "fmt ", 4);
waveHeader.m_nSubChunk1Size = 16;
waveHeader.m_nAudioFormat = 1;
waveHeader.m_nNumChannels = sound.m_numChannels.Value();
waveHeader.m_nSampleRate = sound.m_sampleRate.Value();
waveHeader.m_nByteRate = sound.m_sampleRate.Value() * sound.m_numChannels.Value() * bitsPerSample / 8;
waveHeader.m_nBlockAlign = sound.m_numChannels.Value() * bitsPerSample / 8;
waveHeader.m_nBitsPerSample = bitsPerSample;
//fill out sub chunk 2 "data"
memcpy(waveHeader.m_szSubChunk2ID, "data", 4);
waveHeader.m_nSubChunk2Size = dataSize;
//write the header
fwrite(&waveHeader, sizeof(SMinimalWaveFileHeader), 1, file);
//write the wave data itself, converting it from float to the type specified
std::vector outSamples;
outSamples.resize(samples.size());
for (size_t index = 0; index < samples.size(); ++index)
outSamples[index] = AmplitudeToAudioSample(samples[index]);
fwrite(&outSamples[0], dataSize, 1, file);
//close the file and return success
fclose(file);
return true;
}
//=====================================================================================
// Oscilators
//=====================================================================================
void AdvancePhase(TPhase &phase, TFrequency frequency, TSamples sampleRate)
{
phase += TPhase(frequency.Value() / (float)sampleRate.Value());
while (phase >= TPhase(1.0f))
phase -= TPhase(1.0f);
while (phase 0.5f ? 1.0f : -1.0f);
}
TAmplitude AdvanceOscilator_Triangle(TPhase &phase, TFrequency frequency, TSamples sampleRate)
{
AdvancePhase(phase, frequency, sampleRate);
if (phase > TPhase(0.5f))
return TAmplitude((((1.0f - phase.Value()) * 2.0f) * 2.0f) - 1.0f);
else
return TAmplitude(((phase.Value() * 2.0f) * 2.0f) - 1.0f);
}
TAmplitude AdvanceOscilator_Saw_BandLimited(TPhase &phase, TFrequency frequency, TSamples sampleRate)
{
AdvancePhase(phase, frequency, sampleRate);
// sum the harmonics
TAmplitude ret(0.0f);
for (int harmonicIndex = 1; harmonicIndex <= 4; ++harmonicIndex)
{
TPhase harmonicPhase = phase * TPhase((float)harmonicIndex);
ret += TAmplitude(sin(harmonicPhase.Value()*c_twoPi) / (float)harmonicIndex);
}
//adjust the volume
ret *= TAmplitude(2.0f / c_pi);
return ret;
}
TAmplitude AdvanceOscilator_Square_BandLimited(TPhase &phase, TFrequency frequency, TSamples sampleRate)
{
AdvancePhase(phase, frequency, sampleRate);
// sum the harmonics
TAmplitude ret(0.0f);
for (int harmonicIndex = 1; harmonicIndex <= 4; ++harmonicIndex)
{
float harmonicFactor = (float)harmonicIndex * 2.0f - 1.0f;
TPhase harmonicPhase = phase * TPhase(harmonicFactor);
ret += TAmplitude(sin(harmonicPhase.Value()*c_twoPi) / harmonicFactor);
}
//adjust the volume
ret *= TAmplitude(4.0f / c_pi);
return ret;
}
TAmplitude AdvanceOscilator_Triangle_BandLimited(TPhase &phase, TFrequency frequency, TSamples sampleRate)
{
AdvancePhase(phase, frequency, sampleRate);
// sum the harmonics
TAmplitude ret(0.0f);
bool subtract = true;
for (int harmonicIndex = 1; harmonicIndex <= 10; ++harmonicIndex)
{
float harmonicFactor = (float)harmonicIndex * 2.0f - 1.0f;
TPhase harmonicPhase = phase * TPhase(harmonicFactor);
ret += TAmplitude(sin(harmonicPhase.Value()*c_twoPi) / (harmonicFactor*harmonicFactor)) * TAmplitude(subtract ? -1.0f : 1.0f);
}
//adjust the volume
ret *= TAmplitude(8.0f / (c_pi*c_pi));
return ret;
}
//=====================================================================================
// Drum Synthesis
//=====================================================================================
TAmplitude Drum(const SSoundSettings &sound, SDrumInstance &drum)
{
// if the drum hasn't started yet, nothing to do!
if (sound.m_currentSample < drum.m_startTime)
return TAmplitude(0.0f);
TFrequency frequencyMultiplier(1.0f);
TAmplitude envelopeVolume(0.0f);
TSamples sampleRelative = sound.m_currentSample - drum.m_startTime;
if (sampleRelative < drum.m_settings.m_attack)
{
envelopeVolume = TAmplitude(sampleRelative.Divide(drum.m_settings.m_attack));
}
else if (sampleRelative < drum.m_settings.m_attack + drum.m_settings.m_sustain)
{
envelopeVolume = TAmplitude(1.0f);
}
else if (sampleRelative < drum.m_settings.m_attack + drum.m_settings.m_sustain + drum.m_settings.m_release)
{
sampleRelative -= (drum.m_settings.m_attack + drum.m_settings.m_sustain);
envelopeVolume = TAmplitude(1.0f - sampleRelative.Divide(drum.m_settings.m_release));
frequencyMultiplier = TFrequency(envelopeVolume.Value());
}
else
{
return TAmplitude(0.0f);
}
const TFrequency freqDecay(0.8f);
envelopeVolume *= drum.m_settings.m_volume;
TFrequency frequency = drum.m_settings.m_frequency * ((TFrequency(1.0f) - freqDecay) + (frequencyMultiplier*freqDecay));
return AdvanceOscilator_Sine(drum.m_phase, frequency, sound.m_sampleRate) * envelopeVolume;
}
//=====================================================================================
// Main
//=====================================================================================
int main(int argc, char **argv)
{
//our sound parameters
SSoundSettings sound;
sound.m_sampleRate = TSamples(44100);
sound.m_lengthMs = SecondsToMilliseconds(9.0f);
sound.m_numChannels = TChannelCount(1);
// set up the data for our drums.
SDrumSettings drum1;
drum1.m_frequency = Frequency(1, 8);
drum1.m_attack = MilliSecondsToSamples(sound, 10.0f);
drum1.m_sustain = MilliSecondsToSamples(sound, 10.0f);
drum1.m_release = MilliSecondsToSamples(sound, 175.0f);
drum1.m_volume = DBToAmplitude(TDecibels(-3.0f));
SDrumSettings drum2 = drum1;
drum2.m_frequency = Frequency(2, 5);
SDrumSettings drum3 = drum1;
drum3.m_frequency = Frequency(2, 5);
SDrumSettings drum4 = drum1;
drum4.m_frequency = Frequency(1, 10);
SDrumSettings drumBG = drum1;
drumBG.m_frequency = Frequency(1, 2);
drumBG.m_volume = DBToAmplitude(TDecibels(-12.0f));
// setup drums: make a 4 beat pattern that occurs every other second
for (uint32 i = 1; i < sound.m_lengthMs.Value() / 1000; i += 2)
{
g_drumInstances.push_back(SDrumInstance(SecondsToSamples(sound, (float)i + 0.00f), drum1));
g_drumInstances.push_back(SDrumInstance(SecondsToSamples(sound, (float)i + 0.25f), drum2));
g_drumInstances.push_back(SDrumInstance(SecondsToSamples(sound, (float)i + 0.50f), drum3));
g_drumInstances.push_back(SDrumInstance(SecondsToSamples(sound, (float)i + 1.00f), drum4));
}
// setup drums: make a background beat
for (uint32 i = 0, c = sound.m_lengthMs.Value() / 1000 * 4; i < c; ++i)
g_drumInstances.push_back(SDrumInstance(SecondsToSamples(sound, (float)i / 4.0f), drumBG));
//make our buffer to hold the samples
TSamples numSamples = TSamples(sound.m_sampleRate.Value() * sound.m_numChannels.Value() * sound.m_lengthMs.Value() / 1000);
std::vector samples;
samples.resize(numSamples.Value());
// render our audio samples from our drum list
for (TSamples index = TSamples(0); index < numSamples; ++index)
{
sound.m_currentSample = index;
TAmplitude &sample = samples[index.Value()];
sample = TAmplitude(0.0f);
std::for_each(
g_drumInstances.begin(),
g_drumInstances.end(),
[&sample, &sound](SDrumInstance& drum)
{
sample += Drum(sound, drum);
}
);
}
// save as a wave file
WriteWaveFile("out.wav", samples, sound);
}
Links
If you want a better sounding drum, check out these links. Frankly, read everything on that site… there is such great stuff there. If you like synth, that is the place to read about cool stuff, but unfortunately it’s bent towards electrical engineers and musicians, not programmers.
Sound On Suond – Synthesizing Drums: The Bass Drum
Sound On Suond – Practical Bass Drum Synthesis
Here is some more info about envelopes too. Envelopes really are a core ingrediant to synthesizers. Applying different envelopes to the same sine wave frequency, you can make a variety of different sounding instruments. They are pretty darn powerful.
Wikipedia: ASDR Envelope
I got some REALLY cool synth stuff planned in the near future, so keep an eye out!
The blog at the bottom of the sea 