[NEW] Audio support:

- playmusic(filename)
- pausemusic()
- resumemusic()
- stopmusic()

jail_audio.cpp

@@ -0,0 +1,248 @@
+#include "jail_audio.h"
+#include "stb_vorbis.c"
+#include <SDL2/SDL.h>
+#include <stdio.h>
+
+#define JA_MAX_SIMULTANEOUS_CHANNELS 5
+
+struct JA_Sound_t {
+    Uint32  length {0};
+    Uint8*  buffer {NULL};
+};
+
+struct JA_Channel_t {
+    JA_Sound            sound;
+    int                 pos {0};
+    int                 times {0};
+    JA_Channel_state    state { JA_CHANNEL_FREE };
+};
+
+struct JA_Music_t {
+    int             samples {0};
+    int             pos {0};
+    int             times {0};
+    short*          output {NULL};
+    JA_Music_state  state {JA_MUSIC_INVALID};
+};
+
+JA_Music        current_music{NULL};
+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;
+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);
+        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);
+                current_music->pos = (len-size)/2;
+                if (current_music->times > 0) current_music->times--;
+            } else {
+                current_music->pos = 0;
+                current_music->state = JA_MUSIC_STOPPED;
+            }
+        }
+    }
+    // Mixar els channels mi amol
+    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);
+            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);
+                    channels[i].pos = len-size;
+                    if (channels[i].times > 0) channels[i].times--;
+                } else {
+                    JA_StopChannel(i);
+                }
+            }
+        }
+    }
+}
+
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
+    JA_freq = freq;
+    JA_format = format;
+    JA_channels = channels;
+    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
+    SDL_PauseAudioDevice(sdlAudioDevice, 0);
+}
+
+void JA_Quit() {
+    SDL_PauseAudioDevice(sdlAudioDevice, 1);
+    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = 0;
+}
+
+JA_Music JA_LoadMusic(const char* filename) {
+    int chan, samplerate;
+    JA_Music music = new JA_Music_t();
+
+    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    FILE *f = fopen(filename, "rb");
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
+    fread(buffer, fsize, 1, f);
+    fclose(f);
+
+    music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
+    free(buffer);
+    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
+//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+
+    SDL_AudioCVT cvt;
+    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
+    if (cvt.needed) {
+        cvt.len = music->samples * chan * 2;
+        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->pos = 0;
+    music->state = JA_MUSIC_STOPPED;
+
+    return music;
+}
+
+void JA_PlayMusic(JA_Music music, const int loop) {
+    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;
+}
+
+void JA_PauseMusic() {
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    current_music->state = JA_MUSIC_PAUSED;
+}
+
+void JA_ResumeMusic() {
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    current_music->state = JA_MUSIC_PLAYING;
+}
+
+void JA_StopMusic() {
+    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 (current_music == NULL) return JA_MUSIC_INVALID;
+    return current_music->state;
+}
+
+void JA_DeleteMusic(JA_Music music) {
+    if (current_music == music) current_music = NULL;
+    free(music->output);
+    delete music;
+}
+
+JA_Sound JA_NewSound(Uint8* buffer, Uint32 length) {
+    JA_Sound sound = new JA_Sound_t();
+    sound->buffer = buffer;
+    sound->length = length;
+    return sound;
+}
+
+JA_Sound JA_LoadSound(const char* filename) {
+    JA_Sound sound = new JA_Sound_t();
+    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 sound, const int loop) {
+    int channel = 0;
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
+
+    channels[channel].sound = sound;
+    channels[channel].times = loop;
+    channels[channel].pos = 0;
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    return channel;
+}
+
+void JA_DeleteSound(JA_Sound sound) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if (channels[i].sound == sound) JA_StopChannel(i);
+    }
+    SDL_free(sound->buffer);
+    delete sound;
+}
+
+void JA_PauseChannel(const int channel) {
+    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;
+        }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
+    }
+}
+
+void JA_ResumeChannel(const int channel) {
+    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;
+        }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
+    }
+}
+
+void JA_StopChannel(const int channel) {
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+            channels[i].state = JA_CHANNEL_FREE;
+            channels[i].pos = 0;
+            channels[i].sound = NULL;
+        }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        channels[channel].state = JA_CHANNEL_FREE;
+        channels[channel].pos = 0;
+        channels[channel].sound = NULL;
+    }
+}
+
+JA_Channel_state JA_GetChannelState(const int channel) {
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+    return channels[channel].state;
+}
+
+int JA_SetVolume(int volume) {
+    JA_volume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    return JA_volume;
+}

jail_audio.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <SDL2/SDL.h>
+
+enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED };
+enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED };
+
+typedef struct JA_Sound_t *JA_Sound;
+typedef struct JA_Music_t *JA_Music;
+
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
+void JA_Quit();
+
+JA_Music JA_LoadMusic(const char* filename);
+void JA_PlayMusic(JA_Music music, const int loop = -1);
+void JA_PauseMusic();
+void JA_ResumeMusic();
+void JA_StopMusic();
+JA_Music_state JA_GetMusicState();
+void JA_DeleteMusic(JA_Music music);
+
+JA_Sound JA_NewSound(Uint8* buffer, Uint32 length);
+JA_Sound JA_LoadSound(const char* filename);
+int JA_PlaySound(JA_Sound sound, 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 sound);
+
+int JA_SetVolume(int volume);

