GitHub Vita Lite - Wolff's Store
Code / README | Releases | Issues
WolffsRoom/TheHouse2Vita / source

audio.c

9876 bytes ยท Original / download

#include "audio.h"
#include "utils/logger.h"

#include <AL/al.h>
#include <AL/alc.h>
#include <vorbis/vorbisfile.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define EFFECT_SLOTS 16

typedef struct {
    ALuint source;
    ALuint buffer;
    unsigned int id;
} effect_slot;

static ALCdevice *device;
static ALCcontext *context;
static ALuint music_source;
static ALuint music_buffer;
static effect_slot effects[EFFECT_SLOTS];
static unsigned int next_effect_id = 1;
static float music_volume = 1.0f;
static float effects_volume = 1.0f;
static bool initialized;

static void source_float(ALuint source, ALenum parameter, float value) {
    ALfloat values[1] = { value };
    alSourcefv(source, parameter, values);
}

static void ogg_path(const char *input, char *output, size_t size) {
    const char *relative = input ? input : "";
    while (*relative == '/') ++relative;
    if (!strncmp(relative, "assets/", 7)) relative += 7;
    snprintf(output, size, DATA_PATH "assets/%s", relative);
    char *extension = strrchr(output, '.');
    if (extension) strcpy(extension, ".ogg");
    else strncat(output, ".ogg", size - strlen(output) - 1);
}

static bool load_ogg(const char *requested, ALuint *buffer) {
    char path[512];
    ogg_path(requested, path, sizeof(path));
    OggVorbis_File file;
    if (ov_fopen(path, &file) < 0) {
        l_error("AUDIO OGG open failed requested=%s path=%s", requested, path);
        return false;
    }

    vorbis_info *info = ov_info(&file, -1);
    ogg_int64_t frames = ov_pcm_total(&file, -1);
    if (!info || frames <= 0 || (info->channels != 1 && info->channels != 2)) {
        l_error("AUDIO OGG invalid path=%s", path);
        ov_clear(&file);
        return false;
    }
    long sample_rate = info->rate;
    int channels = info->channels;

    size_t capacity = (size_t)frames * (size_t)info->channels * sizeof(short);
    char *pcm = malloc(capacity);
    if (!pcm) {
        l_error("AUDIO OGG allocation failed bytes=%u path=%s", (unsigned)capacity, path);
        ov_clear(&file);
        return false;
    }

    size_t used = 0;
    int section = 0;
    while (used < capacity) {
        long read = ov_read(&file, pcm + used, (int)(capacity - used),
                            0, 2, 1, &section);
        if (read == 0) break;
        if (read < 0) {
            l_error("AUDIO OGG decode failed code=%ld path=%s", read, path);
            free(pcm);
            ov_clear(&file);
            return false;
        }
        used += (size_t)read;
    }

    alGenBuffers(1, buffer);
    alBufferData(*buffer, channels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16,
                 pcm, (ALsizei)used, sample_rate);
    ALenum error = alGetError();
    free(pcm);
    ov_clear(&file);
    if (error != AL_NO_ERROR) {
        l_error("AUDIO OpenAL buffer failed error=0x%x path=%s", error, path);
        alDeleteBuffers(1, buffer);
        *buffer = 0;
        return false;
    }
    l_info("AUDIO OGG loaded path=%s pcm_bytes=%u rate=%ld channels=%d",
           path, (unsigned)used, sample_rate, channels);
    return true;
}

bool audio_init(void) {
    if (initialized) return true;
    device = alcOpenDevice(NULL);
    context = device ? alcCreateContext(device, NULL) : NULL;
    if (!device || !context || !alcMakeContextCurrent(context)) {
        l_error("AUDIO OpenAL initialization failed device=%p context=%p", device, context);
        return false;
    }
    alGenSources(1, &music_source);
    initialized = alGetError() == AL_NO_ERROR;
    l_info("AUDIO OpenAL initialized=%d device=%p context=%p", initialized, device, context);
    return initialized;
}

void audio_stop_music(void) {
    if (!initialized) return;
    alSourceStop(music_source);
    alSourcei(music_source, AL_BUFFER, 0);
    if (music_buffer) alDeleteBuffers(1, &music_buffer);
    music_buffer = 0;
}

