Audio waveform with unexpected frequency behavior

Audio waveform with unexpected frequency behavior

Bluebird

Member #15,421

December 2013

Hello. I've been playing around with audio recently, specifically trying to code a simple synthesizer. It works fine when only unchanging (static) frequencies are used (see ex_synth), but as soon as I try to interpolate a frequency when generating the waveform, things go ... wonky.

Here's the clearest explanation of the problem that I know how to give: the program generates a waveform. The waveform should ramp smoothly from a lower frequency to a higher frequency, without detour. But instead, the waveform ramps too high (for reasons I can't even begin to guess at) before finally coming down to the target.

The code is a complete program that demonstrates the problem.

#SelectExpand
   1
   2// This program generates a 5-second audio waveform that is supposed to ramp up
   3// smoothly from 220 hertz to 620 hertz in 4 seconds, with 1 remaining second at
   4// 620 hertz.
   5//
   6// The expected result is that the audio sound ramps up smoothly from one
   7// frequency to another. Directly. Don't pass GO, don't collect $200.
   8//
   9// The actual result is that the frequency ramps up higher than it should, then
  10// comes back down to the target frequency. How odd!
  11//
  12// The described problem is denied by the printouts generated when the program
  13// is run, which indicate that the frequency *should be* ramping as expected
  14// without frequency artifacts. But of course, the actual generated sound
  15// contradicts this. Take note of the 'Freq' column; it proves that the
  16// interpolation function works as expected. I'm pretty sure the problem isn't
  17// there -- the interpolation function is used in many other places in the real
  18// codebase without any issues. The algorithm was extracted off a math site.
  19//
  20// Note: in other tests the waveform was written to a file and inspected in an
  21// audio editor. The saved waveform exhibits the same problem.
  22
  23#include <cstdint>
  24#include <cstddef>
  25#include <cstdlib>
  26#include <cassert>
  27#include <cstdio>
  28#include <cmath>
  29
  30#include <allegro5/allegro.h>
  31#include <allegro5/allegro_audio.h>
  32
  33// Interpolates from one frequency to another within a duration.
  34float interpolate(float time, float base, float change, float duration)
  35{
  36  assert(duration > 0.0);
  37  auto pi = (float)ALLEGRO_PI;
  38
  39  if(time <= 0.0) return base;
  40  if(time >= duration) return base + change;
  41
  42  // This is a simple sinusoidal in/out interpolation. This math has been
  43  // well-tested in the real codebase for other purposes, there are no known
  44  // problems with it.
  45  return -change / 2.0f * (std::cos(pi * time / duration) - 1.0f) + base;
  46}
  47
  48// Generates the waveform.
  49void waveform(
  50  float* buffer, int32_t samples, float time, uint64_t count, float vfreq)
  51{
  52  auto pi = (float)ALLEGRO_PI;
  53  auto pi2 = pi * 2.0f;
  54  auto dt = 1.0f / vfreq;
  55
  56  for(int32_t i = 0; i < samples; ++i) {
  57    float pt = (float)i;
  58    float ti = time + pt * dt;
  59
  60    // Interpolate smoothly from 220 to 620 in 4 seconds.
  61    float wave = interpolate(ti, 220.0f, 400.0f, 4.0f) * pi2;
  62
  63    // Print variables every 1/32 second.
  64    if((count + i) % (44100 / 32) == 0) {
  65      printf("Time %f : Hertz %f : Freq %f : Arg %lf\n",
  66        ti, wave, wave / pi2, wave * ti);
  67    }
  68
  69    float va = std::sin(wave * ti);
  70    buffer[i] = va;
  71  }
  72}
  73
  74int32_t main(int32_t, const char**)
  75{
  76  // Declare variables in advance because using 'goto' for cleanup.
  77  bool success = false;
  78
  79  // Keep track of what items need cleaning up.
  80  bool have_alleg = false;
  81  bool have_audio = false;
  82  bool have_voice = false;
  83  bool have_mixer = false;
  84  bool have_stream = false;
  85
  86  bool mixer_attached = false;
  87  bool stream_attached = false;
  88
  89  // Set when time to exit.
  90  bool done = false;
  91
  92  ALLEGRO_VOICE* voice = nullptr;
  93  ALLEGRO_MIXER* mixer = nullptr;
  94  ALLEGRO_AUDIO_STREAM* stream = nullptr;
  95
  96  // Voice/mixer/stream frequency. Same variable, 2 representations.
  97  auto vfreq = 44100;
  98  auto ffreq = 44100.0f;
  99
 100  auto idepth = ALLEGRO_AUDIO_DEPTH_INT16;
 101  auto fdepth = ALLEGRO_AUDIO_DEPTH_FLOAT32;
 102  auto vchan = ALLEGRO_CHANNEL_CONF_2;
 103  auto schan = ALLEGRO_CHANNEL_CONF_1;
 104  auto fragments = 8; // Number of sample buffers.
 105
 106  // Samples per buffer. Same variable, 2 representations.
 107  auto samples = 1024;
 108  auto fsamps = 1024.0f;
 109
 110  float time = 0.0f;
 111  float dt = 1.0f / ffreq;
 112
 113  // Will store current sample value (1024 per second).
 114  uint64_t count = 0;
 115
 116  // Initializations.
 117  if(!al_install_system(ALLEGRO_VERSION_INT, atexit)) {
 118    printf("Could not init Allegro.\n");
 119    goto cleanup;
 120  } else have_alleg = true;
 121
 122  if(!al_install_audio()) {
 123    printf("Could not install audio.\n");
 124    goto cleanup;
 125  } else have_audio = true;
 126
 127  voice = al_create_voice(vfreq, idepth, vchan);
 128  if(!voice) {
 129    printf("Could not create hardware voice.\n");
 130    goto cleanup;
 131  } else have_voice = true;
 132
 133  mixer = al_create_mixer(vfreq, fdepth, vchan);
 134  if(!mixer) {
 135    printf("Could not create mixer.\n");
 136    goto cleanup;
 137  } else have_mixer = true;
 138
 139  mixer_attached = al_attach_mixer_to_voice(mixer, voice);
 140  if(!mixer_attached) {
 141    printf("Could not attach mixer to voice.\n");
 142    goto cleanup;
 143  }
 144
 145  stream = al_create_audio_stream(fragments, samples, vfreq, fdepth, schan);
 146  if(!stream) {
 147    printf("Could not create audio stream.\n");
 148    goto cleanup;
 149  } else have_stream = true;
 150
 151  stream_attached = al_attach_audio_stream_to_mixer(stream, mixer);
 152  if(!stream_attached) {
 153    printf("Could not attach audio stream to mixer.\n");
 154    goto cleanup;
 155  }
 156
 157  // Main loop.
 158  while(!done) {
 159    void* buffer = al_get_audio_stream_fragment(stream);
 160    if(!buffer) {
 161      al_rest(0.001f); // Don't be a timeslice hog.
 162      continue;
 163    }
 164
 165    // Generate waveform.
 166    waveform((float*)buffer, samples, time, count, ffreq);
 167
 168    // Advance time and sample count.
 169    time += (dt * fsamps);
 170    count += samples;
 171
 172    al_set_audio_stream_fragment(stream, buffer);
 173    if(time >= 5.0f) done = true; // Quit after 5 seconds.
 174  }
 175
 176  al_drain_audio_stream(stream);
 177
 178  success = true;
 179  cleanup:
 180
 181  // Cleanup.
 182  if(have_stream) {
 183    al_detach_audio_stream(stream);
 184    al_destroy_audio_stream(stream);
 185  }
 186
 187  if(have_mixer) {
 188    al_detach_mixer(mixer);
 189    al_destroy_mixer(mixer);
 190  }
 191
 192  if(have_voice) {
 193    al_detach_voice(voice);
 194    al_destroy_voice(voice);
 195  }
 196
 197  if(have_audio) al_uninstall_audio();
 198  if(have_alleg) al_uninstall_system();
 199
 200  if(success) {
 201    printf("Everything worked.\n");
 202    return EXIT_SUCCESS;
 203  }
 204
 205  printf("Something went wrong.\n");
 206  return EXIT_FAILURE;
 207}

