MiniAL usage optimization for more optimal GUS performance.

Author: Franticware

src/gamemng.cpp

@@ -269,7 +269,6 @@ void Gamemng::init_sound()
 {
     p_sound_crash = new Sound_crash;
     p_sound_crash->init(p_sound_game_static.p_hit_stream); // nulové *p_audiodevice je ošéfované uvnitř
-    p_sound_crash->p_global_volume = &p_global_volume;
 }
 
 void Gamemng::unset_scissor()

src/gamemng.h

@@ -382,13 +382,11 @@ class Gamemng {
 
     Sound_car* p_sound_car;
 
-    float p_global_volume;
-
     int p_global_volume_i;
 
     int get_global_volume() { return p_global_volume_i; }
     void set_global_volume(int volume) { if (volume < 0) volume = 0; else if (volume > 100) volume = 100;
-        p_global_volume_i = volume; p_global_volume = p_global_volume_i*0.01f; }
+        p_global_volume_i = volume; alListenerf(AL_GAIN, p_global_volume_i*0.01f); }
 
 
     Gamemenu p_gamemenu;

src/gamemng_load.cpp

@@ -213,8 +213,7 @@ bool Gamemng::load(int players_sel, const int* cars_sel, const int* cars_tex_sel
         p_sound_game_static.load(i, p_cars[cars_sel[i]].p_engine0_sample, p_cars[cars_sel[i]].p_engine1_sample);
 
         // zvuky
-        p_sound_car[i].p_global_volume = &p_global_volume; // je důležité, aby toto bylo první
-        p_sound_car[i].init(p_sound_game_static.p_engine0_stream[i], p_sound_game_static.p_engine1_stream[i], p_cars[cars_sel[i]].engine1_pitch, p_sound_game_static.p_skid_stream[i], i, p_players);
+        p_sound_car[i].init(p_sound_game_static.p_engine_stream[i], p_sound_game_static.p_engine0_sample[i], p_sound_game_static.p_engine1_sample[i], p_cars[cars_sel[i]].engine1_pitch, p_sound_game_static.p_skid_stream[i], i, p_players);
 
         // částice
         if (p_particles)

src/main.cpp

@@ -373,7 +373,7 @@ int my_main (int argc, char** argv)
 
         static const ALCint attribs[] = {
             ALC_FREQUENCY, ma_freq,
-            ALC_MONO_SOURCES, 32,
+            ALC_MONO_SOURCES, 14,
             0, 0
         };
 

src/soundmng.cpp

@@ -13,8 +13,13 @@ extern std::vector<ALuint> global_al_buffers;
 
 ALuint createSource(ALuint buffer)
 {
-    ALuint source;
-    alGenSources(1, &source); global_al_sources.push_back(source);
+    ALuint source = 0;
+    alGenSources(1, &source);
+    if (alGetError() == AL_OUT_OF_MEMORY)
+    {
+        fprintf(stderr, "AL source allocation error\n");
+    }
+    global_al_sources.push_back(source);
     const ALfloat sourcePos[] = { 0.0, 0.0, 0.0 };
     const ALfloat sourceVel[] = { 0.0, 0.0, 0.0 };
     alSourcef (source, AL_PITCH,    1.0      );
@@ -29,10 +34,12 @@ ALuint createSource(ALuint buffer)
 
 void Sound_game_static::playSoundTest(float gain)
 {
-    alSourceStop(p_test_stream);
-    alSourceRewind(p_test_stream);
-    alSourcef(p_test_stream, AL_GAIN, gain);
-    alSourcePlay(p_test_stream);
+    alSourceStop(p_hit_stream[0]);
+    alSourceRewind(p_hit_stream[0]);
+    alSourcef(p_hit_stream[0], AL_GAIN, 1.0);
+    alSourcef(p_hit_stream[0], AL_PITCH, 1.0);
+    alListenerf(AL_GAIN, gain);
+    alSourcePlay(p_hit_stream[0]);
 }
 
 void Sound_game_static::init()
@@ -60,38 +67,42 @@ void Sound_game_static::init()
         p_skid_stream[i] = createSource(p_skid_sample);
     }
     for (int j = 0; j != 2; ++j)
-        for (int i = 0; i != 5; ++i) {
-            p_hit_stream[i+j*5] = createSource(p_hit_sample[j]);
+        for (int i = 0; i != hitStreamCount/2; ++i) {
+            p_hit_stream[i+j*(hitStreamCount/2)] = createSource(p_hit_sample[j]);
         }
 
-    p_test_stream = createSource(p_hit_sample[0]);
+    //p_test_stream = createSource(p_hit_sample[0]);
 }
 
 void Sound_game_static::load(unsigned int i, ALbuffer engine0_sample, ALbuffer engine1_sample)
 {
     if (i >= 4)
         return;
-    if (p_engine0_stream[i] == 0)
-        p_engine0_stream[i] = createSource(engine0_sample);
-    else
-        alSourcei(p_engine0_stream[i], AL_BUFFER, engine0_sample);
-    if (p_engine1_stream[i] == 0)
-        p_engine1_stream[i] = createSource(engine1_sample);
-    else
-        alSourcei(p_engine1_stream[i], AL_BUFFER, engine1_sample);
+    if (p_engine_stream[i] == 0)
+        p_engine_stream[i] = createSource(0);
+
+    p_engine0_sample[i] = engine0_sample;
+    p_engine1_sample[i] = engine1_sample;
 }
 
 void Sound_car::stop()
 {
-    alSourceStop(p_engine0_stream);
+    if (p_engine0_state)
+    {
+        alGetSourcef(p_engine_stream, AL_SAMPLE_OFFSET, &p_engine0_offset);
+    }
+    else if (p_engine1_state)
+    {
+        alGetSourcef(p_engine_stream, AL_SAMPLE_OFFSET, &p_engine1_offset);
+    }
+    alSourceStop(p_engine_stream);
     p_engine0_state = 0;
-    alSourceStop(p_engine1_stream);
     p_engine1_state = 0;
-    alSourceStop(p_skid_stream);
+    alSourcePause(p_skid_stream);
     p_skid_state = 0;
 }
 
-const float engine1_volume0 = 0.75f;
+static constexpr float engine1_volume0 = 0.75f;
 
 void Sound_car::frame(float deltaT, int engine_state /*0 - nultý, 1 - první, 2 - první potichu*/, float engine_pitch, const float velocity[2])
 {
@@ -103,33 +114,41 @@ void Sound_car::frame(float deltaT, int engine_state /*0 - nultý, 1 - první, 2
     if (engine_state == 0)
     {
         p_engine_on = 0;
-        alSourcef(p_engine0_stream, AL_GAIN, 0.5f**p_global_volume);
-        if (!p_engine0_state) {
-            alSourcePlay(p_engine0_stream);
-            p_engine0_state = 1;
-        }
+        alSourcef(p_engine_stream, AL_GAIN, 0.5f);
         if (p_engine1_state) {
-            alSourceStop(p_engine1_stream);
+            alGetSourcef(p_engine_stream, AL_SAMPLE_OFFSET, &p_engine1_offset);
+            alSourceStop(p_engine_stream);
             p_engine1_state = 0;
         }
+        if (!p_engine0_state) {
+            alSourcef(p_engine_stream, AL_GAIN, 0.5f);
+            alSourcef(p_engine_stream, AL_PITCH, 1.f);
+            alSourcei(p_engine_stream, AL_BUFFER, p_engine0_sample);
+            alSourcef(p_engine_stream, AL_SAMPLE_OFFSET, p_engine0_offset);
+            alSourcePlay(p_engine_stream);
+            p_engine0_state = 1;
+        }
     } else {
         if (engine_state == 1) {
             p_engine_on = 1;
-            alSourcef(p_engine1_stream, AL_GAIN, engine1_volume0**p_global_volume);
+            alSourcef(p_engine_stream, AL_GAIN, engine1_volume0);
         } else {
-            alSourcef(p_engine1_stream, AL_GAIN, 0.5f**p_global_volume);
+            alSourcef(p_engine_stream, AL_GAIN, 0.5f);
         }
 
-        alSourcef(p_engine1_stream, AL_PITCH, engine_pitch*p_running_pitch);
+        alSourcef(p_engine_stream, AL_PITCH, engine_pitch*p_running_pitch);
 
-        if (!p_engine1_state) {
-            alSourcePlay(p_engine1_stream);
-            p_engine1_state = 1;
-        }
         if (p_engine0_state) {
-            alSourceStop(p_engine0_stream);
+            alGetSourcef(p_engine_stream, AL_SAMPLE_OFFSET, &p_engine0_offset);
+            alSourceStop(p_engine_stream);
             p_engine0_state = 0;
         }
+        if (!p_engine1_state) {
+            alSourcei(p_engine_stream, AL_BUFFER, p_engine1_sample);
+            alSourcef(p_engine_stream, AL_SAMPLE_OFFSET, p_engine1_offset);
+            alSourcePlay(p_engine_stream);
+            p_engine1_state = 1;
+        }
     }
 
     if (p_brake_volume <= 0.f)
@@ -139,7 +158,7 @@ void Sound_car::frame(float deltaT, int engine_state /*0 - nultý, 1 - první, 2
             p_skid_state = 0;
         }
     } else {
-        alSourcef(p_skid_stream, AL_GAIN, p_brake_volume**p_global_volume);
+        alSourcef(p_skid_stream, AL_GAIN, p_brake_volume);
 
         float speed = std::sqrt(velocity[0]*velocity[0] + velocity[1]*velocity[1]);
         float skidPitch = 0.8f+(speed - 6.f)/24.f*0.4f;
@@ -155,7 +174,7 @@ void Sound_car::frame(float deltaT, int engine_state /*0 - nultý, 1 - první, 2
     }
 }
 
-void Sound_car::init(ALsource stream_idle, ALsource stream_running, float running_pitch, ALsource stream_skid, int player, int players_n)
+void Sound_car::init(ALsource stream_engine, ALbuffer sample_idle, ALbuffer sample_running, float running_pitch, ALsource stream_skid, int player, int players_n)
 {
     p_brake_volume = 0.f;
     // toto zásadně změnit
@@ -173,25 +192,25 @@ void Sound_car::init(ALsource stream_idle, ALsource stream_running, float runnin
     default: // 3, 4
         if (player < 2) p_pan = -1; else p_pan = 1;
     }
-    p_engine0_stream = stream_idle;
-    p_engine1_stream = stream_running;
+    p_engine_stream = stream_engine;
+    p_engine0_sample = sample_idle;
+    p_engine1_sample = sample_running;
     p_skid_stream = stream_skid;
     p_time = 0.f;
     p_T = 0.01f;
 
-    alSourcei(p_engine0_stream, AL_LOOPING, 1);
-    alSourcei(p_engine1_stream, AL_LOOPING, 1);
+    alSourcei(p_engine_stream, AL_LOOPING, 1);
     alSourcei(p_skid_stream, AL_LOOPING, 1);
     // nejmenší délka v samplech je 32000
-    alSourcef(p_engine0_stream, AL_SAMPLE_OFFSET, (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n));
-    alSourcef(p_engine0_stream, AL_SAMPLE_OFFSET, (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n));
-    alSourcef(p_engine0_stream, AL_SAMPLE_OFFSET, (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n));
 
-    alSourcef(p_engine0_stream, AL_GAIN, 0.5**p_global_volume);
-    alSourcef(p_engine1_stream, AL_GAIN, engine1_volume0**p_global_volume);
+    p_engine0_offset = (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n);
+    p_engine1_offset = (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n);
+
+    alSourcef(p_skid_stream, AL_SAMPLE_OFFSET, (smallSampleRam() ? 16000.0 : 32000.0)*double(player)/double(players_n));
 
     p_engine0_state = 0; // 0 - nehraje, 1 - hraje
     p_engine1_state = 0; // 0 - nehraje, 1 - hraje
+
     p_skid_state = 0;
 
     p_engine_on = 0;
@@ -216,7 +235,7 @@ void Sound_crash::play(float c_j) // přehraje zvuk nárazu
 
     alSourceStop(p_hit_stream[sel]);
     alSourceRewind(p_hit_stream[sel]);
-    alSourcef(p_hit_stream[sel], AL_GAIN, volume**p_global_volume);
+    alSourcef(p_hit_stream[sel], AL_GAIN, volume);
 
     float pitch_min = 0.88;
     float pitch = pitch_min+randn1(int((1.f-pitch_min)*2.f*1000.f))*0.001;

src/soundmng.h

@@ -31,16 +31,17 @@ typedef ALuint ALsource;
 
 class Sound_game_static {
 public:
+    static constexpr int hitStreamCount = 6;
     Sound_game_static() {
         for (int i = 0; i != 4; ++i)
         {
             p_skid_stream[i] = 0;
-            p_engine0_stream[i] = 0;
-            p_engine1_stream[i] = 0;
+            p_engine0_sample[i] = 0;
+            p_engine1_sample[i] = 0;
+            p_engine_stream[i] = 0;
         }
-        for (int i = 0; i != 10; ++i)
+        for (int i = 0; i != hitStreamCount; ++i)
             p_hit_stream[i] = 0;
-        p_test_stream = 0;
         p_skid_sample = 0;
         p_hit_sample[0] = 0;
         p_hit_sample[1] = 0;
@@ -49,10 +50,11 @@ class Sound_game_static {
         for (int i = 0; i != 4; ++i)
         {
             p_skid_stream[i] = 0;
-            p_engine0_stream[i] = 0;
-            p_engine1_stream[i] = 0;
+            p_engine0_sample[i] = 0;
+            p_engine1_sample[i] = 0;
+            p_engine_stream[i] = 0;
         }
-        for (int i = 0; i != 10; ++i)
+        for (int i = 0; i != hitStreamCount; ++i)
             p_hit_stream[i] = 0;
         p_skid_sample = 0;
         p_hit_sample[0] = 0;
@@ -63,11 +65,10 @@ class Sound_game_static {
     void load(unsigned int i, ALbuffer p_engine0_sample, ALbuffer p_engine1_sample);
 
     ALsource p_skid_stream[4];
-    ALsource p_engine0_stream[4];
-    ALsource p_engine1_stream[4];
-    ALsource p_hit_stream[10];
-
-    ALsource p_test_stream;
+    ALsource p_engine_stream[4];
+    ALbuffer p_engine0_sample[4];
+    ALbuffer p_engine1_sample[4];
+    ALsource p_hit_stream[hitStreamCount];
 
     ALbuffer p_skid_sample;
     ALbuffer p_hit_sample[2];
@@ -82,16 +83,19 @@ class Sound_game_static {
 
 class Sound_car {
 public:
-    Sound_car() : p_skid_stream(0), p_engine0_stream(0), p_engine1_stream(0), p_engine0_state(0), p_engine1_state(0), p_skid_state(0), p_time(0),
-        p_T(0), p_running_pitch(0), p_pan(0), p_player(0), p_brake_volume(0), p_engine_on(0), p_global_volume(0) { }
+    Sound_car() : p_skid_stream(0), p_engine_stream(0), p_engine0_sample(0), p_engine1_sample(0), p_engine0_state(0), p_engine1_state(0), p_skid_state(0), p_time(0),
+        p_T(0), p_running_pitch(0), p_pan(0), p_player(0), p_brake_volume(0), p_engine_on(0) { }
     ~Sound_car() {
     }
-    void init(ALsource stream_idle, ALsource stream_running, float running_pitch, ALsource stream_skid, int player, int players_n);
+    void init(ALsource stream_engine, ALbuffer sample_idle, ALbuffer sample_running, float running_pitch, ALsource stream_skid, int player, int players_n);
     void frame(float deltaT, int engine_state/*0 - nultý, 1 - první, 2 - první potichu*/, float engine_pitch, const float velocity[2]);
     void stop();
     ALsource p_skid_stream;
-    ALsource p_engine0_stream;
-    ALsource p_engine1_stream;
+    ALsource p_engine_stream;
+    ALbuffer p_engine0_sample;
+    ALbuffer p_engine1_sample;
+    ALfloat p_engine0_offset = 0;
+    ALfloat p_engine1_offset = 0;
     int p_engine0_state; // 0 - nehraje, 1 - hraje
     int p_engine1_state; // 0 - nehraje, 1 - hraje
     int p_skid_state; // 0 - nehraje, 1 - hraje
@@ -102,12 +106,11 @@ class Sound_car {
     int p_player;
     float p_brake_volume;
     int p_engine_on;
-    const float* p_global_volume;
 };
 
 class Sound_crash {
 public:
-    Sound_crash() { p_sz_samples = 2; p_width = 5; p_global_volume = 0; p_hit_stream = 0; p_fronta_pos[0] = 0; p_fronta_pos[1] = 0; }
+    Sound_crash() { p_sz_samples = 2; p_width = 3; p_hit_stream = 0; p_fronta_pos[0] = 0; p_fronta_pos[1] = 0; }
     ~Sound_crash() {
     }
     void init(ALsource* stream_hit); // load zvuků
@@ -117,7 +120,6 @@ class Sound_crash {
     ALsource* p_hit_stream;
     int p_fronta_pos[10]; // stačí 2
 
-    const float* p_global_volume;
     // n = 3
     // f = 5
     // samply[n]