What I want to try to figure out is a dumb way to automatically wire this up as the user adds more samples to the system. Basically, create a simple API over the complicated API... I'm curious if something like that is easy to accomplish, or would be a brainfuck to get working. We could call it, allegro_audio_unfucked.h.

I thought the number you passed to al_reserve_samples divided the volume of each attached sample instance?

I gave up on Allegro 5 audio in favor of FMOD despite the license restrictions.

I sweated for days trying to figure it out, but could not get it to behave in a predictable way. The amount of setup, guesswork, and gotchas is unreasonable.

This is not a war between the past and the future, there is no reason why there can't be an easy layer on top that is as useful as the old one. The current "easy" API doesn't let you modify channel properties after they have started playing. I couldn't even figure out the best way to detect that anything has stopped playing in order to free up channels in my own implementation, which is in my opinion suboptimal that we should have to do that in the first place. Unless a lot has changed in the past few months, to me, the API is far from usable.

With FMOD on the other hand I was up and running within an hour and am not wanting for functionality. What's Allegro's excuse?

Well, if al_reserve_samples(100) is not enough try al_reserve_samples(200). A piano only has 88 keys - and if you press the same key again it will interrupt the previous sound it made.

I posted the program above I think. I'm reserving 49 (7 * 7) samples, and the program only supports 7 notes at the moment. When a key down event is seen I begin playing the sounds, and when a key up event is seen I stop the sample using the ID I was given. Can you see a reason why that program won't work? If I can avoid having to setup mixers and instances and such myself that would be great, but from the sounds of it, I need to dig into this lower-level if I want sounds to sound predictable/as instructed.

After reading this thread i just had to try the allegro 5 "complex" audio addon that everyone is talking about here.
I played with it for about an hour or two ( including recompiling allegro to enable audio and browsing the web for samples ) and found out that it really is not "complex".
Just a little bit more involved on the side of initial setup. But it is a very small price to pay for the amount of control you will gain over your samples.
I had no issue playing samples in any way i liked, modify them on the fly, or play whatever amount of them i wanted.
But when i was playing too many samples i had to use ALLEGRO_AUDIO_DEPTH_FLOAT32 for voice and mixers because with the ALLEGRO_AUDIO_DEPTH_INT16 the sound was getting a bit distorted.

I find the audio addon very well made, and really easy to use.

Yeah, next time try figuring it out without the help of a thread like this. I got no easy help like this years ago when I asked the same questions. And the official documentation has STILL not been updated.

Even Edgar got confused about it all a few years back if you search. So don't give me this bullshit.

@Edgar

I'll admit I haven't used the API in at least a year. I threw up my hands the last time I tried to use it because it's so complex, but also because previously it was buggy and I needed to do a lot of workarounds.

The al_get_sample_instance_playing doesn't distinguish if the sample has stopped playing because it is finished or if you paused playback. Unless that has changed. Also IIRC it didn't work for one of the playable sound types and I had to code a workaround. This was years ago though. An event or callback would be better, then you are not constantly having to poll every sound.

I am glad you can now change properties of playing sounds. I will have to take another look. It'll be preferable to not need FMOD. But I still think Allegro 5 is too fussy and a simpler API similar to FMOD would be nice. Not everyone has the brain capacity and time to deal with a more powerful, more complicated API.

Last time I brought up that old shortcoming I was told that al_play_sample wasn't meant for advanced use and I needed to use the more lowlevel functions so I assumed it wasn't going to change any time soon.

(I had to implement my own dynamic channel system for The Lady, but if it's not needed anymore then al_get_sample_instance_playing is moot now.)

I just want to point out that defending things with your opinion, or "taking sides" when it comes to tools isn't helpful. Everybody is different, so a little more listening and a little less rhetoric would be good for everyone.

Right, people need to recognize that this is a free open-source project, so actually proposing ideas for solutions is way more constructive than just complaining.

My suggestion is pretty straightforward - provide a layer as easy as FMOD!

I will give credit where credit is due. Edgar's example he shared in here was really excellent and helped a lot. So koodos for that.

This is a good explanation, but I think that the instances are really implementation details. Instead, al_play_sample() could accept a pointer to an ALLEGRO_SAMPLE_PARAMETERS or something like that which can override the play settings. Under the hood, Allegro may wish to track it in an instance (needs to copy it anyway so the user can free it), but the user will just get an ID back that it can use to further manipulate playback. The ID can be used to pause or possibly readjust parameters if that's possible while an instance is already playing (e.g., al_tune_playback(id, &settings) or al_stop_playback(id)).

All the user has is an ALLEGRO_SAMPLE for the data. If necessary, they can allocate a temporarily ALLEGRO_SAMPLE_PARAMETERS on the stack to tune the playback, and if they want to be able to control playback after it has started then they will want to store a simple integer ID too.

Allegro should do whatever it needs to under the hood to make this work: play the sound as instructed, and do its best to make it sound as the caller would expect. If this means it needs to wire up mixers and voices and whatnot then it should do it on the fly, but as an implementation detail the user doesn't have to care about. If it's resource intensive and might be too slow to do while the game is running, then Allegro should try to allocate a complex enough hierarchy to do anything that could be asked of it when the addon is initialized (hopefully just a voice and a couple of mixers or something).

Even the user facing streams could probably be eliminated and just make samples themselves streamable. If a sample is streamed then the data would not be loaded fully when the file is opened, and it would transparently act like a stream instead when played. If file-based then Allegro will load up chunks of the file when needed. Or if the user is generating the stream data on the fly then it'll just respond to an event the same way, but be filling in a sample id instead something like al_stream_playback(id, buffer, start, count) (instead of the current API of getting a buffer and then setting it again, which doesn't make much sense).

