- [FIX] Si no feia falta conversió de format, la música no apuntava correctament la duració al carregar

.gitignore

@@ -3,4 +3,3 @@
 .vscode
 *.out
 main
-jail_audio

jail_audio.cpp

@@ -1,151 +1,150 @@
 #ifndef JA_USESDLMIXER
 #include "jail_audio.h"
 #include "stb_vorbis.c"
-#include <SDL3/SDL.h>
+#include <SDL2/SDL.h>
 #include <stdio.h>
 
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
-#define JA_MAX_GROUPS 5
 
-struct JA_Sound_t
+struct JA_Sound_t {
-{
+    Uint32  length {0};
-    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
+    Uint8*  buffer {NULL};
-    Uint32              length      { 0 };
-    Uint8               *buffer     { NULL };
 };
 
-struct JA_Channel_t
+struct JA_Channel_t {
-{
+    JA_Sound_t          *sound;
-    JA_Sound_t          *sound      { nullptr };
+    int                 pos {0};
-    int                 pos         { 0 };
+    int                 times {0};
-    int                 times       { 0 };
+    JA_Channel_state    state { JA_CHANNEL_FREE };
-    int                 group       { 0 };
-    SDL_AudioStream     *stream     { nullptr };
-    JA_Channel_state    state       { JA_CHANNEL_FREE };
 };
 
-struct JA_Music_t
+struct JA_Music_t {
-{
+    int             samples {0};
-    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
+    Uint32          length {0};
-    Uint32              length      { 0 };
+    int             pos {0};
-    Uint8               *buffer     { nullptr };
+    int             times {0};
-    char                *filename   { nullptr };
+    short*          output {NULL};
-
+    JA_Music_state  state {JA_MUSIC_INVALID};
-    int                 pos         { 0 };
-    int                 times       { 0 };
-    SDL_AudioStream     *stream     { nullptr };
-    JA_Music_state      state       { JA_MUSIC_INVALID };
 };
 
-JA_Music_t          *current_music  { nullptr };
+JA_Music_t      *current_music{NULL};
-JA_Channel_t        channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
-SDL_AudioSpec       JA_audioSpec    { SDL_AUDIO_S16, 2, 48000 };
+int             JA_freq {48000};
-float               JA_musicVolume  { 1.0f };
+SDL_AudioFormat JA_format {AUDIO_S16};
-float               JA_soundVolume[JA_MAX_GROUPS];
+Uint8           JA_channels {2};
-bool                JA_musicEnabled { true };
+int             JA_musicVolume = 128;
-bool                JA_soundEnabled { true };
+int             JA_soundVolume = 64;
-SDL_AudioDeviceID   sdlAudioDevice  { 0 };
+bool            JA_musicEnabled = true;
-//SDL_TimerID         JA_timerID      { 0 };
+bool            JA_soundEnabled = true;
+SDL_AudioDeviceID sdlAudioDevice = 0;
 
 bool fading = false;
 int fade_start_time;
 int fade_duration;
 int fade_initial_volume;
 
-
+void audioCallback(void * userdata, uint8_t * stream, int len) {
-void JA_Update()
+    SDL_memset(stream, 0, len);
-{
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
-    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING)
+        int volume = JA_musicVolume;
-    {
         if (fading) {
             int time = SDL_GetTicks();
             if (time > (fade_start_time+fade_duration)) {
                 fading = false;
-                JA_StopMusic();
+                current_music->pos = 0;
-                return;
+                current_music->state = JA_MUSIC_STOPPED;
+                volume = 0;
             } else {
                 const int time_passed = time - fade_start_time;
                 const float percent = (float)time_passed / (float)fade_duration;
-                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume*(1.0 - percent));
+                volume = JA_musicVolume * (1.0 - percent);
             }
         }
-
+        const int size = SDL_min(len, current_music->length - current_music->pos);
-        if (current_music->times != 0)
+        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output)+current_music->pos, AUDIO_S16, size, volume);
-        {
+        current_music->pos += size;
-            if (SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length/2)) {
+        if (size < len) {
-                SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
+            if (current_music->times != 0) {
+                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, volume);
+                current_music->pos = len-size;
+                if (current_music->times > 0) current_music->times--;
+            } else {
+                current_music->pos = 0;
+                current_music->state = JA_MUSIC_STOPPED;
             }
-            if (current_music->times>0) current_music->times--;
-        }
-        else
-        {
-            if (SDL_GetAudioStreamAvailable(current_music->stream) == 0) JA_StopMusic();
         }
     }
-
+    // Mixar els channels mi amol
-    if (JA_soundEnabled)
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-    {
+        if (channels[i].state == JA_CHANNEL_PLAYING) {
-        for (int i=0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
+            const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
-            if (channels[i].state == JA_CHANNEL_PLAYING)
+            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
-            {
+            channels[i].pos += size;
-                if (channels[i].times != 0)
+            if (size < len) {
-                {
+                if (channels[i].times != 0) {
-                    if (SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length/2)) {
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
-                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
+                    channels[i].pos = len-size;
-                        if (channels[i].times>0) channels[i].times--;
+                    if (channels[i].times > 0) channels[i].times--;
-                    }
+                } else {
-                }
+                    JA_StopChannel(i);
-                else
-                {
-                    if (SDL_GetAudioStreamAvailable(channels[i].stream) == 0) JA_StopChannel(i);
                 }
             }
-
+        }
     }
-
-    return;
 }
 
-void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels)
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
 {
     #ifdef DEBUG
-    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
     #endif
     
     SDL_Log("Iniciant JailAudio...");
-    JA_audioSpec = {format, num_channels, freq };
+    JA_freq = freq;
-    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
+    JA_format = format;
-    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
+    JA_channels = channels;
-    SDL_Log( (sdlAudioDevice==0) ? "Failed to initialize SDL audio!\n" : "OK!\n");
+    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    for (int i=0; i<JA_MAX_SIMULTANEOUS_CHANNELS; ++i) channels[i].state = JA_CHANNEL_FREE;
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
-    for (int i=0; i<JA_MAX_GROUPS; ++i) JA_soundVolume[i] = 0.5f;
+    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
-    //SDL_PauseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice==0)
-    //JA_timerID = SDL_AddTimer(30, JA_UpdateCallback, nullptr);
+    {
+        SDL_Log("FAILED!\n");
+        SDL_Log("Failed to initialize SDL audio!\n");
+    } else {
+        SDL_Log("OK!\n");
+    }
+    SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }
 
-void JA_Quit()
+void JA_Quit() {
-{
+    SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    //if (JA_timerID) SDL_RemoveTimer(JA_timerID);
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
-
-    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = 0;
 }
 
 JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
 {
+    int chan, samplerate;
     JA_Music_t *music = new JA_Music_t();
 
-    int chan, samplerate;
+    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
-    short *output;
+    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
+//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
 
-    music->spec.channels = chan;
+    SDL_AudioCVT cvt;
-    music->spec.freq = samplerate;
+    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    music->spec.format = SDL_AUDIO_S16;
+    SDL_Log("Music length: %f\n", float(music->samples)/float(JA_freq));
-    music->buffer = (Uint8*)SDL_malloc(music->length);
+    if (cvt.needed) {
-    SDL_memcpy(music->buffer, output, music->length);
+        cvt.len = music->samples * chan * 2;
-    free(output);
+        music->length = cvt.len;
+        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+        SDL_memcpy(cvt.buf, music->output, cvt.len);
+        SDL_ConvertAudio(&cvt);
+        free(music->output);
+        music->output = (short*)cvt.buf;
+    }
+    music->length = music->samples * chan * 2;
     music->pos = 0;
     music->state = JA_MUSIC_STOPPED;
 
@@ -164,8 +163,6 @@ JA_Music_t *JA_LoadMusic(const char* filename)
     fclose(f);
 
     JA_Music_t *music = JA_LoadMusic(buffer, fsize);
-    music->filename = (char*)malloc(strlen(filename)+1);
-    strcpy(music->filename, filename);
 
     free(buffer);
 
@@ -176,58 +173,39 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
     if (!JA_musicEnabled) return;
 
-    JA_StopMusic();
+    if (current_music != NULL) {
-
+        current_music->pos = 0;
+        current_music->state = JA_MUSIC_STOPPED;
+    }
     current_music = music;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_PLAYING;
     current_music->times = loop;
-
-    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
-    if (!SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length)) printf("[ERROR] SDL_PutAudioStreamData failed!\n");
-    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
-    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
-    //SDL_ResumeAudioStreamDevice(current_music->stream);
-}
-
-char *JA_GetMusicFilename(JA_Music_t *music)
-{
-    if (!music) music = current_music;
-    return music->filename;
 }
 
 void JA_PauseMusic()
 {
     if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PAUSED;
-    //SDL_PauseAudioStreamDevice(current_music->stream);
-    SDL_UnbindAudioStream(current_music->stream);
 }
 
 void JA_ResumeMusic()
 {
     if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PLAYING;
-    //SDL_ResumeAudioStreamDevice(current_music->stream);
-    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
 }
 
 void JA_StopMusic()
 {
     if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_STOPPED;
-    //SDL_PauseAudioStreamDevice(current_music->stream);
-    SDL_DestroyAudioStream(current_music->stream);
-    current_music->stream = nullptr;
-    free(current_music->filename);
-    current_music->filename = nullptr;
 }
 
 void JA_FadeOutMusic(const int milliseconds)
@@ -241,44 +219,40 @@ void JA_FadeOutMusic(const int milliseconds)
     fade_initial_volume = JA_musicVolume;
 }
 
