~ctwm/ctwm/trunk

/*

 * 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;

}