Processing audio is one of our core tasks. When you create a startup there are a thousand things that you could do manually or automate. Which ones do you automate? We decided to automate as little as possible. Yes, you’ve read it correctly; as little as possible.

Automating is great because you solve a problem once and you don’t have to do it ever again. If you know that you’ll have to do it again. In a startup, you don’t know what you’ll be doing tomorrow. They are higly experimetal endevours. We decided to do all the audio processing by hand; and we did it until Audacity, an excellent audio processing tool, became a recurring character in our nightmares.

We decided to automate. We picked the library NAudio because it’s free and apparently capable of doing what we need. We struggle with it at first, but it turned out there was a bug, which was solved quite quickly by the developers. Surely they deserve all the donations they can get, as soon as we are profitable, we’ll make one.

Our process is simple:

1. The intro starts
2. 6 seconds after that the main audio starts
3. 30 seconds after the main audio finishes, the outro finishes.

That ensures the proper synchronization of our amazing intro and outro. And the code is quite simple.

First, we load the intro, the outro and the main audio:

var intro = new WaveFileReader("Intro.wav"));
var outro = new WaveFileReader("Outro.wav"));
 
var audio = new WaveFileReader(OriginalAudioFileName);

Then we create the mixer stream:

var mixer = new WaveMixerStream32();
mixer.AutoStop;

Out of the loaded audios we create new ones with the proper time offsets (note: the intro doesn’t need an offset):

var audioOffsetted = new WaveOffsetStream(
   audio, TimeSpan.FromSeconds(6), TimeSpan.Zero, audio.TotalTime);
var outroOffset = TimeSpan.FromSeconds(6) + audio.TotalTime +
   TimeSpan.FromSeconds(30) - outro.TotalTime;
var outroOffsetted = new WaveOffsetStream(
   outro, outroOffset, TimeSpan.Zero, outro.TotalTime);

All our wavs are stored as 16bit, but the mixer expects 32bit wavs, so we convert them before adding them to the mixer:

var intro32 = new WaveChannel32(intro);
intro32.PadWithZeroes = false;
mixer.AddInputStream(intro32);
var outro32 = new WaveChannel32(outroOffsetted);
outro32.PadWithZeroes = false;
mixer.AddInputStream(outro32);
var audio32 = new WaveChannel32(audioOffsetted);
audio32.PadWithZeroes = false;
mixer.AddInputStream(audio32);

Pad with zeros is set to false because otherwise you end up with pretty big files. When we forgot that we ended up with a 10GB wav, not sure if we stopped it or it crashed.

Once our mixer is set up we save that wav to a temporary location

WaveFileWriter.CreateWaveFile(tempwav, new Wave32To16Stream(mixer));

tempwav is the full file name of the temporary wav. Note that we go back to 16bit wavs. After that comes the ugly part of converting to MP3 which is left as an exercise for the reader.

We hope you find this information useful.