-JA_Music_state JA_GetMusicState()
+JA_Music_state JA_GetMusicState() {
-{
     if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
-    if (!current_music) return JA_MUSIC_INVALID;
 
+    if (current_music == NULL) return JA_MUSIC_INVALID;
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music_t *music)
+void JA_DeleteMusic(JA_Music_t *music) {
-{
+    if (current_music == music) current_music = NULL;
-    if (current_music == music) current_music = nullptr;
+    free(music->output);
-    SDL_free(music->buffer);
-    if (music->stream) SDL_DestroyAudioStream(music->stream);
     delete music;
 }
 
-float JA_SetMusicVolume(float volume)
+int JA_SetMusicVolume(int volume)
 {
-    JA_musicVolume = SDL_clamp( volume, 0.0f, 1.0f );
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-    if (current_music) SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
     return JA_musicVolume;
 }
 
 void JA_SetMusicPosition(float value)
 {
     if (!current_music) return;
-    current_music->pos = value * current_music->spec.freq;
+    current_music->pos = value * JA_freq;
 }
 
 float JA_GetMusicPosition()
 {
     if (!current_music) return 0;
-    return float(current_music->pos)/float(current_music->spec.freq);
+    return float(current_music->pos)/float(JA_freq);
 }
 
 void JA_EnableMusic(const bool value)
 {
-    if ( !value && current_music && (current_music->state==JA_MUSIC_PLAYING) ) JA_StopMusic();
+    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
 
     JA_musicEnabled = value;
 }
@@ -287,67 +261,74 @@ void JA_EnableMusic(const bool value)
 
 
 
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length)
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
-{
     JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
     sound->length = length;
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size)
+JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size) {
-{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size),1, &sound->spec, &sound->buffer, &sound->length);
+    SDL_AudioSpec wavSpec;
+    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size),1, &wavSpec, &sound->buffer, &sound->length);
+    
+    SDL_AudioCVT cvt;
+    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
+    cvt.len = sound->length;
+    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
+    SDL_ConvertAudio(&cvt);
+    SDL_FreeWAV(sound->buffer);
+    sound->buffer = cvt.buf;
+    sound->length = cvt.len_cvt;
 
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(const char* filename)
+JA_Sound_t *JA_LoadSound(const char* filename) {
-{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length);
+    SDL_AudioSpec wavSpec;
+    SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
+
+    SDL_AudioCVT cvt;
+    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
+    cvt.len = sound->length;
+    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
+    SDL_ConvertAudio(&cvt);
+    SDL_FreeWAV(sound->buffer);
+    sound->buffer = cvt.buf;
+    sound->length = cvt.len_cvt;
 
     return sound;
 }
 
