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.
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?