Append:

I finally took a stab at rewriting my program to use the lower-level API.

diff --git a/src/main.c b/src/main.c
index ec60a45..e349017 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,33 +6,35 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+const int AUDIO_FREQUENCY = 44100;
+const ALLEGRO_AUDIO_DEPTH AUDIO_DEPTH = ALLEGRO_AUDIO_DEPTH_FLOAT32;
+const ALLEGRO_CHANNEL_CONF CHANNEL_CONF = ALLEGRO_CHANNEL_CONF_2;
+const int NUM_INSTANCES = 10000;
+
 #define notes_length (sizeof(notes) / sizeof(ALLEGRO_SAMPLE *))
 
 #define say_center(w, h, text) \
         (al_draw_text(musicals, white, w, h, ALLEGRO_ALIGN_CENTRE, text))
 
-#define play_note(i) \
-        (al_play_sample( \
-                 notes[i], \
-                 3.0, 0.0, 1.0, \
-                 ALLEGRO_PLAYMODE_ONCE, \
-                 &sample_ids[i]))
-
 static const char abcdefg[] = "abcdefg";
 
+int get_available_instance(int, ALLEGRO_SAMPLE_INSTANCE * [7][10000]);
+bool play_note(int, ALLEGRO_SAMPLE_INSTANCE * [7][10000]);
+
 int main(int argc, char * argv[])
 {
     char tmp[8] = "       ";
-    int i = 0, l = -1;
-    int playing[7] = {0};
+    int i = 0, il = -1, j = 0, jl = -1;
     int status = 0;
     ALLEGRO_COLOR black, white;
     ALLEGRO_DISPLAY * display = NULL;
     ALLEGRO_EVENT_QUEUE * event_queue = NULL;
     ALLEGRO_FONT * musicals = NULL;
+    ALLEGRO_MIXER * mixer = NULL;
     ALLEGRO_SAMPLE * notes[7] = {0};
-    ALLEGRO_SAMPLE_ID sample_ids[7] = {0};
+    ALLEGRO_SAMPLE_INSTANCE * instances[7][10000] = {0};
     ALLEGRO_TIMEOUT timeout;
+    ALLEGRO_VOICE * voice = NULL;
 
     if (!al_init()) {
         fprintf(stderr, "al_init failed\n");
@@ -78,12 +80,32 @@ int main(int argc, char * argv[])
         goto error;
     }
 
-    if (!al_reserve_samples(7 * 7)) {
-        fprintf(stderr, "al_reserve_samples failed\n");
+    voice = al_create_voice(
+            AUDIO_FREQUENCY,
+            AUDIO_DEPTH,
+            CHANNEL_CONF);
+
+    if (voice == NULL) {
+        fprintf(stderr, "al_create_voice failed\n");
+        goto error;
+    }
+
+    mixer = al_create_mixer(
+            AUDIO_FREQUENCY,
+            AUDIO_DEPTH,
+            CHANNEL_CONF);
+
+    if (mixer == NULL) {
+        fprintf(stderr, "al_create_mixer failed\n");
+        goto error;
+    }
+
+    if (!al_attach_mixer_to_voice(mixer, voice)) {
+        fprintf(stderr, "al_attach_mixer_to_voice failed\n");
         goto error;
     }
 
-    for (i=0,l=notes_length; i<l; i++) {
+    for (i=0,il=notes_length; i<il; i++) {
         char filename[22] = "media/Piano.pp.A3.ogg";
 
         filename[15] = 'A' + i;
@@ -97,6 +119,24 @@ int main(int argc, char * argv[])
         if (notes[i] == NULL) {
             fprintf(stderr, "al_load_sample %s failed\n", filename);
             goto error;
+        } else {
+            for(j=0,jl=NUM_INSTANCES; j<jl; j++) {
+                instances[i][j] = al_create_sample_instance(notes[i]);
+
+                if (instances[i][j] == NULL) {
+                    fprintf(stderr,
+                            "al_create_sample_instance %s[%d] failed\n",
+                            filename, j);
+                    goto error;
+                }
+
+                if (!al_attach_sample_instance_to_mixer(instances[i][j], mixer)) {
+                    fprintf(stderr,
+                            "al_attach_sample_instance_to_mixer %s[%d] failed\n",
+                            filename, j);
+                    goto error;
+                }
+            }
         }
     }
 
@@ -134,9 +174,7 @@ int main(int argc, char * argv[])
                         i = ev.keyboard.keycode - ALLEGRO_KEY_A;
                         tmp[i] = abcdefg[i];
 
-                        if (playing[i] == 0) {
-                            playing[i] = play_note(i);
-                        }
+                        play_note(i, instances);
                     } else {
                         switch (ev.keyboard.keycode) {
                             case ALLEGRO_KEY_ESCAPE:
@@ -151,11 +189,6 @@ int main(int argc, char * argv[])
                             ev.keyboard.keycode <= ALLEGRO_KEY_G) {
                         i = ev.keyboard.keycode - ALLEGRO_KEY_A;
                         tmp[i] = ' ';
-
-                        if (playing[i] != 0) {
-                            al_stop_sample(&sample_ids[i]);
-                            playing[i] = 0;
-                        }
                     }
                     break;
             }
@@ -170,10 +203,20 @@ int main(int argc, char * argv[])
     }
 
 clean:
-    for (i=0,l=notes_length; i<l; i++) {
-        if (notes[i]) al_destroy_sample(notes[i]);
+    for (i=0,il=notes_length; i<il; i++) {
+        if (notes[i]) {
+            al_destroy_sample(notes[i]);
+
+            for (j=0,jl=NUM_INSTANCES; j<jl; j++) {
+                if (instances[i][j]) {
+                    al_destroy_sample_instance(instances[i][j]);
+                }
+            }
+        }
     }
     if (musicals) al_destroy_font(musicals);
+    if (mixer) al_destroy_mixer(mixer);
+    if (voice) al_destroy_voice(voice);
     if (event_queue) al_destroy_event_queue(event_queue);
     if (display) al_destroy_display(display);
 
@@ -183,3 +226,31 @@ error:
     status = 1;
     goto clean;
 }
+
+int get_available_instance(
+        int i,
+        ALLEGRO_SAMPLE_INSTANCE * instances[7][10000]) {
+    int j, l;
+
+    for (j=0, l=NUM_INSTANCES; j<l; j++) {
+        if (!al_get_sample_instance_playing(instances[i][j])) {
+            return j;
+        }
+    }
+
+    return -1;
+}
+
+bool play_note(
+        int i,
+        ALLEGRO_SAMPLE_INSTANCE * instances[7][10000]) {
+    int j = get_available_instance(i, instances);
+
+    if (j == -1) {
+        return false;
+    }
+
+    return al_set_sample_instance_playing(
+           instances[i][j],
+           true);
+}

What I found was increased complexity having to manage a nested layer of objects. In my case, I am loading 7 "notes", and to allow notes to be repeatedly played I try to keep many samples around for each note. I started with 7, but the program quickly ran out of air again. I presume because the sample files that I happened to find vary in length up to a minute or so. It seems evident that I need to trim the files down to a shorter slice, or else find better files. That said, I tried creating 10000 instances per note (see code above for that hack) and still resulted in gittering and unpredictable behavior. Not only did the sounds eventually stop working (for a while anyway) again, but it seemed the more instances I fired up by repeatedly pressing "A" the more "pops" I'd hear. Pops that are not part of the sample data. Am I doing something wrong now with the lower level?

I hope that I'm missing something obvious here. If this is truly the direction my program has to go then I think it would illustrate why the current API is bad.

I meant for large files.

Then why doesn't my original program work? Did you ever get a chance to try that?

What files did you use to test? I wonder if those would have an affect? Can you share the Windows build and files for me to try in Windows? Source too please so I can compare.

I just figured the best way to rule out other "magical" explanations was to do it all myself. This is pretty much exploration at this point to figure out what works so that I can learn from it and understand it.

Ubuntu 16.04 (Xenial Xerces).

Interesting. I'll give the different driver options a try tonight.