-int JA_PlaySound(JA_Sound_t *sound, const int loop, const int group)
+int JA_PlaySound(JA_Sound_t *sound, const int loop)
 {
     if (!JA_soundEnabled) return -1;
 
     int channel = 0;
     while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
     if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
-    JA_StopChannel(channel);
 
     channels[channel].sound = sound;
     channels[channel].times = loop;
     channels[channel].pos = 0;
     channels[channel].state = JA_CHANNEL_PLAYING;
-    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
-    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
-    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume[group]);
-    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
-
     return channel;
 }
 
-int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop, const int group)
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop)
 {
     if (!JA_soundEnabled) return -1;
 
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
+    if (channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
-    JA_StopChannel(channel);
 
     channels[channel].sound = sound;
     channels[channel].times = loop;
     channels[channel].pos = 0;
     channels[channel].state = JA_CHANNEL_PLAYING;
-    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
-    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
-    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume[group]);
-    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
-
     return channel;
 }
 
@@ -364,24 +345,12 @@ void JA_PauseChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
-            if (channels[i].state == JA_CHANNEL_PLAYING)
-            {
-                channels[i].state = JA_CHANNEL_PAUSED;
-                //SDL_PauseAudioStreamDevice(channels[i].stream);
-                SDL_UnbindAudioStream(channels[i].stream);
-            }
-    }
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
-    {
-        if (channels[channel].state == JA_CHANNEL_PLAYING)
-        {
-            channels[channel].state = JA_CHANNEL_PAUSED;
-            //SDL_PauseAudioStreamDevice(channels[channel].stream);
-            SDL_UnbindAudioStream(channels[channel].stream);
         }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
     }
 }
 