I've been banging my head on this for three days now ... >:( :-/ What could possibly be the problem?

GullRaDriel

Member #3,861

September 2003

I think it has to be something lying inside the types conversions. Have you enabled all the possible warnings to search and see ?

I would try to launch it in valgrind, to check for overflows.

Edit: I would also not use 'auto' and clearly choose a defined type instead.

"Code is like shit - it only smells if it is not yours"
Allegro Wiki, full of examples and articles !!

MikiZX

Member #17,092

June 2019

Possibly you could try testing the code by replacing the interpolate function with a linear one. This should show if the input values you have at that point in your code are correct. Also, in your interpolate function try having a single point of return (i.e. first two return command could only set the temporary 'time' value for the final return to calculate the output).
Not really much help but who knows maybe it gives you some ideas as to what to try next.

Edgar Reynaldo

Major Reynaldo

May 2007

You're interpolating from cos(0) to cos(PI). This means your wave is scaled by from 1 to 0 to -1 as it progresses. Try linear interpolation first, then mess with it.

I'm going to try your code and see if I can get it to work.

Replacing your interpolate function with a strict linear interpolation made the code work.

    // Interpolate smoothly from 220 to 620 in 4 seconds.
    float wave = (220.0f + 100*ti) * pi2;

Ooh, try this :

    float wave = (440.0f + 220.0f*(sin(pi2*(count + i)/(float)samples))/4.0f) * pi2;

I call it the SoundBlaster

https://d1cxvcw9gjxu2x.cloudfront.net/attachments/612091

Eagle and Allegro 5 binaries | Older Allegro 4 and 5 binaries | Allegro 5 compile guide
King Piccolo will make it so Then I could just flip it with some sweet, sweet matrix math. In either case, I’ll ride this wagon until the wheels fall off. Thanks to those that keep it running

Bluebird

Member #15,421

December 2013

Ouch, my ears!

I've updated the program to address the remarks so far.

Regarding the use of auto and type conversions; trust me, if it was something simple like that I would have found it already. But anyway, all autos are replaced with concrete types. Also note, this program compiles without warnings using the usual flags: `-Wall -Weffc++ -Wextra -Wpedantic -Wconversion`.

I've added two new functions, linear interpolation and a function for discrete steps. The discrete step function produces the expected results as long as the step count is relatively low. Try making the step count 500 or higher; you'll start to notice the frequencies going too high.

I've added a command-line switch so you can test the different functions easily.

Edgar Reynaldo, I added your linear interpolate function, it's different from mine in that it doesn't have a specific target value, it just keeps increasing. Notice the problem shows up as soon as a target value is added to the code (command-line opt "edgar2").

