feat: add mute functionality via command-line option and runtime file check

This commit is contained in:
sankalp committed 2025-10-08 12:35:18 +05:45
1 parent fb81c12ba7
commit 5902bf3ebb
2 files changed
+188 -33

No files matched your search

+50 -2
View File
@@ -1,4 +1,5 @@
#define _GNU_SOURCE #define _GNU_SOURCE
#include <errno.h>
#include <json-c/json.h> #include <json-c/json.h>
#include <libgen.h> #include <libgen.h>
#include <pthread.h> #include <pthread.h>
@@ -43,6 +44,7 @@ typedef struct {
SoundPack g_sound_pack = {0}; SoundPack g_sound_pack = {0};
float g_volume = 1.0f; float g_volume = 1.0f;
int g_verbose = 0; int g_verbose = 0;
int g_mute = 0;
pthread_t sound_threads[MAX_CONCURRENT_SOUNDS]; pthread_t sound_threads[MAX_CONCURRENT_SOUNDS];
volatile int thread_active[MAX_CONCURRENT_SOUNDS] = {0}; volatile int thread_active[MAX_CONCURRENT_SOUNDS] = {0};
pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -390,6 +392,13 @@ int find_available_thread_slot() {
} }
void play_sound_segment(int key_code, int is_pressed) { void play_sound_segment(int key_code, int is_pressed) {
if (g_mute) {
if (g_verbose) {
printf("Sound muted - ignoring key %d (%s)\n", key_code,
is_pressed ? "press" : "release");
}
return;
}
if (!g_sound_pack.is_multi && !is_pressed) { if (!g_sound_pack.is_multi && !is_pressed) {
if (g_verbose) { if (g_verbose) {
printf("Single mode: Ignoring key release for key %d\n", key_code); printf("Single mode: Ignoring key release for key %d\n", key_code);
@@ -476,11 +485,36 @@ void cleanup() {
pthread_mutex_unlock(&thread_mutex); pthread_mutex_unlock(&thread_mutex);
} }
static int read_mute_state() {
char mute_file[MAX_LINE_LENGTH];
const char *rd = getenv("XDG_RUNTIME_DIR");
if (!rd || strlen(rd) == 0) {
rd = "/tmp";
}
snprintf(mute_file, sizeof(mute_file), "%s/keyvibe-mute-%d", rd,
(int)getuid());
FILE *f = fopen(mute_file, "r");
if (!f) {
return 0; // Default to unmuted if file doesn't exist
}
int mute = 0;
if (fscanf(f, "%d", &mute) == 1) {
fclose(f);
return mute;
}
fclose(f);
return 0;
}
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
if (argc < 2 || argc > 4) { if (argc < 2 || argc > 5) {
fprintf(stderr, "Usage: %s <config.json> [volume] [verbose]\n", argv[0]); fprintf(stderr, "Usage: %s <config.json> [volume] [verbose] [mute]\n",
argv[0]);
fprintf(stderr, " volume: 0-100 (default: 50)\n"); fprintf(stderr, " volume: 0-100 (default: 50)\n");
fprintf(stderr, " verbose: 1 to enable verbose output (default: 0)\n"); fprintf(stderr, " verbose: 1 to enable verbose output (default: 0)\n");
fprintf(stderr, " mute: 1 to mute sound (default: 0)\n");
return 1; return 1;
} }
if (argc >= 3) { if (argc >= 3) {
@@ -500,6 +534,12 @@ int main(int argc, char *argv[]) {
printf("Verbose mode enabled\n"); printf("Verbose mode enabled\n");
} }
} }
if (argc >= 5) {
g_mute = atoi(argv[4]);
if (g_mute) {
printf("Sound muted\n");
}
}
if (load_sound_config(argv[1]) != 0) { if (load_sound_config(argv[1]) != 0) {
fprintf(stderr, "Failed to load sound configuration\n"); fprintf(stderr, "Failed to load sound configuration\n");
return 1; return 1;
@@ -508,16 +548,24 @@ int main(int argc, char *argv[]) {
fprintf(stderr, "Failed to initialize audio\n"); fprintf(stderr, "Failed to initialize audio\n");
return 1; return 1;
} }
// Remove signal handlers - we'll use file-based approach instead
fd_set readfds; fd_set readfds;
struct timeval timeout; struct timeval timeout;
char line[MAX_LINE_LENGTH]; char line[MAX_LINE_LENGTH];
while (1) { while (1) {
// Check mute state from file periodically
g_mute = read_mute_state();
FD_ZERO(&readfds); FD_ZERO(&readfds);
FD_SET(STDIN_FILENO, &readfds); FD_SET(STDIN_FILENO, &readfds);
timeout.tv_sec = 1; timeout.tv_sec = 1;
timeout.tv_usec = 0; timeout.tv_usec = 0;
int ready = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &timeout); int ready = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &timeout);
if (ready == -1) { if (ready == -1) {
if (errno == EINTR) {
// Signal interrupted select, continue
continue;
}
perror("select"); perror("select");
break; break;
} else if (ready == 0) { } else if (ready == 0) {
+138 -31
View File
@@ -21,6 +21,7 @@
#define MAX_PATH_LENGTH 512 #define MAX_PATH_LENGTH 512
#define AUDIO_BASE_DIR KeyVibe_DATA_DIR "/audio" #define AUDIO_BASE_DIR KeyVibe_DATA_DIR "/audio"
#define USER_AUDIO_SUBPATH "/.local/share/keyvibe/audio"
#define USER_CONFIG_FILENAME ".keyvibe.json" #define USER_CONFIG_FILENAME ".keyvibe.json"
// Global variables for cleanup // Global variables for cleanup
@@ -34,6 +35,7 @@ static char current_sound_name[MAX_PATH_LENGTH] = {0};
static int current_verbose = 0; static int current_verbose = 0;
static char current_config_path[MAX_PATH_LENGTH] = {0}; static char current_config_path[MAX_PATH_LENGTH] = {0};
static char current_sound_dir[MAX_PATH_LENGTH] = {0}; static char current_sound_dir[MAX_PATH_LENGTH] = {0};
static int current_mute = 0;
void print_usage(const char *program_name) { void print_usage(const char *program_name) {
printf("KeyVibe - Mechanical Keyboard Sound Simulator\n\n"); printf("KeyVibe - Mechanical Keyboard Sound Simulator\n\n");
@@ -46,6 +48,8 @@ void print_usage(const char *program_name) {
printf(" --daemon Run in background (write PID file)\n"); printf(" --daemon Run in background (write PID file)\n");
printf(" --stop Stop background daemon\n"); printf(" --stop Stop background daemon\n");
printf(" --reload Send reload signal to running daemon\n"); printf(" --reload Send reload signal to running daemon\n");
printf(" --mute Mute sound\n");
printf(" --unmute Unmute sound\n");
printf(" -h, --help Show this help message\n"); printf(" -h, --help Show this help message\n");
printf(" -v, --verbose Enable verbose output\n"); printf(" -v, --verbose Enable verbose output\n");
printf("\nConfiguration:\n"); printf("\nConfiguration:\n");
@@ -68,44 +72,100 @@ int list_sound_packs() {
char path[MAX_PATH_LENGTH]; char path[MAX_PATH_LENGTH];
struct stat st; struct stat st;
dir = opendir(AUDIO_BASE_DIR); // Determine user audio dir
if (dir == NULL) { char user_audio_dir[MAX_PATH_LENGTH] = {0};
fprintf(stderr, "Error: Cannot open audio directory '%s'\n", const char *home = getenv("HOME");
AUDIO_BASE_DIR); if (!home || strlen(home) == 0) {
fprintf(stderr, "Make sure you're running from the correct directory.\n"); struct passwd *pw = getpwuid(getuid());
return 1; if (pw && pw->pw_dir)
home = pw->pw_dir;
}
if (home) {
snprintf(user_audio_dir, sizeof(user_audio_dir), "%s%s", home,
USER_AUDIO_SUBPATH);
} }
printf("Available sound packs:\n"); printf("Available sound packs:\n");
printf("======================\n"); printf("======================\n");
while ((entry = readdir(dir)) != NULL) { // List user packs first (if available)
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) if (user_audio_dir[0] && (dir = opendir(user_audio_dir)) != NULL) {
continue; while ((entry = readdir(dir)) != NULL) {
snprintf(path, sizeof(path), "%s/%s", AUDIO_BASE_DIR, entry->d_name); if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) { continue;
printf(" %s\n", entry->d_name); snprintf(path, sizeof(path), "%s/%s", user_audio_dir, entry->d_name);
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
printf(" %s (user)\n", entry->d_name);
}
} }
closedir(dir);
} }
closedir(dir); // Then list system packs
dir = opendir(AUDIO_BASE_DIR);
if (dir != NULL) {
while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
snprintf(path, sizeof(path), "%s/%s", AUDIO_BASE_DIR, entry->d_name);
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
printf(" %s (system)\n", entry->d_name);
}
}
closedir(dir);
}
return 0;
}
static void get_user_audio_dir(char *buffer, size_t buflen) {
buffer[0] = '\0';
const char *home = getenv("HOME");
if (!home || strlen(home) == 0) {
struct passwd *pw = getpwuid(getuid());
if (pw && pw->pw_dir)
home = pw->pw_dir;
}
if (home)
snprintf(buffer, buflen, "%s%s", home, USER_AUDIO_SUBPATH);
}
static int resolve_sound_base_dir(const char *sound_name, char *out_basedir,
size_t out_sz) {
char user_audio_dir[MAX_PATH_LENGTH];
get_user_audio_dir(user_audio_dir, sizeof(user_audio_dir));
if (user_audio_dir[0]) {
char p[MAX_PATH_LENGTH];
snprintf(p, sizeof(p), "%s/%s/config.json", user_audio_dir, sound_name);
if (access(p, R_OK) == 0) {
strncpy(out_basedir, user_audio_dir, out_sz - 1);
out_basedir[out_sz - 1] = '\0';
return 1;
}
}
// Fallback to system dir
char p2[MAX_PATH_LENGTH];
snprintf(p2, sizeof(p2), "%s/%s/config.json", AUDIO_BASE_DIR, sound_name);
if (access(p2, R_OK) == 0) {
strncpy(out_basedir, AUDIO_BASE_DIR, out_sz - 1);
out_basedir[out_sz - 1] = '\0';
return 1;
}
return 0; return 0;
} }
int validate_sound_pack(const char *sound_name) { int validate_sound_pack(const char *sound_name) {
char config_path[MAX_PATH_LENGTH]; char basedir[MAX_PATH_LENGTH];
char sound_path[MAX_PATH_LENGTH]; if (!resolve_sound_base_dir(sound_name, basedir, sizeof(basedir))) {
fprintf(stderr,
snprintf(config_path, sizeof(config_path), "%s/%s/config.json", "Error: Sound pack '%s' not found in user or system dirs.\n",
AUDIO_BASE_DIR, sound_name); sound_name);
snprintf(sound_path, sizeof(sound_path), "%s/%s", AUDIO_BASE_DIR, sound_name);
if (access(sound_path, F_OK) != 0) {
fprintf(stderr, "Error: Sound pack '%s' not found in %s/\n", sound_name,
AUDIO_BASE_DIR);
fprintf(stderr, "Use --list to see available sound packs.\n"); fprintf(stderr, "Use --list to see available sound packs.\n");
return 0; return 0;
} }
char config_path[MAX_PATH_LENGTH];
snprintf(config_path, sizeof(config_path), "%s/%s/config.json", basedir,
sound_name);
if (access(config_path, R_OK) != 0) { if (access(config_path, R_OK) != 0) {
fprintf(stderr, "Error: Config file not found: %s\n", config_path); fprintf(stderr, "Error: Config file not found: %s\n", config_path);
return 0; return 0;
@@ -174,7 +234,11 @@ static const char *get_runtime_dir() {
static int build_paths_for_sound(const char *sound_name, char *out_config_path, static int build_paths_for_sound(const char *sound_name, char *out_config_path,
size_t out_config_sz, char *out_sound_dir, size_t out_config_sz, char *out_sound_dir,
size_t out_sound_sz) { size_t out_sound_sz) {
size_t base_len = strlen(AUDIO_BASE_DIR); char basedir[MAX_PATH_LENGTH];
if (!resolve_sound_base_dir(sound_name, basedir, sizeof(basedir))) {
return 0;
}
size_t base_len = strlen(basedir);
size_t name_len = strlen(sound_name); size_t name_len = strlen(sound_name);
const char *cfg_suffix = "/config.json"; const char *cfg_suffix = "/config.json";
size_t cfg_suffix_len = strlen(cfg_suffix); size_t cfg_suffix_len = strlen(cfg_suffix);
@@ -186,9 +250,9 @@ static int build_paths_for_sound(const char *sound_name, char *out_config_path,
fprintf(stderr, "Error: sound pack name too long for directory buffer.\n"); fprintf(stderr, "Error: sound pack name too long for directory buffer.\n");
return 0; return 0;
} }
snprintf(out_config_path, out_config_sz, "%s/%s%s", AUDIO_BASE_DIR, snprintf(out_config_path, out_config_sz, "%s/%s%s", basedir, sound_name,
sound_name, cfg_suffix); cfg_suffix);
snprintf(out_sound_dir, out_sound_sz, "%s/%s", AUDIO_BASE_DIR, sound_name); snprintf(out_sound_dir, out_sound_sz, "%s/%s", basedir, sound_name);
return 1; return 1;
} }
@@ -267,7 +331,7 @@ static void stop_children() {
} }
static int start_children(const char *sound_dir, const char *config_path, static int start_children(const char *sound_dir, const char *config_path,
int volume, int verbose) { int volume, int verbose, int mute) {
(void)config_path; (void)config_path;
int pipefd[2]; int pipefd[2];
if (pipe(pipefd) == -1) { if (pipe(pipefd) == -1) {
@@ -296,8 +360,10 @@ static int start_children(const char *sound_dir, const char *config_path,
snprintf(volume_str, sizeof(volume_str), "%d", volume); snprintf(volume_str, sizeof(volume_str), "%d", volume);
char verbose_str[8]; char verbose_str[8];
snprintf(verbose_str, sizeof(verbose_str), "%d", verbose); snprintf(verbose_str, sizeof(verbose_str), "%d", verbose);
char mute_str[8];
snprintf(mute_str, sizeof(mute_str), "%d", mute);
execl(sound_player_path, "keyvibe-audio", "config.json", volume_str, execl(sound_player_path, "keyvibe-audio", "config.json", volume_str,
verbose_str, (char *)NULL); verbose_str, mute_str, (char *)NULL);
perror("execl keyvibe-audio"); perror("execl keyvibe-audio");
exit(1); exit(1);
} }
@@ -330,6 +396,19 @@ static void handle_sighup(int sig) {
reload_requested = 1; reload_requested = 1;
} }
static void write_mute_state(int mute) {
char mute_file[MAX_PATH_LENGTH];
const char *rd = get_runtime_dir();
snprintf(mute_file, sizeof(mute_file), "%s/keyvibe-mute-%d", rd,
(int)getuid());
FILE *f = fopen(mute_file, "w");
if (f) {
fprintf(f, "%d\n", mute);
fclose(f);
}
}
struct inotify_thread_args { struct inotify_thread_args {
char path[MAX_PATH_LENGTH]; char path[MAX_PATH_LENGTH];
}; };
@@ -428,6 +507,8 @@ int main(int argc, char *argv[]) {
{"daemon", no_argument, 0, 1000}, {"daemon", no_argument, 0, 1000},
{"stop", no_argument, 0, 1001}, {"stop", no_argument, 0, 1001},
{"reload", no_argument, 0, 1002}, {"reload", no_argument, 0, 1002},
{"mute", no_argument, 0, 1003},
{"unmute", no_argument, 0, 1004},
{"help", no_argument, 0, 'h'}, {"help", no_argument, 0, 'h'},
{"verbose", no_argument, 0, 'v'}, {"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}}; {0, 0, 0, 0}};
@@ -489,6 +570,32 @@ int main(int argc, char *argv[]) {
printf("KeyVibe reload signal sent.\n"); printf("KeyVibe reload signal sent.\n");
return 0; return 0;
} }
case 1003: {
build_pidfile_path(pidfile_path, sizeof(pidfile_path));
pid_t running_pid = 0;
if (!read_pidfile(pidfile_path, &running_pid) ||
!process_is_running(running_pid)) {
fprintf(stderr, "KeyVibe: not running.\n");
return 1;
}
// Write mute state to file instead of using signals
write_mute_state(1);
printf("KeyVibe muted.\n");
return 0;
}
case 1004: {
build_pidfile_path(pidfile_path, sizeof(pidfile_path));
pid_t running_pid = 0;
if (!read_pidfile(pidfile_path, &running_pid) ||
!process_is_running(running_pid)) {
fprintf(stderr, "KeyVibe: not running.\n");
return 1;
}
// Write mute state to file instead of using signals
write_mute_state(0);
printf("KeyVibe unmuted.\n");
return 0;
}
case 'h': case 'h':
print_usage(argv[0]); print_usage(argv[0]);
return 0; return 0;
@@ -607,7 +714,7 @@ int main(int argc, char *argv[]) {
printf("Press Ctrl+C to exit.\n"); printf("Press Ctrl+C to exit.\n");
} }
} }
if (!start_children(sound_dir, config_path, volume, verbose)) { if (!start_children(sound_dir, config_path, volume, verbose, current_mute)) {
return 1; return 1;
} }
int status; int status;
@@ -649,7 +756,7 @@ int main(int argc, char *argv[]) {
} }
stop_children(); stop_children();
start_children(current_sound_dir, current_config_path, current_volume, start_children(current_sound_dir, current_config_path, current_volume,
current_verbose); current_verbose, current_mute);
} }
continue; continue;
} }