@@ -389,24 +358,12 @@ void JA_ResumeChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
-            if (channels[i].state == JA_CHANNEL_PAUSED)
-            {
-                channels[i].state = JA_CHANNEL_PLAYING;
-                //SDL_ResumeAudioStreamDevice(channels[i].stream);
-                SDL_BindAudioStream(sdlAudioDevice, channels[i].stream);
-            }
-    }
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
-    {
-        if (channels[channel].state == JA_CHANNEL_PAUSED)
-        {
-            channels[channel].state = JA_CHANNEL_PLAYING;
-            //SDL_ResumeAudioStreamDevice(channels[channel].stream);
-            SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
         }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
     }
 }
 
@@ -414,20 +371,13 @@ void JA_StopChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1)
+    if (channel == -1) {
-    {
         for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state != JA_CHANNEL_FREE) SDL_DestroyAudioStream(channels[i].stream);
-            channels[i].stream = nullptr;
             channels[i].state = JA_CHANNEL_FREE;
             channels[i].pos = 0;
             channels[i].sound = NULL;
         }
-    }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
-    {
-        if (channels[channel].state != JA_CHANNEL_FREE) SDL_DestroyAudioStream(channels[channel].stream);
-        channels[channel].stream = nullptr;
         channels[channel].state = JA_CHANNEL_FREE;
         channels[channel].pos = 0;
         channels[channel].sound = NULL;
@@ -439,23 +389,13 @@ 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;
 }
 
-float JA_SetSoundVolume(float volume, const int group)
+int JA_SetSoundVolume(int volume)
 {
-    const float v = SDL_clamp( volume, 0.0f, 1.0f );
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-    for (int i = 0; i < JA_MAX_GROUPS; ++i) {
+    return JA_soundVolume;
-        if (group==-1 || group==i) JA_soundVolume[i]=v;
-    }
-
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-        if ( ((channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED)) &&
-             ((group==-1) || (channels[i].group==group)) )
-            SDL_SetAudioStreamGain(channels[i].stream, JA_soundVolume[i]);
-
-    return v;
 }
 
 void JA_EnableSound(const bool value)
@@ -467,10 +407,10 @@ void JA_EnableSound(const bool value)
     JA_soundEnabled = value;
 }
 
-float JA_SetVolume(float volume)
+int JA_SetVolume(int volume)
 {
-    JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-
+    JA_soundVolume = JA_musicVolume/2;
     return JA_musicVolume;
 }
 

jail_audio.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <SDL3/SDL.h>
+#include <SDL2/SDL.h>
 
 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, JA_MUSIC_DISABLED };
@@ -7,22 +7,19 @@ enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MU
 struct JA_Sound_t;
 struct JA_Music_t;
 