#SelectExpand
   1
   2// This program generates a 5-second audio waveform that is supposed to ramp up
   3// smoothly from 220 hertz to 620 hertz in 4 seconds, with 1 remaining second at
   4// 620 hertz.
   5//
   6// The expected result is that the audio sound ramps up smoothly from one
   7// frequency to another. Directly. Don't pass GO, don't collect $200.
   8//
   9// The actual result is that the frequency ramps up higher than it should, then
  10// comes back down to the target frequency. How odd!
  11//
  12// The described problem is denied by the printouts generated when the program
  13// is run, which indicate that the frequency *should be* ramping as expected
  14// without frequency artifacts. But of course, the actual generated sound
  15// contradicts this. Take note of the 'Freq' column; it proves that the
  16// interpolation function works as expected. I'm pretty sure the problem isn't
  17// there -- the interpolation function is used in many other places in the real
  18// codebase without any issues. The algorithm was extracted off a math site.
  19//
  20// Note: in other tests the waveform was written to a file and inspected in an
  21// audio editor. The saved waveform exhibits the same problem.
  22
  23#include <cstdint>
  24#include <cstddef>
  25#include <cstdlib>
  26#include <cassert>
  27#include <cstdio>
  28#include <cstring>
  29#include <cmath>
  30
  31#include <string>
  32#include <exception>
  33#include <stdexcept>
  34
  35#include <allegro5/allegro.h>
  36#include <allegro5/allegro_audio.h>
  37
  38float g_step_count = 20.0f;
  39
  40// Interpolates from one frequency to another within a duration.
  41float interpolate_sinusoidal_inout(
  42  float time, float base, float change, float duration)
  43{
  44  assert(duration > 0.0);
  45  float pi = (float)ALLEGRO_PI;
  46
  47  if(time <= 0.0) time = 0.0f;
  48  if(time >= duration) time = duration;
  49
  50  // This is a simple sinusoidal in/out interpolation. This math has been
  51  // well-tested in the real codebase for other purposes, there are no known
  52  // problems with it.
  53  return -change / 2.0f * (std::cos(pi * time / duration) - 1.0f) + base;
  54}
  55
  56float interpolate_linear_tween(
  57  float time, float base, float change, float duration)
  58{
  59  assert(duration > 0.0);
  60
  61  if(time <= 0.0) time = 0.0f;
  62  if(time >= duration) time = duration;
  63
  64  // Linear interpolation without smoothing.
  65  return change * time / duration + base;
  66}
  67
  68// Change frequency in discrete steps without smoothing.
  69// Unlike the other two interpolation functions, this produces expected results
  70// *most* of the time. Try playing with the step count parameter. Large values
  71// start to cause wrong frequencies to be emitted (disregarding the static).
  72float interpolate_discrete_step(
  73  float time, float base, float change, float duration)
  74{
  75  assert(duration > 0.0);
  76
  77  if(time <= 0.0) time = 0.0f;
  78  if(time >= duration) time = duration;
  79
  80  float steps = g_step_count; // From command-line.
  81
  82  float delta = change / steps;
  83  float clock = duration / steps;
  84  float count = 0.0f;
  85
  86  while(time >= clock * count) {
  87    count = count + 1.0f;
  88  }
  89
  90  return base + delta * count - delta;
  91}
  92
  93// Generates the waveform.
  94void waveform(
  95    float* buffer,   // Raw sample buffer.
  96    int32_t samples, // Length of buffer.
  97    float time,      // Starting time value for this buffer.
  98    uint64_t count,  // Starting sample count for this buffer.
  99    float ffreq,     // Voice/mixer/stream frequency (float).
 100    int32_t vfreq,   // Voice/mixer/stream frequency (int).
 101    int32_t which    // Choice of interpolation function.
 102  )
 103{
 104  float pi = (float)ALLEGRO_PI;
 105  float pi2 = pi * 2.0f;
 106  float dt = 1.0f / ffreq;
 107
 108  for(int32_t i = 0; i < samples; ++i) {
 109    float pt = (float)i;
 110    float ti = time + pt * dt;
 111
 112    float wave;
 113    try_again:
 114
 115    if(which == 0) {
 116      // Interpolate smoothly from 220 to 620 in 4 seconds.
 117      wave = interpolate_sinusoidal_inout(ti, 220.0f, 400.0f, 4.0f) * pi2;
 118    }
 119    else if(which == 1) {
 120      // Direct linear interpolation.
 121      wave = interpolate_linear_tween(ti, 220.0f, 400.0f, 4.0f) * pi2;
 122    }
 123    else if(which == 2) {
 124      // Discrete steps in frequency, no smooth changes.
 125      // Note: high step counts create static.
 126      wave = interpolate_discrete_step(ti, 220.0f, 400.0f, 4.0f) * pi2;
 127    }
 128    else if(which == 3) {
 129      // Edgar Reynaldo.
 130      wave = (220.0f + 100 * ti) * pi2;
 131    }
 132    else if(which == 5) {
 133      // Edgar Reynaldo (with explicit stop point).
 134      float mu = ti;
 135      if(mu > 4.0f) mu = 4.0f;
 136      wave = (220.0f + 100 * mu) * pi2;
 137    }
 138    else if(which == 4) {
 139      // Sound Blaster.
 140      wave = (440.0f + 220.0f * (std::sin(pi2 * (float)(count + i) /
 141        (float)samples)) / 4.0f) * pi2;
 142    }
 143    else {
 144      which = 0;
 145      goto try_again;
 146    }
 147
 148    // Print variables every 1/32 second.
 149    if((count + i) % (vfreq / 32) == 0) {
 150      printf("Time %f : Hertz %f : Freq %f : Arg %lf\n",
 151        ti, wave, wave / pi2, wave * ti);
 152    }
 153
 154    float va = std::sin(wave * ti);
 155    buffer[i] = va;
 156  }
 157}
 158
 159int32_t main(int32_t argc, const char** argv)
 160{
 161  // Declare variables in advance because using 'goto' for cleanup.
 162  bool success = false;
 163
 164  // Keep track of what items need cleaning up.
 165  bool have_alleg = false;
 166  bool have_audio = false;
 167  bool have_voice = false;
 168  bool have_mixer = false;
 169  bool have_stream = false;
 170
 171  bool mixer_attached = false;
 172  bool stream_attached = false;
 173
 174  // Set when time to exit.
 175  bool done = false;
 176
 177  // Which interpolation function to use.
 178  int32_t which = 0;
 179
 180  ALLEGRO_VOICE* voice = nullptr;
 181  ALLEGRO_MIXER* mixer = nullptr;
 182  ALLEGRO_AUDIO_STREAM* stream = nullptr;
 183
 184  // Voice/mixer/stream frequency. Same variable, 2 representations.
 185  int32_t vfreq = 44100;
 186  float ffreq = 44100.0f;
 187
 188  ALLEGRO_AUDIO_DEPTH idepth = ALLEGRO_AUDIO_DEPTH_INT16;
 189  ALLEGRO_AUDIO_DEPTH fdepth = ALLEGRO_AUDIO_DEPTH_FLOAT32;
 190  ALLEGRO_CHANNEL_CONF vchan = ALLEGRO_CHANNEL_CONF_2;
 191  ALLEGRO_CHANNEL_CONF schan = ALLEGRO_CHANNEL_CONF_1;
 192  int32_t fragments = 8; // Number of sample buffers.
 193
 194  // Samples per buffer. Same variable, 2 representations.
 195  int32_t samples = 1024;
 196  float fsamps = 1024.0f;
 197
 198  float time = 0.0f;
 199  float dt = 1.0f / ffreq;
 200
 201  // Will store current sample value (1024 per second).
 202  uint64_t count = 0;
 203
 204  // Parse command-line options.
 205  if(argc >= 2) {
 206    if(strcmp(argv[1], "sine") == 0) which = 0;
 207    else if(strcmp(argv[1], "linear") == 0) which = 1;
 208    else if(strcmp(argv[1], "step") == 0) {
 209      which = 2;
 210
 211      // Parse step count parameter.
 212      if(argc >= 3) {
 213        std::string arg {argv[2]};
 214        try {
 215          std::size_t pos = 0;
 216          g_step_count = (float)std::stoi(arg, &pos);
 217
 218          // Screen out bad parameters.
 219          if(pos != arg.size() || g_step_count < 1.0f) {
 220            throw std::exception {};
 221          }
 222        } catch(...) {
 223          printf("Could not parse step count.\n");
 224          goto cleanup;
 225        }
 226      }
 227    }
 228    else if(strcmp(argv[1], "edgar") == 0) which = 3;
 229    else if(strcmp(argv[1], "edgar2") == 0) which = 5;
 230    else if(strcmp(argv[1], "blaster") == 0) which = 4;
 231    else if(strcmp(argv[1], "help") == 0) {
 232      printf("Options: "
 233        "sine | linear | step [count] | edgar | edgar2 | blaster | help.\n");
 234      success = true;
 235      goto cleanup;
 236    }
 237    else {
 238      printf("Unrecognized option.\n");
 239      goto cleanup;
 240    }
 241  }
 242
 243  // Initializations.
 244  if(!al_install_system(ALLEGRO_VERSION_INT, atexit)) {
 245    printf("Could not init Allegro.\n");
 246    goto cleanup;
 247  } else have_alleg = true;
 248
 249  if(!al_install_audio()) {
 250    printf("Could not install audio.\n");
 251    goto cleanup;
 252  } else have_audio = true;
 253
 254  voice = al_create_voice(vfreq, idepth, vchan);
 255  if(!voice) {
 256    printf("Could not create hardware voice.\n");
 257    goto cleanup;
 258  } else have_voice = true;
 259
 260  mixer = al_create_mixer(vfreq, fdepth, vchan);
 261  if(!mixer) {
 262    printf("Could not create mixer.\n");
 263    goto cleanup;
 264  } else have_mixer = true;
 265
 266  mixer_attached = al_attach_mixer_to_voice(mixer, voice);
 267  if(!mixer_attached) {
 268    printf("Could not attach mixer to voice.\n");
 269    goto cleanup;
 270  }
 271
 272  stream = al_create_audio_stream(fragments, samples, vfreq, fdepth, schan);
 273  if(!stream) {
 274    printf("Could not create audio stream.\n");
 275    goto cleanup;
 276  } else have_stream = true;
 277
 278  stream_attached = al_attach_audio_stream_to_mixer(stream, mixer);
 279  if(!stream_attached) {
 280    printf("Could not attach audio stream to mixer.\n");
 281    goto cleanup;
 282  }
 283
 284  // Main loop.
 285  while(!done) {
 286    void* buffer = al_get_audio_stream_fragment(stream);
 287    if(!buffer) {
 288      al_rest(0.001f); // Don't be a timeslice hog.
 289      continue;
 290    }
 291
 292    // Generate waveform.
 293    waveform((float*)buffer, samples, time, count, ffreq, vfreq, which);
 294
 295    // Advance time and sample count.
 296    time += (dt * fsamps);
 297    count += samples;
 298
 299    al_set_audio_stream_fragment(stream, buffer);
 300    if(time >= 5.0f) done = true; // Quit after 5 seconds.
 301  }
 302
 303  al_drain_audio_stream(stream);
 304
 305  success = true;
 306  cleanup:
 307
 308  // Cleanup.
 309  if(have_stream) {
 310    al_detach_audio_stream(stream);
 311    al_destroy_audio_stream(stream);
 312  }
 313
 314  if(have_mixer) {
 315    al_detach_mixer(mixer);
 316    al_destroy_mixer(mixer);
 317  }
 318
 319  if(have_voice) {
 320    al_detach_voice(voice);
 321    al_destroy_voice(voice);
 322  }
 323
 324  if(have_audio) al_uninstall_audio();
 325  if(have_alleg) al_uninstall_system();
 326
 327  if(success) {
 328    printf("Everything worked.\n");
 329    return EXIT_SUCCESS;
 330  }
 331
 332  printf("Something went wrong.\n");
 333  return EXIT_FAILURE;
 334}

