Play dynamically-created simple sounds in C# without external libraries

Question

I need to be able to generate dynamically a waveform and play it, using C#, without any external libraries, and without having to store sound files on the hard disk. Latency isn't an issue; the sounds would be generated well before they are needed by the application.

Actually the Console.Beep() method might meet my needs if it weren't for the fact that Microsoft says it isn't supported in 64-bit versions of Windows.

If I generate my own sound dynamically I can get a more fancy than a simple beep. For example, I could make a waveform from a triangle wave that increases in frequency from 2 KHz to 4 KHz while decaying in volume. I don't need fancy 16-bit stereo, just 8-bit mono is fine. I don't need dynamic control over volume and pitch, just basically generate a soundfile in memory and play it without storing it.

Last time I needed to generate sounds was many years ago, on Apple II, on HP workstations, and on my old Amiga computer. Haven't needed to do it since then, and it seems that something simple that I describe has gotten a lot more complicated. I am having trouble believing that something so simple seems so hard. Most of the answers I see refer to NAudio or similar libraries, and that isn't an option for this project (aside from the fact that pulling in an entire library just to play a tone seems like a waste).

Anachronist · Answer 1 · 2012-10-01T15:28:01.330

Based on one of the links in the answers I received, and some other pages I found about .wav header formats, here is my working code for a little class that generates an 8-bit "ding!" sound with a user-specified frequency and duration. It's basically a beep that decays linearly to zero in amplitude during the specified duration.

public class AlertDing {
    private SoundPlayer player = null;
    private BinaryWriter writer = null;

    /// <summary>
    /// Dynamically generate a "ding" sound and save it to a memory stream
    /// </summary>
    /// <param name="freq">Frequency in Hertz, e.g. 880</param>
    /// <param name="tenthseconds">Duration in multiple of 1/10 second</param>
    public AlertDing(double freq, uint tenthseconds) {

        string header_GroupID = "RIFF";  // RIFF
        uint header_FileLength = 0;      // total file length minus 8, which is taken up by RIFF
        string header_RiffType = "WAVE"; // always WAVE

        string fmt_ChunkID = "fmt "; // Four bytes: "fmt "
        uint fmt_ChunkSize = 16;     // Length of header in bytes
        ushort fmt_FormatTag = 1;        // 1 for PCM
        ushort fmt_Channels = 1;         // Number of channels, 2=stereo
        uint fmt_SamplesPerSec = 14000;  // sample rate, e.g. CD=44100
        ushort fmt_BitsPerSample = 8;   // bits per sample
        ushort fmt_BlockAlign =
            (ushort)(fmt_Channels * (fmt_BitsPerSample / 8)); // sample frame size, in bytes
        uint fmt_AvgBytesPerSec =
            fmt_SamplesPerSec * fmt_BlockAlign; // for estimating RAM allocation

        string data_ChunkID = "data";  // "data"
        uint data_ChunkSize;           // Length of header in bytes
        byte [] data_ByteArray;

        // Fill the data array with sample data

        // Number of samples = sample rate * channels * bytes per sample * duration in seconds
        uint numSamples = fmt_SamplesPerSec * fmt_Channels * tenthseconds / 10;
        data_ByteArray = new byte[numSamples];

        //int amplitude = 32760, offset=0; // for 16-bit audio
        int amplitude = 127, offset = 128; // for 8-audio
        double period = (2.0*Math.PI*freq) / (fmt_SamplesPerSec * fmt_Channels);
        double amp;
        for (uint i = 0; i < numSamples - 1; i += fmt_Channels) {
            amp = amplitude * (double)(numSamples - i) / numSamples; // amplitude decay
            // Fill with a waveform on each channel with amplitude decay
            for (int channel = 0; channel < fmt_Channels; channel++) {
                data_ByteArray[i+channel] = Convert.ToByte(amp * Math.Sin(i*period) + offset);
            }
        }

        // Calculate file and data chunk size in bytes
        data_ChunkSize = (uint)(data_ByteArray.Length * (fmt_BitsPerSample / 8));
        header_FileLength = 4 + (8 + fmt_ChunkSize) + (8 + data_ChunkSize);

        // write data to a MemoryStream with BinaryWriter
        MemoryStream audioStream = new MemoryStream();
        BinaryWriter writer = new BinaryWriter(audioStream);

        // Write the header
        writer.Write(header_GroupID.ToCharArray());
        writer.Write(header_FileLength);
        writer.Write(header_RiffType.ToCharArray());

        // Write the format chunk
        writer.Write(fmt_ChunkID.ToCharArray());
        writer.Write(fmt_ChunkSize);
        writer.Write(fmt_FormatTag);
        writer.Write(fmt_Channels);
        writer.Write(fmt_SamplesPerSec);
        writer.Write(fmt_AvgBytesPerSec);
        writer.Write(fmt_BlockAlign);
        writer.Write(fmt_BitsPerSample);

        // Write the data chunk
        writer.Write(data_ChunkID.ToCharArray());
        writer.Write(data_ChunkSize);
        foreach (byte dataPoint in data_ByteArray) {
            writer.Write(dataPoint);
        }
        player = new SoundPlayer(audioStream);
    }