-void JA_Update();
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
-
-void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels);
 void JA_Quit();
 
 JA_Music_t *JA_LoadMusic(const char* filename);
 JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length);
 void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
-char *JA_GetMusicFilename(JA_Music_t *music = nullptr);
 void JA_PauseMusic();
 void JA_ResumeMusic();
 void JA_StopMusic();
 void JA_FadeOutMusic(const int milliseconds);
 JA_Music_state JA_GetMusicState();
 void JA_DeleteMusic(JA_Music_t *music);
-float JA_SetMusicVolume(float volume);
+int JA_SetMusicVolume(int volume);
 void JA_SetMusicPosition(float value);
 float JA_GetMusicPosition();
 void JA_EnableMusic(const bool value);
@@ -30,14 +27,14 @@ void JA_EnableMusic(const bool value);
 JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
 JA_Sound_t *JA_LoadSound(Uint8* buffer, Uint32 length);
 JA_Sound_t *JA_LoadSound(const char* filename);
-int JA_PlaySound(JA_Sound_t *sound, const int loop = 0, const int group=0);
+int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
-int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop = 0, const int group=0);
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop = 0);
 void JA_PauseChannel(const int channel);
 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);
-float JA_SetSoundVolume(float volume, const int group=0);
+int JA_SetSoundVolume(int volume);
 void JA_EnableSound(const bool value);
 
-float JA_SetVolume(float volume);
+int JA_SetVolume(int volume);

jail_audio_sdlmixer.cpp