The whole thing is very strange, I'm positive the problem can't be the interpolation function(s).

Edit: try $program step 10000. The results are nearly the same as linear (i.e., wrong), ignoring the static effects.

MikiZX

Member #17,092

June 2019

I've tried the source as well. After changing it a little I managed to get it to work ok (?).

The problem seems to be with this line:
float va = std::sin(wave * ti);

In the below source, you will see that there is a new global variable called 'sine' which progresses with each generated sample and according to the frequency calculated in the interpolate function.

I'm not sure how to post the source code so sorry for this:

Marked with '// THIS IS NEW' are the changes I did:

#include <cstdint>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <cstdio>
#include <cmath>

#include <allegro5/allegro.h>
#include <allegro5/allegro_audio.h>

float sine; // THIS IS NEW

// Interpolates from one frequency to another within a duration.
float interpolate(float time, float base, float change, float duration)
{
assert(duration > 0.0);
auto pi = (float)ALLEGRO_PI;

if (time <= 0.0) return base;
if (time >= duration) return base + change;

return -change / 2.0f * (std::cos(pi * time / duration) - 1.0f) + base;
}

// Generates the waveform.
void waveform(
float* buffer, int32_t samples, float time, uint64_t count, float vfreq)
{
auto pi = (float)ALLEGRO_PI;
auto pi2 = pi * 2.0f;
auto dt = 1.0f / vfreq;

for (int32_t i = 0; i < samples; ++i) {
float pt = (float)i;
float ti = time + pt * dt;

// Interpolate smoothly from 220 to 620 in 4 seconds.
float frequency = interpolate(ti, 220.0f, 400.0f, 4.0f) *pi2;

sine += frequency/44100.0f; // THIS IS NEW
float va = std::sin(sine);

buffer[i] = va;

}
}