lua.cpp

@@ -638,6 +638,27 @@ extern "C" {
         return 1;
     }
 
+    static int cpp_playmusic(lua_State *L) {
+        const char* str = luaL_checkstring(L, 1);
+        playmusic(str);
+        return 0;
+    }
+
+    static int cpp_pausemusic(lua_State *L) {
+        pausemusic();
+        return 0;
+    }
+
+    static int cpp_resumemusic(lua_State *L) {
+        resumemusic();
+        return 0;
+    }
+
+    static int cpp_stopmusic(lua_State *L) {
+        stopmusic();
+        return 0;
+    }
+
 }
 
 lua_State *L;
@@ -732,6 +753,11 @@ void push_lua_funcs() {
     lua_pushcfunction(L,cpp_freadw);    lua_setglobal(L, "freadw");
     lua_pushcfunction(L,cpp_freadb);    lua_setglobal(L, "freadb");
 
+    lua_pushcfunction(L,cpp_playmusic);    lua_setglobal(L, "playmusic");
+    lua_pushcfunction(L,cpp_pausemusic);    lua_setglobal(L, "pausemusic");
+    lua_pushcfunction(L,cpp_resumemusic);    lua_setglobal(L, "resumemusic");
+    lua_pushcfunction(L,cpp_stopmusic);    lua_setglobal(L, "stopmusic");
+
     lua_pushinteger(L, 0);              lua_setglobal(L, "KEY_UNKNOWN");
     lua_pushinteger(L, 4);              lua_setglobal(L, "KEY_A");
     lua_pushinteger(L, 5);              lua_setglobal(L, "KEY_B");

mini.cpp

@@ -3,6 +3,7 @@
 #include <string.h>
 #include "lua.h"
 #include "gif.c"
+#include "jail_audio.h"
 
 #pragma pack(1)
 
@@ -52,6 +53,7 @@ SDL_Renderer *mini_ren;
 SDL_Texture *mini_bak;
 Uint32 *pixels;
 int pitch;
+JA_Music music = NULL;
 
 uint32_t palette[256] = { 0x001a1c2c, 0x005d275d, 0x00b13e53, 0x00ef7d57, 0x00ffcd75, 0x00a7f070, 0x0038b764, 0x00257179,
                          0x0029366f, 0x003b5dc9, 0x0041a6f6, 0x0073eff7, 0x00f4f4f4, 0x0094b0c2, 0x00566c86, 0x00333c57 };
@@ -143,6 +145,17 @@ void reinit() {
     file = NULL;
 }
 
+void initaudio() {
+    if (music!=NULL) JA_DeleteMusic(music);
+    music = NULL;
+    JA_Init(22050, AUDIO_S16, 2);
+}
+void quitaudio() {
+    if (music!=NULL) JA_DeleteMusic(music);
+    music = NULL;
+    JA_Quit();
+}
+
 uint8_t newsurf(int w, int h) {
     int i = 0;
     while (i<10 && surfaces[i].p != NULL) ++i;
@@ -233,6 +246,7 @@ int main(int argc,char*argv[]){
     SDL_Event mini_eve;
 
     reinit();
+    initaudio();
     debug("MINI SYSTEM BOOTING...");
     lua_init(lua_files);
     lua_call_init();
@@ -246,14 +260,17 @@ int main(int argc,char*argv[]){
                 if (mini_eve.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
                     if (lua_is_playing()) {
                         lua_quit();
+                        quitaudio();
                         reinit();
                     } else {
+                        initaudio();
                         lua_init(lua_files);
                         lua_call_init();
                     }
                 } else if (mini_eve.key.keysym.scancode == SDL_SCANCODE_F5) {
                     lua_quit();
                     reinit();
+                    initaudio();
                     lua_init(lua_files);
                     lua_call_init();
                 } else {
@@ -957,3 +974,21 @@ bool freadb() {
     fscanf(file, "%s", &fstr);
     return strcmp(fstr, "true")==0?true:false;
 }
+
+void playmusic(const char *filename) {
+    if (music != NULL) JA_DeleteMusic(music);
+    music = JA_LoadMusic(filename);
+    JA_PlayMusic(music);
+}
+
+void pausemusic() {
+    JA_PauseMusic();
+}
+
+void resumemusic() {
+    JA_ResumeMusic();
+}
+
+void stopmusic() {
+    JA_StopMusic();
+}

mini.h

@@ -247,3 +247,8 @@ float freadd();
 const char *freads();
 const char *freadw();
 bool freadb();
+
+void playmusic(const char *filename);
+void pausemusic();
+void resumemusic();
+void stopmusic();