/usr/src/RPM/BUILD/ctwm-4.1.0/sound.c

Go to the documentation of this file.

/*
 * These routines were extracted from the sound hack for olvwm3.3 by
 * Andrew "Ender" Scherpbier (turtle@sciences.sdsu.edu, Andrew@SDSU.Edu)
 * and modified by J.E. Sacco (jsacco @ssl.com) for tvtwm and twm.  They
 * were then slightly adapted for ctwm by Mark Boyns (boyns@sdsu.edu),
 * and have since been reworked more.
 */
 
#include "ctwm.h"
 
#include <rplay.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
 
#include "event_names.h"
#include "sound.h"
 
RPLAY **rp = NULL;
 
static int need_sound_init = 1;
static int sound_from_config = 0;
static int sound_fd = 0;
static int sound_state = 1;
#define HOSTNAME_LEN 200
static char hostname[HOSTNAME_LEN];
 
/*
 * Function to trim away spaces at the start and end of a string
 */
static char *
trim_spaces(char *str)
{
    if(str != NULL) {
        char *p = str + strlen(str);
        while(*str != '\0' && *str != '\r' && *str != '\n' && isspace(*str)) {
            str++;
        }
        /* Assume all line end characters are at the end */
        while(p > str && isspace(p[-1])) {
            p--;
        }
        *p = '\0';
    }
    return str;
}
 
/*
 * Define stuff related to "magic" names.
 */
static const char *magic_events[] = {
    "Startup",
    "Shutdown",
};
#define NMAGICEVENTS (sizeof(magic_events) / sizeof(*magic_events))
 
static int
sound_magic_event_name2num(const char *name)
{
    int i;
 
    for(i = 0 ; i < NMAGICEVENTS ; i++) {
        if(strcasecmp(name, magic_events[i]) == 0) {
            /* We number these off the far end of the non-magic events */
            return event_names_size() + i;
        }
    }
 
    return -1;
}
 
 
/*
 * Now we know how many events we need to store up info for
 */
#define NEVENTS (event_names_size() + NMAGICEVENTS)
 
 
 
/*
 * Initialize the subsystem and its necessary bits
 */
void
sound_init(void)
{
    if(!need_sound_init) {
        return;
    }
 
    /* Can't happen */
    if(sound_fd != 0) {
        fprintf(stderr, "BUG: sound_fd not set but sound inited.\n");
        exit(1);
    }
 
    need_sound_init = 0;
    if(hostname[0] == '\0') {
        strncpy(hostname, rplay_default_host(), HOSTNAME_LEN - 1);
        hostname[HOSTNAME_LEN - 1] = '\0'; /* JIC */
    }
 
    if((sound_fd = rplay_open(hostname)) < 0) {
        rplay_perror("create");
    }
 
    /*
     * Init rp if necessary
     */
    if(rp == NULL) {
        if((rp = calloc(NEVENTS, sizeof(RPLAY *))) == NULL) {
            perror("calloc() rplay control");
            exit(1);
            /*
             * Should maybe just bomb out of sound stuff, but there's
             * currently no provision for that.  If malloc fails, we're
             * pretty screwed anyway, so it's not much loss to just die.
             */
        }
    }
}
 
 
/*
 * Clear out any set sounds
 */
void
sound_clear_list(void)
{
    int i;
 
    /* JIC */
    if(rp == NULL) {
        return;
    }
 
    /*
     * Destroy any old sounds
     */
    for(i = 0; i < NEVENTS; i++) {
        if(rp[i] != NULL) {
            rplay_destroy(rp[i]);
        }
        rp[i] = NULL;
    }
}
 
 
/*
 * [Re]load the sounds
 */
