How do I generate a tone using SDL_audio?

Question

I am trying to generate a simple, constant sine tone using SDL_audio. I have a small helper class that can be called to turn the tone on/off, change the frequency, and change the wave shape. I have followed some examples I could find on the web and got the following:

beeper.h

#pragma once

#include <SDL.h>
#include <SDL_audio.h>
#include <cmath>
#include "logger.h"

class Beeper {
private:
    //Should there be sound right now
    bool soundOn = true;
    //Type of wave that should be generated
    int waveType = 0;
    //Tone that the wave will produce (may or may not be applicable based on wave type)
    float waveTone = 440;
    //Running index for sampling
    float samplingIndex = 0;

    //These are useful variables that cannot be changed outside of this file:
    //Volume
    const Sint16 amplitude = 32000;
    //Sampling rate
    const int samplingRate = 44100;
    //Buffer size
    const int bufferSize = 1024;

    //Samples a sine wave at a given index
    float sampleSine(float index);
    //Samples a square wave at a given index
    float sampleSquare(float index);
public:
    //Initializes SDL audio, audio device, and audio specs
    void initializeAudio();
    //Function called by SDL audio_callback that fills stream with samples
    void generateSamples(short* stream, int length);
    //Turn sound on or off
    void setSoundOn(bool soundOnOrOff);
    //Set timbre of tone produced by beeper
    void setWaveType(int waveTypeID);
    //Set tone (in Hz) produced by beeper
    void setWaveTone(int waveHz);
};

beeper.cpp

#include <beeper.h>

void fillBuffer(void* userdata, Uint8* _stream, int len) {
    short * stream = reinterpret_cast<short*>(_stream);
    int length = len;
    Beeper* beeper = (Beeper*)userdata;

    beeper->generateSamples(stream, length);
}

void Beeper::initializeAudio() {
    SDL_AudioSpec desired, returned;
    SDL_AudioDeviceID devID;

    SDL_zero(desired);
    desired.freq = samplingRate;
    desired.format = AUDIO_S16SYS; //16-bit audio
    desired.channels = 1;
    desired.samples = bufferSize;
    desired.callback = &fillBuffer;
    desired.userdata = this;

    devID = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(0,0), 0, &desired, &returned, SDL_AUDIO_ALLOW_FORMAT_CHANGE);
    SDL_PauseAudioDevice(devID, 0);
}

void Beeper::generateSamples(short *stream, int length) {
    int samplesToWrite = length / sizeof(short);
    for (int i = 0; i < samplesToWrite; i++) {
        if (soundOn) {
            if (waveType == 0) {
                stream[i] = (short)(amplitude * sampleSine(samplingIndex));
            }
            else if (waveType == 1) {
                stream[i] = (short)(amplitude * 0.8 * sampleSquare(samplingIndex));
            }
        }
        else {
            stream[i] = 0;
        }
        //INFO << "Sampling index: " << samplingIndex;
        samplingIndex += (waveTone * M_PI * 2) / samplingRate;
        //INFO << "Stream input: " << stream[i];
        if (samplingIndex >= (M_PI*2)) {
            samplingIndex -= M_PI * 2;
        }
    }
}

void Beeper::setSoundOn(bool soundOnOrOff) {
    soundOn = soundOnOrOff;
    //if (soundOnOrOff) {
    //  samplingIndex = 0;
    //}
}

void Beeper::setWaveType(int waveTypeID) {
    waveType = waveTypeID;
    //samplingIndex = 0;
}

void Beeper::setWaveTone(int waveHz) {
    waveTone = waveHz;
    //samplingIndex = 0;
}

float Beeper::sampleSine(float index) {
    double result = sin((index));
    //INFO << "Sine result: " << result;
    return result;
}

float Beeper::sampleSquare(float index)
{
    int unSquaredSin = sin((index));
    if (unSquaredSin >= 0) {
        return 1;
    }
    else {
        return -1;
    }
}

The callback function is being called and the generateSamples function is loading data into the stream, but I cannot hear anything but a very slight click at irregular periods. I have had a look at the data inside the stream and it follows a pattern that I would expect for a scaled sine wave with a 440 Hz frequency. Is there something obvious that I am missing? I did notice that the size of the stream is double what I put when declaring the SDL_AudioSpec and calling SDL_OpenAudioDevice. Why is that?

Answer 1

Answered my own question! When opening the audio device I used the flag SDL_AUDIO_ALLOW_FORMAT_CHANGE which meant that SDL was actually using a float buffer instead of the short buffer that I expected. This was causing issues in a couple of places that were hard to detect (the stream being double the amount of bytes I was expecting should have tipped me off). I changed that parameter in SDL_OpenAudioDevice() to 0 and it worked as expected!