#include "audio/playback.h" #include "audio/types.h" #include "common/utils.h" #include "common/log.h" #include #include #include #include #include #include #include #include pthread_t sound_threads[MAX_CONCURRENT_SOUNDS]; volatile int thread_active[MAX_CONCURRENT_SOUNDS] = {0}; pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER; static inline float get_boosted_system_volume(float vol_multiplier) { if (vol_multiplier >= 1.0f) return vol_multiplier; if (vol_multiplier <= 0.0f) return 0.0f; float inv = 1.0f - vol_multiplier; return 1.0f - (inv * inv * inv); } int init_audio() { if (g_sound_pack.is_multi) return 0; if (strlen(g_sound_pack.sound_file) == 0) { LOG_ERROR("No sound file specified in sound pack config"); LOG_ERROR("Check that your sound pack has a valid config.json file."); return -1; } if (access(g_sound_pack.sound_file, R_OK) != 0) { LOG_ERROR("Sound file not accessible: %s", g_sound_pack.sound_file); perror("access"); return -1; } SNDFILE *test_sf = sf_open(g_sound_pack.sound_file, SFM_READ, &g_sound_pack.sf_info); if (!test_sf) { LOG_ERROR("Could not open sound file: %s", g_sound_pack.sound_file); LOG_ERROR("libsndfile error: %s", sf_strerror(NULL)); return -1; } sf_close(test_sf); LOG_DEBUG("Sound file info: %ld frames, %d channels, %d Hz", (long)g_sound_pack.sf_info.frames, g_sound_pack.sf_info.channels, g_sound_pack.sf_info.samplerate); return 0; } void *play_sound_thread(void *arg) { PlaybackData *data = (PlaybackData *)arg; int key_code = data->key_code; int thread_id = data->thread_id; int is_pressed = data->is_pressed; const char *file_to_play = NULL; int is_mouse_event = (key_code == 272 || key_code == 273 || key_code == 274); SoundPack *sound_pack = is_mouse_event ? &g_mouse_sound_pack : &g_sound_pack; float volume = is_mouse_event ? g_mouse_volume : g_volume; int mute_state = is_mouse_event ? g_mouse_mute : g_keyboard_mute; LOG_DEBUG("Thread %d: Playing %s sound for key %d (%s)", thread_id, is_mouse_event ? "mouse" : "keyboard", key_code, is_pressed ? "press" : "release"); if (g_mute || mute_state) { LOG_DEBUG("Thread %d: %s sound is muted", thread_id, is_mouse_event ? "Mouse" : "Keyboard"); goto exit_cleanup; } if (sound_pack->is_multi) { if (is_pressed && sound_pack->multi_key_mappings[key_code].press) file_to_play = sound_pack->multi_key_mappings[key_code].press; else if (!is_pressed && sound_pack->multi_key_mappings[key_code].release) file_to_play = sound_pack->multi_key_mappings[key_code].release; else if (is_pressed && sound_pack->num_generic_press_files > 0) { int idx = rand() % sound_pack->num_generic_press_files; file_to_play = sound_pack->generic_press_files[idx]; } else if (!is_pressed && strlen(sound_pack->release_file) > 0) file_to_play = sound_pack->release_file; if (!file_to_play) { LOG_DEBUG("Thread %d: No sound file found for key %d (%s)", thread_id, key_code, is_pressed ? "press" : "release"); goto exit_cleanup; } LOG_DEBUG("Thread %d: Using sound file: %s", thread_id, file_to_play); SF_INFO sf_info = {0}; SNDFILE *sf = sf_open(file_to_play, SFM_READ, &sf_info); if (!sf) { LOG_ERROR("Could not open sound file: %s", file_to_play); LOG_ERROR("Details: %s", sf_strerror(NULL)); LOG_ERROR("Check that the audio file exists and is readable."); goto exit_cleanup; } pa_sample_spec ss = {.format = PA_SAMPLE_S16LE, .rate = sf_info.samplerate, .channels = sf_info.channels}; int pa_error; pa_simple *pa_handle = pa_simple_new(NULL, "KeyboardSounds", PA_STREAM_PLAYBACK, NULL, "playback", &ss, NULL, NULL, &pa_error); if (!pa_handle) { LOG_ERROR("Could not initialize PulseAudio: %s", pa_strerror(pa_error)); sf_close(sf); goto exit_cleanup; } int frames = 2048; short *buffer = malloc(frames * sf_info.channels * sizeof(short)); if (!buffer) { pa_simple_free(pa_handle); sf_close(sf); goto exit_cleanup; } sf_count_t read; while ((read = sf_readf_short(sf, buffer, frames)) > 0) { float vol_mult = volume * get_boosted_system_volume(g_system_volume_multiplier); for (sf_count_t i = 0; i < read * sf_info.channels; i++) { buffer[i] = (short)(buffer[i] * vol_mult); } int pa_write_error; if (pa_simple_write(pa_handle, buffer, read * sf_info.channels * sizeof(short), &pa_write_error) < 0) { LOG_ERROR("PulseAudio write error: %s", pa_strerror(pa_write_error)); break; } } int pa_drain_error; pa_simple_drain(pa_handle, &pa_drain_error); pa_simple_free(pa_handle); sf_close(sf); free(buffer); } else { if (key_code >= 512 || sound_pack->key_mappings[key_code].duration_ms == 0) { LOG_DEBUG("Thread %d: No mapping for key %d", thread_id, key_code); goto exit_cleanup; } SoundMapping *mapping = &sound_pack->key_mappings[key_code]; SF_INFO sf_info = sound_pack->sf_info; SNDFILE *sf = sf_open(sound_pack->sound_file, SFM_READ, &sf_info); if (!sf) { LOG_ERROR("Thread: Could not open sound file"); goto exit_cleanup; } pa_sample_spec ss = {.format = PA_SAMPLE_S16LE, .rate = sf_info.samplerate, .channels = sf_info.channels}; int pa_error; pa_simple *pa_handle = pa_simple_new(NULL, "KeyboardSounds", PA_STREAM_PLAYBACK, NULL, "playback", &ss, NULL, NULL, &pa_error); if (!pa_handle) { sf_close(sf); LOG_ERROR("Thread: Could not initialize PulseAudio: %s", pa_strerror(pa_error)); goto exit_cleanup; } sf_count_t start_frame = (mapping->start_ms * sf_info.samplerate) / 1000; sf_count_t duration_frames = (mapping->duration_ms * sf_info.samplerate) / 1000; sf_seek(sf, start_frame, SEEK_SET); short *buffer = malloc(duration_frames * sf_info.channels * sizeof(short)); if (!buffer) { pa_simple_free(pa_handle); sf_close(sf); goto exit_cleanup; } sf_count_t frames_read = sf_readf_short(sf, buffer, duration_frames); float vol_mult = volume * get_boosted_system_volume(g_system_volume_multiplier); for (sf_count_t i = 0; i < frames_read * sf_info.channels; i++) { buffer[i] = (short)(buffer[i] * vol_mult); } int pa_write_error, pa_drain_error; pa_simple_write(pa_handle, buffer, frames_read * sf_info.channels * sizeof(short), &pa_write_error); pa_simple_drain(pa_handle, &pa_drain_error); free(buffer); pa_simple_free(pa_handle); sf_close(sf); } exit_cleanup: pthread_mutex_lock(&thread_mutex); thread_active[thread_id] = 0; pthread_mutex_unlock(&thread_mutex); free(data); return NULL; } int find_available_thread_slot() { pthread_mutex_lock(&thread_mutex); for (int i = 0; i < MAX_CONCURRENT_SOUNDS; i++) { if (!thread_active[i]) { pthread_mutex_unlock(&thread_mutex); return i; } } pthread_mutex_unlock(&thread_mutex); return -1; } void play_sound_segment(int key_code, int is_pressed) { if (g_mute) { LOG_DEBUG("Sound muted - ignoring key %d (%s)", key_code, is_pressed ? "press" : "release"); return; } // Check if this is a mouse event and if mouse is disabled int is_mouse_event = (key_code == 272 || key_code == 273 || key_code == 274); if (is_mouse_event) { // For mouse events, we need to check if mouse is enabled // This will be handled by the main loop passing enabled state // For now, we'll add a simple check here extern int g_mouse_enabled; if (!g_mouse_enabled) { LOG_DEBUG("Mouse sounds disabled - ignoring mouse event %d", key_code); return; } } else { // For keyboard events, check if keyboard is enabled extern int g_keyboard_enabled; if (!g_keyboard_enabled) { LOG_DEBUG("Keyboard sounds disabled - ignoring key %d", key_code); return; } } if (!g_sound_pack.is_multi && !is_pressed) { LOG_DEBUG("Single mode: Ignoring key release for key %d", key_code); return; } int slot = find_available_thread_slot(); if (slot == -1) { LOG_WARN("No available thread slots"); return; } PlaybackData *data = malloc(sizeof(PlaybackData)); if (!data) return; data->key_code = key_code; data->thread_id = slot; data->is_pressed = is_pressed; pthread_mutex_lock(&thread_mutex); thread_active[slot] = 1; if (pthread_create(&sound_threads[slot], NULL, play_sound_thread, data) != 0) { thread_active[slot] = 0; free(data); LOG_ERROR("Failed to create sound thread"); } else { pthread_detach(sound_threads[slot]); } pthread_mutex_unlock(&thread_mutex); }