void
sound_load_list(void)
{
    FILE *fl;
    char *home;
    char *soundfile;
    char buffer[100];
 
    /* Guard; shouldn't be possible */
    if(rp == NULL) {
        fprintf(stderr, "Tried to load sounds before subsystem inited.\n");
        exit(1);
    }
 
    /* Find the .ctwm-sounds file */
    if((home = getenv("HOME")) == NULL) {
        home = "";
    }
    if(asprintf(&soundfile, "%s/.ctwm-sounds", home) < 0) {
        perror("Failed building path to sound file");
        return;
    }
    fl = fopen(soundfile, "r");
    free(soundfile);
 
    /*
     * If it was found, but we already have sound set from the config
     * file, complain on stderr and then return.
     */
    if(fl != NULL && sound_from_config) {
        fprintf(stderr, "RplaySounds set in ctwmrc, not reading "
                "~/.ctwm-sounds.\n");
        fclose(fl);
        return;
    }
 
    /* Clear out the old list, whether we have new or not */
    sound_clear_list();
 
    /* If there wasn't a .ctwm-sounds file, we're done now */
    if(fl == NULL) {
        return;
    }
 
    /* Now go ahead and parse it in */
    while(fgets(buffer, 100, fl) != NULL) {
        char *ename, *sndfile;
 
        ename = trim_spaces(strtok(buffer, ": \t"));
        if(ename == NULL || *ename == '#') {
            continue;
        }
 
        sndfile = trim_spaces(strtok(NULL, "\r\n"));
        if(sndfile == NULL || *sndfile == '#') {
            continue;
        }
 
        if(set_sound_event_name(ename, sndfile) != 0) {
            fprintf(stderr, "Error adding sound for %s; maybe event "
                    "name is invalid?\n", ename);
        }
    }
    fclose(fl);
}
 
 
/*
 * Play sound
 */
void
play_sound(int snd)
{
    /* Bounds */
    if(snd < 0 || snd >= NEVENTS) {
        return;
    }
 
    /* Playing enabled */
    if(sound_state == 0) {
        return;
    }
 
    /* Better already be initted */
    if(need_sound_init) {
        fprintf(stderr, "BUG: play_sound() Sound should be initted already.\n");
        return;
    }
 
    /* Skip if this isn't a sound we have set */
    if(rp[snd] == NULL) {
        return;
    }
 
    /* And if all else fails, play it */
    if(rplay(sound_fd, rp[snd]) < 0) {
        rplay_perror("rplay");
    }
}
 
void
play_startup_sound(void)
{
    play_sound(sound_magic_event_name2num("Startup"));
}
 
void
play_exit_sound(void)
{
    play_sound(sound_magic_event_name2num("Shutdown"));
}
 
 
/*
 * Flag that we loaded sounds from the ctwmrc
 */
void
sound_set_from_config(void)
{
    sound_from_config = 1;
}
 
 
/*
 * Toggle the sound on/off
 */
void
toggle_sound(void)
{
    sound_state ^= 1;
}
 
 
/*
 * Re-read the sounds mapping file
 */
void
reread_sounds(void)
{
    sound_load_list();
}
 
/*
 * Set the SoundHost and force the sound_fd to be re-opened.
 */
void
set_sound_host(char *host)
{
    strncpy(hostname, host, HOSTNAME_LEN - 1);
    hostname[HOSTNAME_LEN - 1] = '\0'; /* JIC */
    if(sound_fd != 0) {
        rplay_close(sound_fd);
    }
    sound_fd = 0;
}
 
/*
 * Set the sound to play for a given event
 */
int
set_sound_event_name(const char *ename, const char *soundfile)
{
    int i;
 
    /* Find the index we'll use in rp[] for it */
    i = sound_magic_event_name2num(ename);
    if(i < 0) {
        i = event_num_by_name(ename);
    }
    if(i < 0) {
        return -1;
    }
 
    /* Gotcha */
    return set_sound_event(i, soundfile);
}
 
int
set_sound_event(int snd, const char *soundfile)
{
    /* This shouldn't get called before things are initialized */
    if(rp == NULL) {
        fprintf(stderr, "%s(): internal error: called before initialized.\n", __func__);
        exit(1);
    }
 
    /* Cleanup old if necessary */
    if(rp[snd] != NULL) {
        rplay_destroy(rp[snd]);
    }
 
    /* Setup new */
    rp[snd] = rplay_create(RPLAY_PLAY);
    if(rp[snd] == NULL) {
        rplay_perror("create");
        return -1;
    }
    if(rplay_set(rp[snd], RPLAY_INSERT, 0, RPLAY_SOUND, soundfile, NULL)
                    < 0) {
        rplay_perror("rplay");
    }
 
    return 0;
}