void audio_play_music(const char *path, bool loop) {
    if (!audio_init()) return;
    audio_stop_music();
    if (!load_ogg(path, &music_buffer)) return;
    alSourcei(music_source, AL_BUFFER, music_buffer);
    alSourcei(music_source, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
    source_float(music_source, AL_GAIN, music_volume);
    alSourcePlay(music_source);
    l_info("AUDIO music play requested=%s loop=%d", path, loop);
}

void audio_pause_music(void) { if (initialized) alSourcePause(music_source); }
void audio_resume_music(void) { if (initialized) alSourcePlay(music_source); }
void audio_rewind_music(void) { if (initialized) alSourceRewind(music_source); }
void audio_set_music_volume(float volume) {
    l_info("AUDIO music volume requested=%.3f", volume);
    if (volume <= 0.0f) {
        l_warn("AUDIO music volume fallback=1.000 (Android preferences unavailable)");
        volume = 1.0f;
    }
    music_volume = volume;
    if (initialized) source_float(music_source, AL_GAIN, volume);
}
float audio_get_music_volume(void) { return music_volume; }
void audio_set_user_music_volume(float volume) {
    if (volume < 0.0f) volume = 0.0f;
    if (volume > 1.0f) volume = 1.0f;
    music_volume = volume;
    if (initialized) source_float(music_source, AL_GAIN, volume);
    l_info("AUDIO user music volume=%.2f", volume);
}
bool audio_music_playing(void) {
    ALint state = AL_STOPPED;
    if (initialized) alGetSourcei(music_source, AL_SOURCE_STATE, &state);
    return state == AL_PLAYING;
}

static effect_slot *effect_slot_for_play(void) {
    for (int i = 0; i < EFFECT_SLOTS; ++i) {
        ALint state = AL_STOPPED;
        if (effects[i].source) alGetSourcei(effects[i].source, AL_SOURCE_STATE, &state);
        if (!effects[i].source || (state != AL_PLAYING && state != AL_PAUSED)) {
            if (effects[i].source) {
                alSourceStop(effects[i].source);
                alSourcei(effects[i].source, AL_BUFFER, 0);
                alDeleteSources(1, &effects[i].source);
            }
            if (effects[i].buffer) {
                alDeleteBuffers(1, &effects[i].buffer);
            }
            memset(&effects[i], 0, sizeof(effects[i]));
            return &effects[i];
        }
    }
    if (effects[0].source) {
        alSourceStop(effects[0].source);
        alSourcei(effects[0].source, AL_BUFFER, 0);
        alDeleteSources(1, &effects[0].source);
    }
    if (effects[0].buffer) {
        alDeleteBuffers(1, &effects[0].buffer);
    }
    memset(&effects[0], 0, sizeof(effects[0]));
    return &effects[0];
}

unsigned int audio_play_effect(const char *path, bool loop, float gain) {
    if (!audio_init()) return 0;
    effect_slot *slot = effect_slot_for_play();
    if (!load_ogg(path, &slot->buffer)) return 0;
    alGenSources(1, &slot->source);
    alSourcei(slot->source, AL_BUFFER, slot->buffer);
    alSourcei(slot->source, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
    source_float(slot->source, AL_GAIN, gain * effects_volume);
    slot->id = next_effect_id++;
    alSourcePlay(slot->source);
    l_info("AUDIO effect play id=%u requested=%s loop=%d gain=%.2f",
           slot->id, path, loop, gain);
    return slot->id;
}

static effect_slot *find_effect(unsigned int id) {
    for (int i = 0; i < EFFECT_SLOTS; ++i)
        if (effects[i].id == id) return &effects[i];
    return NULL;
}
void audio_stop_effect(unsigned int id) { effect_slot *s = find_effect(id); if (s && s->source) alSourceStop(s->source); }
void audio_pause_effect(unsigned int id) { effect_slot *s = find_effect(id); if (s && s->source) alSourcePause(s->source); }
void audio_resume_effect(unsigned int id) { effect_slot *s = find_effect(id); if (s && s->source) alSourcePlay(s->source); }
void audio_stop_all_effects(void) {
    if (!initialized) return;
    for (int i = 0; i < EFFECT_SLOTS; ++i) {
        if (effects[i].source) {
            alSourceStop(effects[i].source);
            alSourcei(effects[i].source, AL_BUFFER, 0);
            alDeleteSources(1, &effects[i].source);
            effects[i].source = 0;
        }
        if (effects[i].buffer) {
            alDeleteBuffers(1, &effects[i].buffer);
            effects[i].buffer = 0;
        }
        effects[i].id = 0;
    }
}
void audio_pause_all_effects(void) { for (int i = 0; i < EFFECT_SLOTS; ++i) if (effects[i].source) alSourcePause(effects[i].source); }
void audio_resume_all_effects(void) { for (int i = 0; i < EFFECT_SLOTS; ++i) if (effects[i].source) alSourcePlay(effects[i].source); }
void audio_set_effects_volume(float volume) {
    l_info("AUDIO effects volume requested=%.3f", volume);
    if (volume <= 0.0f) {
        l_warn("AUDIO effects volume fallback=1.000 (Android preferences unavailable)");
        volume = 1.0f;
    }
    effects_volume = volume;
}
float audio_get_effects_volume(void) { return effects_volume; }
void audio_set_user_effects_volume(float volume) {
    if (volume < 0.0f) volume = 0.0f;
    if (volume > 1.0f) volume = 1.0f;
    effects_volume = volume;
    for (int i = 0; i < EFFECT_SLOTS; ++i) {
        if (effects[i].source) source_float(effects[i].source, AL_GAIN, volume);
    }
    l_info("AUDIO user effects volume=%.2f", volume);
}

void audio_log_status(unsigned int frame) {
    if (!initialized) {
        l_info("AUDIO status frame=%u initialized=0", frame);
        return;
    }
    ALint state = 0, queued = 0, processed = 0;
    ALfloat seconds = 0.0f, gain = 0.0f;
    alGetSourcei(music_source, AL_SOURCE_STATE, &state);
    alGetSourcei(music_source, AL_BUFFERS_QUEUED, &queued);
    alGetSourcei(music_source, AL_BUFFERS_PROCESSED, &processed);
    alGetSourcef(music_source, AL_SEC_OFFSET, &seconds);
    alGetSourcef(music_source, AL_GAIN, &gain);
    ALenum al_error = alGetError();
    ALCenum alc_error = alcGetError(device);
    l_info("AUDIO status frame=%u state=0x%x queued=%d processed=%d offset=%.3f gain=%.3f al=0x%x alc=0x%x",
           frame, state, queued, processed, seconds, gain, al_error, alc_error);
}