int32_t main(int32_t, const char**)
{

sine = 0.0f; // THIS IS NEW

// Declare variables in advance because using 'goto' for cleanup.
bool success = false;

...

Bluebird

Member #15,421

December 2013

IT WORKS!

Thanks MikiZX, I can definitely say that your solution would never have occurred to me.

One thing about it that concerned me though, was that your sine variable would saturate eventually if the playback went on long enough. I fixed this with this code:

while(g_sine > pi2) g_sine -= pi2;

Here's the whole program, working correctly now. If anyone can think of a use for it, have at it!

#SelectExpand
   1// =============================================================================
   2// This program generates a 5-second audio waveform that ramps smoothly up or
   3// down for some number of seconds, and then holds at a single frequency for 1
   4// second longer.
   5//
   6// The expected result is that the audio sound ramps up smoothly from one
   7// frequency to another. Directly. Don't pass GO, don't collect $200.
   8//
   9// Author: Bluebird
  10// License: MIT
  11// =============================================================================
  12
  13#include <cstdint>
  14#include <cstddef>
  15#include <cstdlib>
  16#include <cassert>
  17#include <cstdio>
  18#include <cstring>
  19#include <cmath>
  20
  21#include <string>
  22#include <exception>
  23#include <stdexcept>
  24#include <algorithm>
  25
  26#include <allegro5/allegro.h>
  27#include <allegro5/allegro_audio.h>
  28
  29float g_step_count = 20.0f;
  30float g_sine = 0.0f; // Used like an "accumulator" in the interpolation code.
  31float g_start_frequency = 0.0f;
  32float g_frequency_change = 0.0f;
  33float g_interp_time = 0.0f;
  34
  35// Interpolates from one frequency to another within a duration.
  36float interpolate_sinusoidal_inout(
  37  float time, float base, float change, float duration)
  38{
  39  assert(duration > 0.0);
  40  float pi = (float)ALLEGRO_PI;
  41
  42  if(time <= 0.0) time = 0.0f;
  43  if(time >= duration) time = duration;
  44
  45  // This is a simple sinusoidal in/out interpolation.
  46  return -change / 2.0f * (std::cos(pi * time / duration) - 1.0f) + base;
  47}
  48
  49float interpolate_linear_tween(
  50  float time, float base, float change, float duration)
  51{
  52  assert(duration > 0.0);
  53
  54  if(time <= 0.0) time = 0.0f;
  55  if(time >= duration) time = duration;
  56
  57  // Linear interpolation without smoothing.
  58  return change * time / duration + base;
  59}
  60
  61// Change frequency in discrete steps without smoothing.
  62float interpolate_discrete_step(
  63  float time, float base, float change, float duration)
  64{
  65  assert(duration > 0.0);
  66
  67  if(time <= 0.0) time = 0.0f;
  68  if(time >= duration) time = duration;
  69
  70  float steps = g_step_count; // From command-line.
  71
  72  float delta = change / steps;
  73  float clock = duration / steps;
  74  float count = 0.0f;
  75
  76  while(time >= clock * count) {
  77    count = count + 1.0f;
  78  }
  79
  80  return base + delta * count - delta;
  81}
  82
  83// Generates the waveform.
  84void waveform(
  85    float* buffer,   // Raw sample buffer.
  86    int32_t samples, // Length of buffer.
  87    float time,      // Starting time value for this buffer.
  88    uint64_t count,  // Starting sample count for this buffer.
  89    float ffreq,     // Voice/mixer/stream frequency (float).
  90    int32_t vfreq,   // Voice/mixer/stream frequency (int).
  91    int32_t which    // Choice of interpolation function.
  92  )
  93{
  94  float pi = (float)ALLEGRO_PI;
  95  float pi2 = pi * 2.0f;
  96  float dt = 1.0f / ffreq;
  97
  98  for(int32_t i = 0; i < samples; ++i) {
  99    float pt = (float)i;
 100    float ti = time + pt * dt;
 101
 102    float frequency;
 103    float start = g_start_frequency;
 104    float change = g_frequency_change;
 105    float tt = g_interp_time;
 106    try_again:
 107
 108    if(which == 0) {
 109      // Interpolate smoothly from 220 to 620 in 4 seconds.
 110      frequency = interpolate_sinusoidal_inout(ti, start, change, tt) * pi2;
 111    }
 112    else if(which == 1) {
 113      // Direct linear interpolation.
 114      frequency = interpolate_linear_tween(ti, start, change, tt) * pi2;
 115    }
 116    else if(which == 2) {
 117      // Discrete steps in frequency, no smooth changes.
 118      // Note: high step counts may create static or stuttering.
 119      frequency = interpolate_discrete_step(ti, start, change, tt) * pi2;
 120    }
 121    else {
 122      which = 0;
 123      goto try_again;
 124    }
 125
 126    // Generate the waveform, allowing for frequency interpolation.
 127    g_sine = g_sine + frequency / ffreq;
 128    while(g_sine > pi2) g_sine -= pi2; // Prevent saturation.
 129    float va = std::sin(g_sine);
 130
 131    // Print variables every 1/32 second.
 132    if((count + i) % (vfreq / 32) == 0) {
 133      printf("Time %f : Freq %f : Sine %f\n",
 134        ti, frequency / pi2, g_sine);
 135    }
 136
 137    buffer[i] = va;
 138  }
 139}
 140
 141int32_t main(int32_t argc, const char** argv)
 142{
 143  // Declare variables in advance because using 'goto' for cleanup.
 144  bool success = false;
 145
 146  // Keep track of what items need cleaning up.
 147  bool have_alleg = false;
 148  bool have_audio = false;
 149  bool have_voice = false;
 150  bool have_mixer = false;
 151  bool have_stream = false;
 152
 153  bool mixer_attached = false;
 154  bool stream_attached = false;
 155
 156  // Set when time to exit.
 157  bool done = false;
 158
 159  // Which interpolation function to use.
 160  int32_t which = 0;
 161
 162  ALLEGRO_VOICE* voice = nullptr;
 163  ALLEGRO_MIXER* mixer = nullptr;
 164  ALLEGRO_AUDIO_STREAM* stream = nullptr;
 165
 166  // Voice/mixer/stream frequency. Same variable, 2 representations.
 167  int32_t vfreq = 44100;
 168  float ffreq = 44100.0f;
 169
 170  ALLEGRO_AUDIO_DEPTH idepth = ALLEGRO_AUDIO_DEPTH_INT16;
 171  ALLEGRO_AUDIO_DEPTH fdepth = ALLEGRO_AUDIO_DEPTH_FLOAT32;
 172  ALLEGRO_CHANNEL_CONF vchan = ALLEGRO_CHANNEL_CONF_2;
 173  ALLEGRO_CHANNEL_CONF schan = ALLEGRO_CHANNEL_CONF_1;
 174  int32_t fragments = 8; // Number of sample buffers.
 175
 176  // Samples per buffer. Same variable, 2 representations.
 177  int32_t samples = 1024;
 178  float fsamps = 1024.0f;
 179
 180  float time = 0.0f;
 181  float end_time = 0.0f;
 182  float dt = 1.0f / ffreq;
 183
 184  // Will store current sample value (1024 per second).
 185  uint64_t count = 0;
 186
 187  auto parse_float = [](
 188    int32_t argc, const char** argv, int32_t index, float* out)
 189  {
 190    assert(out);
 191    bool status = false;
 192
 193    if(argc >= index + 1) {
 194      std::string arg {argv[index]};
 195      try {
 196        std::size_t pos = 0;
 197        float result = (float)std::stof(arg, &pos);
 198
 199        // Screen out bad parameters.
 200        if(pos != arg.size()) {
 201          throw std::exception {};
 202        }
 203
 204        status = true;
 205        (*out) = result;
 206      }
 207      catch(...) {
 208        status = false;
 209      }
 210    }
 211
 212    return status;
 213  };
 214
 215  // Parse command-line options.
 216  if(argc >= 2) {
 217    // The index in the command-line at which common options start.
 218    int32_t common_index = 2;
 219
 220    if(strcmp(argv[1], "sine") == 0) {
 221      which = 0;
 222      goto do_common_opts;
 223    }
 224    else if(strcmp(argv[1], "linear") == 0) {
 225      which = 1;
 226      goto do_common_opts;
 227    }
 228    else if(strcmp(argv[1], "step") == 0) {
 229      which = 2;
 230      bool result = parse_float(argc, argv, 2, &g_step_count);
 231      if(!result) {
 232        printf("Could not parse step count.\n");
 233        goto cleanup;
 234      }
 235      g_step_count = std::max(g_step_count, 1.0f);
 236      g_step_count = std::floor(g_step_count);
 237
 238      common_index = 3;
 239      goto do_common_opts;
 240    }
 241    else if(strcmp(argv[1], "help") == 0) {
 242      printf("Options:\n"
 243        "  sine [start_freq] [freq_change] [total_time]\n"
 244        "  linear [start_freq] [freq_change] [total_time]\n"
 245        "  step [count] [start_freq] [freq_change] [total_time]\n"
 246        "  help\n");
 247      success = true;
 248      goto cleanup;
 249    }
 250    else {
 251      printf("Unrecognized option.\n");
 252      goto cleanup;
 253    }
 254
 255    // Parse common command-line options.
 256    if(false) {
 257      do_common_opts:
 258      bool result;
 259
 260      result = parse_float(argc, argv, common_index + 0, &g_start_frequency);
 261      if(!result) {
 262        g_start_frequency = 220.0f;
 263      }
 264
 265      result = parse_float(argc, argv, common_index + 1, &g_frequency_change);
 266      if(!result) {
 267        g_frequency_change = 400.0f;
 268      }
 269
 270      result = parse_float(argc, argv, common_index + 2, &end_time);
 271      if(!result) end_time = 5.0f;
 272      end_time = std::max(end_time, 2.0f);
 273      g_interp_time = end_time - 1.0f;
 274    }
 275  }
 276  else {
 277    printf("You must specify some option (pass \"help\").\n");
 278    goto cleanup;
 279  }
 280
 281  // Initializations.
 282  if(!al_install_system(ALLEGRO_VERSION_INT, atexit)) {
 283    printf("Could not init Allegro.\n");
 284    goto cleanup;
 285  } else have_alleg = true;
 286
 287  if(!al_install_audio()) {
 288    printf("Could not install audio.\n");
 289    goto cleanup;
 290  } else have_audio = true;
 291
 292  voice = al_create_voice(vfreq, idepth, vchan);
 293  if(!voice) {
 294    printf("Could not create hardware voice.\n");
 295    goto cleanup;
 296  } else have_voice = true;
 297
 298  mixer = al_create_mixer(vfreq, fdepth, vchan);
 299  if(!mixer) {
 300    printf("Could not create mixer.\n");
 301    goto cleanup;
 302  } else have_mixer = true;
 303
 304  mixer_attached = al_attach_mixer_to_voice(mixer, voice);
 305  if(!mixer_attached) {
 306    printf("Could not attach mixer to voice.\n");
 307    goto cleanup;
 308  }
 309
 310  stream = al_create_audio_stream(fragments, samples, vfreq, fdepth, schan);
 311  if(!stream) {
 312    printf("Could not create audio stream.\n");
 313    goto cleanup;
 314  } else have_stream = true;
 315
 316  stream_attached = al_attach_audio_stream_to_mixer(stream, mixer);
 317  if(!stream_attached) {
 318    printf("Could not attach audio stream to mixer.\n");
 319    goto cleanup;
 320  }
 321
 322  printf("Total time: %f, starting frequency: %f, target frequency: %f.\n",
 323    end_time, g_start_frequency, g_start_frequency + g_frequency_change);
 324
 325  // Main loop.
 326  while(!done) {
 327    void* buffer = al_get_audio_stream_fragment(stream);
 328    if(!buffer) {
 329      al_rest(0.001f); // Don't be a timeslice hog.
 330      continue;
 331    }
 332
 333    // Generate waveform.
 334    waveform((float*)buffer, samples, time, count, ffreq, vfreq, which);
 335
 336    // Advance time and sample count.
 337    time += (dt * fsamps);
 338    count += samples;
 339
 340    al_set_audio_stream_fragment(stream, buffer);
 341    if(time >= end_time) done = true; // Quit after some seconds.
 342  }
 343
 344  al_drain_audio_stream(stream);
 345
 346  printf("Total time: %f, starting frequency: %f, target frequency: %f.\n",
 347    end_time, g_start_frequency, g_start_frequency + g_frequency_change);
 348
 349  success = true;
 350  cleanup:
 351
 352  // Cleanup.
 353  if(have_stream) {
 354    al_detach_audio_stream(stream);
 355    al_destroy_audio_stream(stream);
 356  }
 357
 358  if(have_mixer) {
 359    al_detach_mixer(mixer);
 360    al_destroy_mixer(mixer);
 361  }
 362
 363  if(have_voice) {
 364    al_detach_voice(voice);
 365    al_destroy_voice(voice);
 366  }
 367
 368  if(have_audio) al_uninstall_audio();
 369  if(have_alleg) al_uninstall_system();
 370
 371  if(success) {
 372    printf("Everything worked.\n");
 373    return EXIT_SUCCESS;
 374  }
 375
 376  printf("Something went wrong.\n");
 377  return EXIT_FAILURE;
 378}

One thing of note is that Edgar Reynaldo's SoundBlaster no longer sounds as it was originally intended to sound. I guess it depended on the wrong frequency behavior.

Now if only I understood WHY it works ... I've been coding for years and I'm still not that good with math.

GullRaDriel

Member #3,861

September 2003

One thing that's helping for sure: always make the maximum number of operations before dividing.

a = ( b + c ) / d will keep precision longer than a = b/d + c/d

The sine thing look like a variable range problem. MikiZX added a global sine value which he initialize on main, and then iterate before using it along interpolation.

"Code is like shit - it only smells if it is not yours"
Allegro Wiki, full of examples and articles !!

Edgar Reynaldo

Major Reynaldo

May 2007

Hey, I thought you would be interested. I made a simple sound generator you might like.

Get it here (SoundFoX1.zip)

Source code included (depends on Eagle and Allegro 5)

#SelectExpand
   1#include "Eagle/backends/Allegro5Backend.hpp"
   2#include "Eagle.hpp"
   3
   4
   5/// Data(t) = Amplitude(t)*waveform(t)
   6
   7
   8typedef float (*WAVEFORM) (float);
   9typedef float (*VOLUMEFORM) (float);
  10typedef float (*FREQFORM) (float);
  11typedef float (*AUDIOFORM) (float);
  12
  13float SINWAVE (float pct) {
 return sin(pct*2*M_PI);
  15}
  16float TRIANGLEWAVE (float pct) {
 /// maps percent [0.0f,1.0f] to /\/ triangle wave
 pct = fmod(pct , 1.0);
 if (pct <= 0.25) {
    return 0.0f + 1*pct*4.0f;
 }
 else if (pct <= 0.75) {
    return 1.0f + (-2.0f*(pct - 0.25f)*2.0f);
 }
 else {
    return -1.0f + 1.0f*(pct - 0.75f);
 }
 return 0.0f;/// Not reached
  29}
  30float SQUAREWAVE (float pct) {
 pct = fmod(pct , 1.0);
 return (pct <= 0.5)?1.0:-1.0;
  33}
  34
  35
  36float RAMP (float pct) {
 pct = fmod(pct , 1.0f);
 return pct*pct*pct;
  39}
  40
  41float RAMP2 (float pct) {
 pct = fmod(pct , 1.0f);
 pct = 1.0 + 99.0f*pct;
 return log10(pct)/2.0f;
  45}
  46
  47float DAMP (float pct) {
 pct = fmod(pct , 1.0f);
 return (1.0f - pct)*(1.0f - pct);
  50}
  51
  52float HALFVOL(float pct) {return 0.5f;}
  53
  54float RAMPANDDAMP (float pct) {
 pct = fmod(pct , 1.0f);
 if (pct <= 0.5f) {
    return RAMP(pct*2.0f);
 }
 else {
    return DAMP(pct*2.0f - 1.0f);
 }
 return 0.0f;/// Not reached
  63}
  64
  65
  66
  67void waveform(float* buffer, int32_t samples, float time , float vfreq) {
for(int32_t i = 0; i < samples; ++i) {
  float ti = time + i/vfreq;//pt * samples/vfreq;
  70
  71//    buffer[i] = RAMP(fmod(ti,5.0f)/5.0)*TRIANGLEWAVE(440.0f*ti*2.0*M_PI);
  buffer[i] = SINWAVE((220.0f + 220.0f*DAMP(ti/7.0f))*ti*2.0f*M_PI);
}
  74}
  75
  76
  77float FREQ220(float pct) {return 220.0f + 110.0f*RAMP(pct);}
  78
  79template<class Type>
  80class Interp {
  81public :
 Type start;
 Type finish;
 
 Interp(Type begin , Type end) :
    start(begin),
    finish(end)
 {
    
 }
  91//   void operator(float pct);
 Type operator()(float pct) {
    pct = fmod(pct , 1.0f);
    return start + (finish-start)*pct;
 }
  96};
           
  98class Audio {
 int buffer_fragment_count;///< Fragment count
 int samples_per_buffer;///< Sample count
 float samples_per_second;///< Mixer frequency
 double secs_per_sample;///< Duration per sample
 103
 double sound_duration;
 
 VOLUMEFORM volform;
 WAVEFORM waveform;
 FREQFORM freqform;
 109
 double volume;
 double freq;
 
 113public :
 Audio() :
       buffer_fragment_count(8),
       samples_per_buffer(1024),
       samples_per_second(44100.0f),
       secs_per_sample(1.0/samples_per_second),
       sound_duration(5.0),
       volform(HALFVOL),
       waveform(SINWAVE),
       freqform(FREQ220),
       volume(0.0),
       freq(220.0)
 {}
 
 
 128//   void FillBuffer(float* buf , float audiotime);
 void FillBuffer(float* buf , float audiotime) {
    double ti = audiotime;
    for (unsigned int i = 0 ; i < (unsigned int)samples_per_buffer ; ++i) {
 132//         buf[i] = waveform(freqform(ti/sound_duration)*ti*2.0*M_PI/sound_duration);
 133//         buf[i] = waveform(220.0f*ti*2.0*M_PI);
 134//         buf[i] = waveform(Interp<float>(220.0f , 330.0f)(ti/sound_duration)*ti*2.0*M_PI);
 135///         buf[i] = Interp<float>(SINWAVE(220.0f*ti*2.0f*M_PI/3.0f) , SQUAREWAVE(220.0f*ti*2.0f*M_PI/3.0f))(ti/3.0f);
       buf[i] = volume*waveform(freq*2.0*M_PI*ti);
       ti += secs_per_sample;
    }
 }
 void SetVolume(double pct) {
    if (pct < 0.0) {pct = 0.0;}
    if (pct > 1.0) {pct = 1.0;}
    volume = pct;
 }
 void SetFrequency(double hz) {
    freq = hz;
 }
 void SetWaveForm(WAVEFORM wf) {
    waveform = wf;
 }
 151};
 152
 153
 154#include <iostream>
 155
 156
 157int main(int argc , char** argv) {
 
 (void)argc;
 (void)argv;
 
 
 SendOutputToFile("sfx.log.txt" , "" , false);
 EagleLogger::RemoveOutputStream(std::cout);
 
 Allegro5System* a5sys = GetAllegro5System();
 
 if (a5sys->Initialize(EAGLE_STANDARD_SETUP) != EAGLE_STANDARD_SETUP) {
    return -1;
 }
 
 ALLEGRO_VOICE* voice = al_create_voice(44100 , ALLEGRO_AUDIO_DEPTH_INT16 , ALLEGRO_CHANNEL_CONF_2);
 ALLEGRO_MIXER* mixer = al_create_mixer(44100 , ALLEGRO_AUDIO_DEPTH_INT16 , ALLEGRO_CHANNEL_CONF_2);
 ALLEGRO_AUDIO_STREAM* stream = al_create_audio_stream(8 , 1024 , 44100 , ALLEGRO_AUDIO_DEPTH_FLOAT32 , ALLEGRO_CHANNEL_CONF_1);
 
 if (!voice || !mixer || !stream) {
    EagleLog() << "Setup error" << std::endl;
    if (!voice) {
       EagleWarn() << "Failed to setup voice" << std::endl;
       return -1;
    }
    if (!mixer) {
       EagleWarn() << "Failed to setup mixer" << std::endl;
       return -2;
    }
    if (!stream) {
       EagleWarn() << "Failed to setup stream" << std::endl;
       return -3;
    }
    
 }
 192
 bool mixer_attached = al_attach_mixer_to_voice(mixer, voice);
 194
 if (!mixer_attached) {
    EagleWarn() << "Failed to attach mixer to voice" << std::endl;
    return -4;
 }
 
 bool stream_attached = al_attach_audio_stream_to_mixer(stream, mixer);
 201
 if (!stream_attached) {
    EagleWarn() << "Failed to attach stream to mixer" << std::endl;
    return -5;
 }
 
 if (al_get_audio_stream_fragments(stream) != 8) {
    EagleLog() << "Didn't get 8 fragments.\n";
 }
 if (al_get_audio_stream_channels(stream) != ALLEGRO_CHANNEL_CONF_1) {
    EagleLog() << "Not a mono stream!\n";
 }
 if (!al_get_audio_stream_attached(stream)) {
    EagleLog() << "Stream not attached!\n";
 }
 if (al_get_audio_stream_frequency(stream) != 44100) {
    EagleLog() << "Not mixing at 44100 HZ!\n";
 }
 
 int sw = 800;
 int sh = 600;
 
 EagleGraphicsContext* win = a5sys->CreateGraphicsContext("Main window" , sw , sh , EAGLE_OPENGL | EAGLE_WINDOWED);
 
 WidgetHandler gui(win);
 gui.SetWidgetArea(WIDGETAREA(Rectangle(0 , 0 , sw , sh) , false));
 gui.SetupBuffer(sw,sh , win);
 228
 RelativeLayout rlayout;
 gui.SetRootLayout(&rlayout);
 231
 Slider sl1,sl2,sl3;
 rlayout.AddWidget(&sl1 , LayoutRectangle(0.05 , 0.2 , 0.05 , 0.5));
 rlayout.AddWidget(&sl2 , LayoutRectangle(0.35 , 0.2 , 0.05 , 0.5));
 rlayout.AddWidget(&sl3 , LayoutRectangle(0.65 , 0.2 , 0.05 , 0.5));
 
 EagleFont* f = win->DefaultFont();
 
 BasicText lbl1,lbl2,lbl3;
 lbl1.SetText("VOL" , f);
 lbl2.SetText("HZ" , f);
 lbl3.SetText("WAVE" , f);
 
 rlayout.AddWidget(&lbl1 , LayoutRectangle(0.05 , 0.02 , 0.3 , 0.1));
 rlayout.AddWidget(&lbl2 , LayoutRectangle(0.35 , 0.02 , 0.3 , 0.1));
 rlayout.AddWidget(&lbl3 , LayoutRectangle(0.65 , 0.02 , 0.3 , 0.1));
 
 BasicText t1,t2,t3;
 t1.SetText("" , f);
 t2.SetText("" , f);
 t3.SetText("" , f);
 252
 rlayout.AddWidget(&t1 , LayoutRectangle(0.05 , 0.12 , 0.3 , 0.25));
 rlayout.AddWidget(&t2 , LayoutRectangle(0.35 , 0.12 , 0.3 , 0.25));
 rlayout.AddWidget(&t3 , LayoutRectangle(0.65 , 0.12 , 0.3 , 0.25));
 
 
 
 Audio audio;
 
 double vol = 0.5;
 double  freq = 220.0f;
 WAVEFORM wf = SINWAVE;
 
 audio.SetVolume(vol);
 audio.SetFrequency(freq);
 audio.SetWaveForm(wf);
 
 sl1.SetPercent(0.5);
 sl2.SetPercent(0.25);
 sl3.SetPercent(0.0);
 
 t1.SetText("0.5");
 t2.SetText("220.0");
 t3.SetText("SINWAVE");
 
 double start = ProgramTime::Now();
 double time = start;
 double audiotime = 0.0;
 280
 bool quit = false;
 bool redraw = true;
 283
 EagleEventHandler* sysqueue = a5sys->GetSystemQueue();
 
 sysqueue->ListenTo(&gui);
 
 a5sys->GetSystemTimer()->Start();
 
 
 while(!quit) {
    if (redraw) {
       win->Clear();
       gui.Display(win , 0 , 0);
       win->FlipDisplay();
    }
    
    do {
       EagleEvent e = a5sys->WaitForSystemEventAndUpdateState();
       if (e.type == EAGLE_EVENT_TIMER) {
          /// Check if the audio stream is empty
          void* buffer = 0;
          while ((buffer = al_get_audio_stream_fragment(stream))) {
             EagleLog() << "FillingBuffer...";
             audio.FillBuffer((float*)buffer , audiotime);
             audiotime += 1024.0/44100.0;
             al_set_audio_stream_fragment(stream , buffer);
          }
          gui.Update(e.timer.eagle_timer_source->SPT());
          redraw = true;
       }
       if (e.type == EAGLE_EVENT_DISPLAY_CLOSE) {
          quit = true;
       }
       if (e.type == EAGLE_EVENT_KEY_DOWN && e.keyboard.keycode == EAGLE_KEY_ESCAPE) {
          quit = true;
       }
       if (e.type == EAGLE_EVENT_WIDGET) {
          WIDGET_EVENT_DATA d = e.widget;
          if (d.from == &sl1 || d.from == &sl2 || d.from == &sl3) {
             if (d.topic == TOPIC_SLIDER) {
                if (d.msgs == SLIDER_VALUE_CHANGED) {
                   if (d.from == &sl1) {
                      vol = sl1.GetPercent();
                      audio.SetVolume(vol);
                      t1.SetText(StringPrintF("VOL %1.4lf" , vol));
                   }
                   if (d.from == &sl2) {
                      freq = 110.0 + 440.0*sl2.GetPercent();
                      audio.SetFrequency(freq);
                      t2.SetText(StringPrintF("HZ %1.4lf" , freq));
                   }
                   if (d.from == &sl3) {
                      double val = sl3.GetPercent();
                      if (val <= 0.34) {
                         wf = SINWAVE;
                         t3.SetText("SINWAVE");
                      }
                      else if (val <= 0.68) {
                         wf = TRIANGLEWAVE;
                         t3.SetText("TRIWAVE");
                      }
                      else {
                         wf = SQUAREWAVE;
                         t3.SetText("SQRWAVE");
                      }
                      audio.SetWaveForm(wf);
                   }
                }
             }
          }
       }
       else {
          gui.HandleEvent(e);
       }
    } while (sysqueue->HasEvent());
 }
 358
 359
 360
 return 0;
 362}