    /// <summary>
    /// Call this to clean up when program is done using this sound
    /// </summary>
    public void Dispose() {
        if (writer != null) writer.Close();
        if (player != null) player.Dispose();
        writer = null;
        player = null;
    }

    /// <summary>
    /// Play "ding" sound
    /// </summary>
    public void Play() {
        if (player != null) {
            player.Stream.Seek(0, SeekOrigin.Begin); // rewind stream
            player.Play();
        }
    }
}

Hopefully this should help others who are trying to produce a simple alert sound dynamically without needing a sound file.

Except that it won't compile. `data_ByteArray` is not initialized before use, among other issues. — Mathias Lykkegaard Lorenzen, Sep 30 '12 at 12:11
Sorry, data_ShortArray should be data_ByteArray everywhere. That's what happens when I post something while working on it. I fixed the code above. It's working fine for me. — Anachronist, Oct 01 '12 at 15:28
If I enable 16-bit audio with your new code, I get an OverflowException. It is getting there though. — Mathias Lykkegaard Lorenzen, Oct 16 '12 at 14:48
If you enable 16 bit audio, then you need to change the byte [] data_ByteArray to short [] data_ShortArray, allocate it as a short array, and replace all occurrences of data_ByteArray to data_ShortArray in the code. My intention here was to produce a simple waveform sound, and for that one doesn't need the dynamic range of 16 bit audio; 8 bits is more than enough. If I were doing this in C, I'd simply allocate a character array of the proper size, and then cast the array pointer to a byte or short as appropriate. I'm not familiar enough with C# to know if I can do that here. — Anachronist, Oct 17 '12 at 22:19

Raman Zhylich · Answer 2 · 2012-08-01T23:07:08.657

0

The following article explains how *.wav file can be generated and played using SoundPlayer. Be aware that SoundPlayer can take a stream as an argument, so you can generate wav-file contents in a MemoryStream and avoid saving to a file.

http://blogs.msdn.com/b/dawate/archive/2009/06/24/intro-to-audio-programming-part-3-synthesizing-simple-wave-audio-using-c.aspx

edited Aug 01 '12 at 23:07

answered Aug 01 '12 at 23:01

Raman Zhylich

3,537
25
23

Huh. I saw that earlier, and disregarded it when I saw it required saving the wav data to a file. I forgot that SoundPlayer can accept the stream in the first place. But gosh, that's sure a complex solution to play a simple beep. I can go with it though. – Anachronist Aug 01 '12 at 23:45

score 0 · Answer 3 · answered Oct 09 '18 at 09:27

I tried out the code-snipped from Anachronist (2012-10) - and it is working for me.

biggest hurdle for me: get rid of the systematic "clicking-noise" at the end of "AlertDing" wav.

This is caused by a "soft-bug" in the code snipped:

for (uint i = 0; i < numSamples - 1; i += fmt_Channels)

needs to change to

for (uint i = 0; i < numSamples; i += fmt_Channels)

if not changed, a systematic "zero" will be generated at the end of each "play", causing a sharp clicking noise. (= amplitude jumps 0->min->0)

the original question implies "without clicking noise" of course :)

That will work if fmt_Channels always == 1. If you're doing stereo sound, then fmt_Channels = 2, and your change will result in an array bounds error. The end of loop test should be i < numSamples-1+fmt_Channels instead. — Anachronist, Oct 10 '18 at 11:30

Play dynamically-created simple sounds in C# without external libraries

3 Answers3

Linked