- [NEW] JA_SetMusicVolume(int volume)

- [NEW] JA_EnableMusic(const bool value)
- [NEW]  JA_SetSoundVolume(int volume)
- [NEW] JA_EnableSound(const bool value)

jail_audio.cpp

@@ -32,18 +32,21 @@ JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 int             JA_freq {48000};
 SDL_AudioFormat JA_format {AUDIO_S16};
 Uint8           JA_channels {2};
-int             JA_volume = 128;
+int             JA_musicVolume = 128;
+int             JA_soundVolume = 64;
+bool            JA_musicEnabled = true;
+bool            JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;
 
 void audioCallback(void * userdata, uint8_t * stream, int len) {
     SDL_memset(stream, 0, len);
     if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
         const int size = SDL_min(len, current_music->samples*2-current_music->pos);
-        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_volume);
+        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_musicVolume);
         current_music->pos += size/2;
         if (size < len) {
             if (current_music->times != 0) {
-                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_volume);
+                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_musicVolume);
                 current_music->pos = (len-size)/2;
                 if (current_music->times > 0) current_music->times--;
             } else {
@@ -56,11 +59,11 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
         if (channels[i].state == JA_CHANNEL_PLAYING) {
             const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
-            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_volume/2);
+            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
             channels[i].pos += size;
             if (size < len) {
                 if (channels[i].times != 0) {
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_volume/2);
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
                     channels[i].pos = len-size;
                     if (channels[i].times > 0) channels[i].times--;
                 } else {
@@ -122,7 +125,10 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
     return music;
 }
 
-void JA_PlayMusic(JA_Music_t *music, const int loop) {
+void JA_PlayMusic(JA_Music_t *music, const int loop)
+{
+    if (!JA_musicEnabled) return;
+
     if (current_music != NULL) {
         current_music->pos = 0;
         current_music->state = JA_MUSIC_STOPPED;
@@ -133,23 +139,34 @@ void JA_PlayMusic(JA_Music_t *music, const int loop) {
     current_music->times = loop;
 }
 
-void JA_PauseMusic() {
+void JA_PauseMusic()
+{
+    if (!JA_musicEnabled) return;
+
     if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PAUSED;
 }
 
-void JA_ResumeMusic() {
+void JA_ResumeMusic()
+{
+    if (!JA_musicEnabled) return;
+
     if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PLAYING;
 }
 
-void JA_StopMusic() {
+void JA_StopMusic()
+{
+    if (!JA_musicEnabled) return;
+
     if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_STOPPED;
 }
 
 JA_Music_state JA_GetMusicState() {
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+
     if (current_music == NULL) return JA_MUSIC_INVALID;
     return current_music->state;
 }
@@ -160,6 +177,23 @@ void JA_DeleteMusic(JA_Music_t *music) {
     delete music;
 }
 
+int JA_SetMusicVolume(int volume)
+{
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    return JA_musicVolume;
+}
+
+void JA_EnableMusic(const bool value)
+{
+    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+
+    JA_musicEnabled = value;
+}
+
+
+
+
+
 JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
     JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
@@ -185,7 +219,10 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
     return sound;
 }
 
-int JA_PlaySound(JA_Sound_t *sound, const int loop) {
+int JA_PlaySound(JA_Sound_t *sound, const int loop)
+{
+    if (!JA_soundEnabled) return;
+
     int channel = 0;
     while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
     if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
@@ -197,7 +234,8 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop) {
     return channel;
 }
 
-void JA_DeleteSound(JA_Sound_t *sound) {
+void JA_DeleteSound(JA_Sound_t *sound)
+{
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
         if (channels[i].sound == sound) JA_StopChannel(i);
     }
@@ -205,7 +243,10 @@ void JA_DeleteSound(JA_Sound_t *sound) {
     delete sound;
 }
 
-void JA_PauseChannel(const int channel) {
+void JA_PauseChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+
     if (channel == -1) {
         for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
             if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
@@ -215,7 +256,10 @@ void JA_PauseChannel(const int channel) {
     }
 }
 
-void JA_ResumeChannel(const int channel) {
+void JA_ResumeChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+
     if (channel == -1) {
         for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
             if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
@@ -225,7 +269,10 @@ void JA_ResumeChannel(const int channel) {
     }
 }
 
-void JA_StopChannel(const int channel) {
+void JA_StopChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+
     if (channel == -1) {
         for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
             channels[i].state = JA_CHANNEL_FREE;
@@ -239,13 +286,34 @@ void JA_StopChannel(const int channel) {
     }
 }
 
-JA_Channel_state JA_GetChannelState(const int channel) {
+JA_Channel_state JA_GetChannelState(const int channel)
+{
+    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+
     if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
     return channels[channel].state;
 }
 
-int JA_SetVolume(int volume) {
+int JA_SetSoundVolume(int volume)
-    JA_volume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+{
-    return JA_volume;
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    return JA_soundVolume;
 }
+
+void JA_EnableSound(const bool value)
+{
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    {
+        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
+    }
+    JA_soundEnabled = value;
+}
+
+int JA_SetVolume(int volume)
+{
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_soundVolume = JA_musicVolume/2;
+    return JA_musicVolume;
+}
+
 #endif

jail_audio.h

@@ -1,8 +1,8 @@
 #pragma once
 #include <SDL2/SDL.h>
 
-enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED };
+enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
-enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED };
+enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
 
 struct JA_Sound_t;
 struct JA_Music_t;
@@ -17,6 +17,8 @@ void JA_ResumeMusic();
 void JA_StopMusic();
 JA_Music_state JA_GetMusicState();
 void JA_DeleteMusic(JA_Music_t *music);
+int JA_SetMusicVolume(int volume);
+void JA_EnableMusic(const bool value);
 
 JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
 JA_Sound_t *JA_LoadSound(const char* filename);
@@ -26,5 +28,7 @@ void JA_ResumeChannel(const int channel);
 void JA_StopChannel(const int channel);
 JA_Channel_state JA_GetChannelState(const int channel);
 void JA_DeleteSound(JA_Sound_t *sound);
+int JA_SetSoundVolume(int volume);
+void JA_EnableSound(const bool value);
 
 int JA_SetVolume(int volume);

jail_audio_sdlmixer.cpp

@@ -10,6 +10,10 @@ struct JA_Music_t {};
 int             JA_freq {48000};
 SDL_AudioFormat JA_format {AUDIO_S16};
 Uint8           JA_channels {2};
+int             JA_musicVolume = 128;
+int             JA_soundVolume = 64;
+bool            JA_musicEnabled = true;
+bool            JA_soundEnabled = true;
 
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
     JA_freq = freq;
@@ -26,23 +30,35 @@ JA_Music_t *JA_LoadMusic(const char* filename) {
     return (JA_Music_t*)Mix_LoadMUS(filename);
 }
 
-void JA_PlayMusic(JA_Music_t *music, const int loop) {
+void JA_PlayMusic(JA_Music_t *music, const int loop)
+{
+    if (!JA_musicEnabled) return;
     Mix_PlayMusic((Mix_Music*)music, loop);
+    Mix_VolumeMusic(JA_musicVolume);
 }
 
-void JA_PauseMusic() {
+void JA_PauseMusic()
+{
+    if (!JA_musicEnabled) return;
     Mix_PauseMusic();
 }
 
-void JA_ResumeMusic() {
+void JA_ResumeMusic()
+{
+    if (!JA_musicEnabled) return;
     Mix_ResumeMusic();
 }
 
-void JA_StopMusic() {
+void JA_StopMusic()
+{
+    if (!JA_musicEnabled) return;
     Mix_HaltMusic();
 }
 
-JA_Music_state JA_GetMusicState() {
+JA_Music_state JA_GetMusicState()
+{
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+
     if (Mix_PausedMusic()) {
         return JA_MUSIC_PAUSED;
     } else if (Mix_PlayingMusic()) {
@@ -52,11 +68,30 @@ JA_Music_state JA_GetMusicState() {
     }
 }
 
-void JA_DeleteMusic(JA_Music_t *music) {
+void JA_DeleteMusic(JA_Music_t *music)
+{
     Mix_FreeMusic((Mix_Music*)music);
 }
 
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+int JA_SetMusicVolume(int volume)
+{
+    JA_musicVolume = volume;
+    Mix_VolumeMusic(JA_musicVolume);
+    return JA_musicVolume;
+}
+
+void JA_EnableMusic(const bool value)
+{
+    if (Mix_PlayingMusic()) Mix_HaltMusic();
+    JA_musicEnabled = value;
+}
+
+
+
+
+
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length)
+{
     return NULL;
 }
 
@@ -66,26 +101,39 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
 }
 
 int JA_PlaySound(JA_Sound_t *sound, const int loop) {
-    return Mix_PlayChannel(-1, (Mix_Chunk*)sound, loop);
+    if (!JA_soundEnabled) return -1;
+    const int channel = Mix_PlayChannel(-1, (Mix_Chunk*)sound, loop);
+    Mix_Volume(-1, JA_soundVolume);
+    return channel;
 }
 
-void JA_DeleteSound(JA_Sound_t *sound) {
+void JA_DeleteSound(JA_Sound_t *sound)
+{
     Mix_FreeChunk((Mix_Chunk*)sound);
 }
 
-void JA_PauseChannel(const int channel) {
+void JA_PauseChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
     Mix_Pause(channel);
 }
 
-void JA_ResumeChannel(const int channel) {
+void JA_ResumeChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
     Mix_Resume(channel);
 }
 
-void JA_StopChannel(const int channel) {
+void JA_StopChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
     Mix_HaltChannel(channel);
 }
 
-JA_Channel_state JA_GetChannelState(const int channel) {
+JA_Channel_state JA_GetChannelState(const int channel)
+{
+    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+
     if (Mix_Paused(channel)) {
         return JA_CHANNEL_PAUSED;
     } else if (Mix_Playing(channel)) {
@@ -95,7 +143,24 @@ JA_Channel_state JA_GetChannelState(const int channel) {
     }
 }
 
-int JA_SetVolume(int volume) {
+int JA_SetSoundVolume(int volume)
-    return Mix_Volume(-1, volume);
+{
+    JA_musicVolume = volume;
+    Mix_Volume(-1, JA_musicVolume);
+    return JA_musicVolume;
 }
+
+void JA_EnableSound(const bool value)
+{
+    Mix_HaltChannel(-1);
+    JA_soundEnabled = value;
+}
+
+
+int JA_SetVolume(int volume)
+{
+    JA_SetSoundVolume(volume);
+    return JA_SetMusicVolume(volume);
+}
+
 #endif