@@ -0,0 +1,166 @@
+#ifdef JA_USESDLMIXER
+#include "jail_audio.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_mixer.h>
+#include <stdio.h>
+
+struct JA_Sound_t {}; // Dummy structs
+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;
+    JA_format = format;
+    JA_channels = channels;
+    Mix_OpenAudio(JA_freq, JA_format, JA_channels, 1024);
+}
+
+void JA_Quit() {
+    Mix_CloseAudio();
+}
+
+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)
+{
+    if (!JA_musicEnabled) return;
+    Mix_PlayMusic((Mix_Music*)music, loop);
+    Mix_VolumeMusic(JA_musicVolume);
+}
+
+void JA_PauseMusic()
+{
+    if (!JA_musicEnabled) return;
+    Mix_PauseMusic();
+}
+
+void JA_ResumeMusic()
+{
+    if (!JA_musicEnabled) return;
+    Mix_ResumeMusic();
+}
+
+void JA_StopMusic()
+{
+    if (!JA_musicEnabled) return;
+    Mix_HaltMusic();
+}
+
+JA_Music_state JA_GetMusicState()
+{
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+
+    if (Mix_PausedMusic()) {
+        return JA_MUSIC_PAUSED;
+    } else if (Mix_PlayingMusic()) {
+        return JA_MUSIC_PLAYING;
+    } else {
+        return JA_MUSIC_STOPPED;
+    }
+}
+
+void JA_DeleteMusic(JA_Music_t *music)
+{
+    Mix_FreeMusic((Mix_Music*)music);
+}
+
+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;
+}
+
+JA_Sound_t *JA_LoadSound(const char* filename) {
+    JA_Sound_t *sound = (JA_Sound_t*)Mix_LoadWAV(filename);
+    return sound;
+}
+
+int JA_PlaySound(JA_Sound_t *sound, const int 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)
+{
+    Mix_FreeChunk((Mix_Chunk*)sound);
+}
+
+void JA_PauseChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+    Mix_Pause(channel);
+}
+
+void JA_ResumeChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+    Mix_Resume(channel);
+}
+
+void JA_StopChannel(const int channel)
+{
+    if (!JA_soundEnabled) return;
+    Mix_HaltChannel(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)) {
+        return JA_CHANNEL_PLAYING;
+    } else {
+        return JA_CHANNEL_FREE;
+    }
+}
+
+int JA_SetSoundVolume(int 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

main.cpp

@@ -1,6 +1,6 @@
 #include "jail_audio.h"
 #include <stdlib.h>
-#include <SDL3/SDL.h>
+#include <SDL2/SDL.h>
 #include <stdio.h>
 
 SDL_Event event;
@@ -8,22 +8,22 @@ SDL_Window *sdlWindow;
 
 
 int main(int argc, char **argv) {
-    SDL_Init(SDL_INIT_AUDIO|SDL_INIT_EVENTS);
+    SDL_Init(SDL_INIT_EVERYTHING);
-    sdlWindow = SDL_CreateWindow("JailAudio", 320, 240, 0);
+    sdlWindow = SDL_CreateWindow("JailAudio", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 320, 240, SDL_WINDOW_SHOWN);
-    JA_Init(48000, SDL_AUDIO_S16, 2);
+    JA_Init(48000, AUDIO_S16, 2);
 
     JA_Music_t *music = JA_LoadMusic("intro2.ogg");
     JA_Sound_t *peiv = JA_LoadSound("menu_select.wav");
     int channel = -1;
 
     JA_PlayMusic(music, -1);
-    float volume = 1.0f;
+    int volume = 128;
     bool should_exit = false;
     while(!should_exit) {
         while(SDL_PollEvent(&event)) {
-            if (event.type == SDL_EVENT_QUIT) { should_exit = true; break; }
+            if (event.type == SDL_QUIT) { should_exit = true; break; }
-            if (event.type == SDL_EVENT_KEY_DOWN) {
+            if (event.type == SDL_KEYDOWN) {
-                switch (event.key.scancode) {
+                switch (event.key.keysym.scancode) {
                     case SDL_SCANCODE_1:                // Si pulsem la tecla '1' pausem o despausem la música
                         if (JA_GetMusicState() == JA_MUSIC_PLAYING) { JA_PauseMusic(); } else { JA_ResumeMusic(); }
                         break;
@@ -31,10 +31,10 @@ int main(int argc, char **argv) {
                         JA_PlaySound(peiv);
                         break;
                     case SDL_SCANCODE_3:                // Si pulsem la tecla '3' sona el wav 3 vegades
-                        JA_PlaySound(peiv, 2, 1);
+                        JA_PlaySound(peiv, 2);
                         break;
                     case SDL_SCANCODE_4:                // Si pulsem la tecla '4' sona el wav infinitament
-                        channel = JA_PlaySound(peiv, -1, 2);
+                        channel = JA_PlaySound(peiv, -1);
                         break;
                     case SDL_SCANCODE_5:                // Si pulsem la tecla '5' pausem o despausem el wav que sonaba infinitament
                         if (JA_GetChannelState(channel) == JA_CHANNEL_PLAYING) { JA_PauseChannel(channel); } else { JA_ResumeChannel(channel); }
@@ -43,19 +43,16 @@ int main(int argc, char **argv) {
                         JA_StopChannel(channel);
                         break;
                     case SDL_SCANCODE_7:
-                        JA_PlayMusic(music, 0);         // Si pulsem la tecla '7' fa sonar la música UNA negada nomes.
+                        JA_PlayMusic(music, 0);
                         break;
-                    case SDL_SCANCODE_0:                // Si pulsem la tecla '0' stopem la música amb un fade
+                    case SDL_SCANCODE_0:                // Si pulsem la tecla '1' pausem o despausem la música
                         JA_FadeOutMusic(1000);
                         break;
                     case SDL_SCANCODE_UP:
-                        volume = JA_SetVolume(volume+0.1f);
+                        volume = JA_SetVolume(volume+16);
                         break;
                     case SDL_SCANCODE_DOWN:
-                        volume = JA_SetVolume(volume-0.1f);
+                        volume = JA_SetVolume(volume-16);
-                        break;
-                    case SDL_SCANCODE_ESCAPE:
-                        should_exit = true;
                         break;
                     default:
                         break;
@@ -63,11 +60,9 @@ int main(int argc, char **argv) {
                 
             }
         }
-        JA_Update();
     }
     JA_DeleteSound(peiv);
     JA_DeleteMusic(music);
-    JA_Quit();
     SDL_DestroyWindow(sdlWindow);
     SDL_Quit();
     return 0;

valgrind-sup.txt

@@ -1,12 +0,0 @@
-{
-    ignore_unversioned_libs
-    Memcheck:Leak
-    ...
-    obj:*/lib*/lib*.so
-}
-{
-    ignore_versioned_libs
-    Memcheck:Leak
-    ...
-    obj:*/lib*/lib*.so.*
-}