#include <config.h>
#if defined HAVE_SOUND
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include "lisp.h"
#include "dispextern.h"
#include "atimer.h"
#include <signal.h>
#include "syssignal.h"
#ifdef HAVE_MACHINE_SOUNDCARD_H
#include <machine/soundcard.h>
#endif
#ifdef HAVE_SYS_SOUNDCARD_H
#include <sys/soundcard.h>
#endif
#ifdef HAVE_SOUNDCARD_H
#include <sys/ioctl.h>
#include <soundcard.h>
#endif
#ifndef DEFAULT_SOUND_DEVICE
#define DEFAULT_SOUND_DEVICE "/dev/dsp"
#endif
#define max(X, Y) ((X) > (Y) ? (X) : (Y))
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
#define abs(X) ((X) < 0 ? -(X) : (X))
struct sound;
struct sound_device;
struct wav_header
{
u_int32_t magic;
u_int32_t length;
u_int32_t chunk_type;
u_int32_t chunk_format;
u_int32_t chunk_length;
u_int16_t format;
u_int16_t channels;
u_int32_t sample_rate;
u_int32_t bytes_per_second;
u_int16_t sample_size;
u_int16_t precision;
u_int32_t chunk_data;
u_int32_t data_length;
};
struct au_header
{
u_int32_t magic_number;
u_int32_t data_offset;
u_int32_t data_size;
u_int32_t encoding;
u_int32_t sample_rate;
u_int32_t channels;
};
#define MAX_SOUND_HEADER_BYTES \
max (sizeof (struct wav_header), sizeof (struct au_header))
struct sound_device
{
char *file;
int fd;
int format;
int volume;
int sample_size;
int sample_rate;
int bps;
int channels;
void (* open) P_ ((struct sound_device *sd));
void (* close) P_ ((struct sound_device *sd));
void (* configure) P_ ((struct sound_device *device));
void (* choose_format) P_ ((struct sound_device *sd,
struct sound *s));
void (* write) P_ ((struct sound_device *sd, char *buffer, int nbytes));
void *data;
};
enum sound_type
{
RIFF,
SUN_AUDIO
};
struct sound
{
enum sound_type type;
int fd;
char *header;
int header_size;
Lisp_Object data;
void (* play) P_ ((struct sound *s, struct sound_device *sd));
};
enum sound_attr
{
SOUND_FILE,
SOUND_DATA,
SOUND_DEVICE,
SOUND_VOLUME,
SOUND_ATTR_SENTINEL
};
extern Lisp_Object QCfile, QCdata;
Lisp_Object QCvolume, QCdevice;
Lisp_Object Qsound;
Lisp_Object Qplay_sound_functions;
struct sound_device *current_sound_device;
struct sound *current_sound;
static void vox_open P_ ((struct sound_device *));
static void vox_configure P_ ((struct sound_device *));
static void vox_close P_ ((struct sound_device *sd));
static void vox_choose_format P_ ((struct sound_device *, struct sound *));
static void vox_init P_ ((struct sound_device *));
static void vox_write P_ ((struct sound_device *, char *, int));
static void sound_perror P_ ((char *));
static void sound_warning P_ ((char *));
static int parse_sound P_ ((Lisp_Object, Lisp_Object *));
static void find_sound_type P_ ((struct sound *));
static u_int32_t le2hl P_ ((u_int32_t));
static u_int16_t le2hs P_ ((u_int16_t));
static u_int32_t be2hl P_ ((u_int32_t));
static int wav_init P_ ((struct sound *));
static void wav_play P_ ((struct sound *, struct sound_device *));
static int au_init P_ ((struct sound *));
static void au_play P_ ((struct sound *, struct sound_device *));
#if 0
static u_int16_t be2hs P_ ((u_int16_t));
#endif
static void
sound_perror (msg)
char *msg;
{
int saved_errno = errno;
turn_on_atimers (1);
#ifdef SIGIO
sigunblock (sigmask (SIGIO));
#endif
if (saved_errno != 0)
error ("%s: %s", msg, strerror (saved_errno));
else
error ("%s", msg);
}
static void
sound_warning (msg)
char *msg;
{
message (msg);
}
static int
parse_sound (sound, attrs)
Lisp_Object sound;
Lisp_Object *attrs;
{
if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
return 0;
sound = XCDR (sound);
attrs[SOUND_FILE] = Fplist_get (sound, QCfile);
attrs[SOUND_DATA] = Fplist_get (sound, QCdata);
attrs[SOUND_DEVICE] = Fplist_get (sound, QCdevice);
attrs[SOUND_VOLUME] = Fplist_get (sound, QCvolume);
if (!STRINGP (attrs[SOUND_FILE])
&& !STRINGP (attrs[SOUND_DATA]))
return 0;
if (!NILP (attrs[SOUND_VOLUME]))
{
if (INTEGERP (attrs[SOUND_VOLUME]))
{
if (XINT (attrs[SOUND_VOLUME]) < 0
|| XINT (attrs[SOUND_VOLUME]) > 100)
return 0;
}
else if (FLOATP (attrs[SOUND_VOLUME]))
{
if (XFLOAT_DATA (attrs[SOUND_VOLUME]) < 0
|| XFLOAT_DATA (attrs[SOUND_VOLUME]) > 1)
return 0;
}
else
return 0;
}
if (!NILP (attrs[SOUND_DEVICE])
&& !STRINGP (attrs[SOUND_DEVICE]))
return 0;
return 1;
}
static void
find_sound_type (s)
struct sound *s;
{
if (!wav_init (s) && !au_init (s))
error ("Unknown sound format");
}
static Lisp_Object
sound_cleanup (arg)
Lisp_Object arg;
{
if (current_sound_device)
{
if (current_sound_device->close)
current_sound_device->close (current_sound_device);
if (current_sound->fd > 0)
emacs_close (current_sound->fd);
}
return Qnil;
}
DEFUN ("play-sound", Fplay_sound, Splay_sound, 1, 1, 0,
"Play sound SOUND.\n\
SOUND is a list of the form `(sound KEYWORD VALUE...)'.\n\
The following keywords are recognized:\n\
\n\
:file FILE.- read sound data from FILE. If FILE isn't an\n\
absolute file name, it is searched in `data-directory'.\n\
\n\
:data DATA - read sound data from string DATA.\n\
\n\
Exactly one of :file or :data must be present.\n\
\n\
:volume VOL - set volume to VOL. VOL must an integer in the\n\
range 0..100 or a float in the range 0..1.0. If not specified,\n\
don't change the volume setting of the sound device.\n\
\n\
:device DEVICE - play sound on DEVICE. If not specified,\n\
a system-dependent default device name is used.")
(sound)
Lisp_Object sound;
{
Lisp_Object attrs[SOUND_ATTR_SENTINEL];
Lisp_Object file;
struct gcpro gcpro1, gcpro2;
struct sound_device sd;
struct sound s;
Lisp_Object args[2];
int count = specpdl_ptr - specpdl;
file = Qnil;
GCPRO2 (sound, file);
bzero (&sd, sizeof sd);
bzero (&s, sizeof s);
current_sound_device = &sd;
current_sound = &s;
record_unwind_protect (sound_cleanup, Qnil);
s.header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
if (!parse_sound (sound, attrs))
error ("Invalid sound specification");
if (STRINGP (attrs[SOUND_FILE]))
{
s.fd = openp (Fcons (Vdata_directory, Qnil),
attrs[SOUND_FILE], "", &file, 0);
if (s.fd < 0)
sound_perror ("Could not open sound file");
s.header_size = emacs_read (s.fd, s.header, MAX_SOUND_HEADER_BYTES);
if (s.header_size < 0)
sound_perror ("Invalid sound file header");
}
else
{
s.data = attrs[SOUND_DATA];
s.header_size = min (MAX_SOUND_HEADER_BYTES, STRING_BYTES (XSTRING (s.data)));
bcopy (XSTRING (s.data)->data, s.header, s.header_size);
}
find_sound_type (&s);
if (STRINGP (attrs[SOUND_DEVICE]))
{
int len = XSTRING (attrs[SOUND_DEVICE])->size;
sd.file = (char *) alloca (len + 1);
strcpy (sd.file, XSTRING (attrs[SOUND_DEVICE])->data);
}
if (INTEGERP (attrs[SOUND_VOLUME]))
sd.volume = XFASTINT (attrs[SOUND_VOLUME]);
else if (FLOATP (attrs[SOUND_VOLUME]))
sd.volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
args[0] = Qplay_sound_functions;
args[1] = sound;
Frun_hook_with_args (2, args);
vox_init (&sd);
sd.open (&sd);
s.play (&s, &sd);
if (!STRINGP (s.data))
{
emacs_close (s.fd);
s.fd = -1;
}
sd.close (&sd);
current_sound_device = NULL;
current_sound = NULL;
UNGCPRO;
unbind_to (count, Qnil);
return Qnil;
}
static u_int32_t
le2hl (value)
u_int32_t value;
{
#ifdef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
#endif
return value;
}
static u_int16_t
le2hs (value)
u_int16_t value;
{
#ifdef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
value = p[0] + (p[1] << 8);
#endif
return value;
}
static u_int32_t
be2hl (value)
u_int32_t value;
{
#ifndef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
value = p[3] + (p[2] << 8) + (p[1] << 16) + (p[0] << 24);
#endif
return value;
}
#if 0
static u_int16_t
be2hs (value)
u_int16_t value;
{
#ifndef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
value = p[1] + (p[0] << 8);
#endif
return value;
}
#endif
static int
wav_init (s)
struct sound *s;
{
struct wav_header *header = (struct wav_header *) s->header;
if (s->header_size < sizeof *header
|| bcmp (s->header, "RIFF", 4) != 0)
return 0;
header->magic = le2hl (header->magic);
header->length = le2hl (header->length);
header->chunk_type = le2hl (header->chunk_type);
header->chunk_format = le2hl (header->chunk_format);
header->chunk_length = le2hl (header->chunk_length);
header->format = le2hs (header->format);
header->channels = le2hs (header->channels);
header->sample_rate = le2hl (header->sample_rate);
header->bytes_per_second = le2hl (header->bytes_per_second);
header->sample_size = le2hs (header->sample_size);
header->precision = le2hs (header->precision);
header->chunk_data = le2hl (header->chunk_data);
header->data_length = le2hl (header->data_length);
s->type = RIFF;
s->play = wav_play;
return 1;
}
static void
wav_play (s, sd)
struct sound *s;
struct sound_device *sd;
{
struct wav_header *header = (struct wav_header *) s->header;
sd->choose_format (sd, s);
sd->sample_size = header->sample_size;
sd->sample_rate = header->sample_rate;
sd->bps = header->bytes_per_second;
sd->channels = header->channels;
sd->configure (sd);
if (STRINGP (s->data))
sd->write (sd, XSTRING (s->data)->data + sizeof *header,
STRING_BYTES (XSTRING (s->data)) - sizeof *header);
else
{
char *buffer;
int nbytes;
int blksize = 2048;
buffer = (char *) alloca (blksize);
lseek (s->fd, sizeof *header, SEEK_SET);
while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
sd->write (sd, buffer, nbytes);
if (nbytes < 0)
sound_perror ("Error reading sound file");
}
}
enum au_encoding
{
AU_ENCODING_ULAW_8 = 1,
AU_ENCODING_8,
AU_ENCODING_16,
AU_ENCODING_24,
AU_ENCODING_32,
AU_ENCODING_IEEE32,
AU_ENCODING_IEEE64,
AU_COMPRESSED = 23
};
static int
au_init (s)
struct sound *s;
{
struct au_header *header = (struct au_header *) s->header;
if (s->header_size < sizeof *header
|| bcmp (s->header, ".snd", 4) != 0)
return 0;
header->magic_number = be2hl (header->magic_number);
header->data_offset = be2hl (header->data_offset);
header->data_size = be2hl (header->data_size);
header->encoding = be2hl (header->encoding);
header->sample_rate = be2hl (header->sample_rate);
header->channels = be2hl (header->channels);
s->type = SUN_AUDIO;
s->play = au_play;
return 1;
}
static void
au_play (s, sd)
struct sound *s;
struct sound_device *sd;
{
struct au_header *header = (struct au_header *) s->header;
sd->sample_size = 0;
sd->sample_rate = header->sample_rate;
sd->bps = 0;
sd->channels = header->channels;
sd->choose_format (sd, s);
sd->configure (sd);
if (STRINGP (s->data))
sd->write (sd, XSTRING (s->data)->data + header->data_offset,
STRING_BYTES (XSTRING (s->data)) - header->data_offset);
else
{
int blksize = 2048;
char *buffer;
int nbytes;
lseek (s->fd, header->data_offset, SEEK_SET);
buffer = (char *) alloca (blksize);
while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
sd->write (sd, buffer, nbytes);
if (nbytes < 0)
sound_perror ("Error reading sound file");
}
}
static void
vox_open (sd)
struct sound_device *sd;
{
char *file;
if (sd->file)
file = sd->file;
else
file = DEFAULT_SOUND_DEVICE;
sd->fd = emacs_open (file, O_WRONLY, 0);
if (sd->fd < 0)
sound_perror (file);
}
static void
vox_configure (sd)
struct sound_device *sd;
{
int val;
xassert (sd->fd >= 0);
turn_on_atimers (0);
#ifdef SIGIO
sigblock (sigmask (SIGIO));
#endif
val = sd->format;
if (ioctl (sd->fd, SNDCTL_DSP_SETFMT, &sd->format) < 0
|| val != sd->format)
sound_perror ("Could not set sound format");
val = sd->channels != 1;
if (ioctl (sd->fd, SNDCTL_DSP_STEREO, &val) < 0
|| val != (sd->channels != 1))
sound_perror ("Could not set stereo/mono");
if (sd->sample_rate > 0)
{
val = sd->sample_rate;
if (ioctl (sd->fd, SNDCTL_DSP_SPEED, &sd->sample_rate) < 0)
sound_perror ("Could not set sound speed");
else if (val != sd->sample_rate)
sound_warning ("Could not set sample rate");
}
if (sd->volume > 0)
{
int volume = sd->volume & 0xff;
volume |= volume << 8;
ioctl (sd->fd, SOUND_MIXER_WRITE_PCM, &volume);
}
turn_on_atimers (1);
#ifdef SIGIO
sigunblock (sigmask (SIGIO));
#endif
}
static void
vox_close (sd)
struct sound_device *sd;
{
if (sd->fd >= 0)
{
#ifdef SIGIO
sigblock (sigmask (SIGIO));
#endif
turn_on_atimers (0);
ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL);
turn_on_atimers (1);
#ifdef SIGIO
sigunblock (sigmask (SIGIO));
#endif
emacs_close (sd->fd);
sd->fd = -1;
}
}
static void
vox_choose_format (sd, s)
struct sound_device *sd;
struct sound *s;
{
if (s->type == RIFF)
{
struct wav_header *h = (struct wav_header *) s->header;
if (h->precision == 8)
sd->format = AFMT_U8;
else if (h->precision == 16)
sd->format = AFMT_S16_LE;
else
error ("Unsupported WAV file format");
}
else if (s->type == SUN_AUDIO)
{
struct au_header *header = (struct au_header *) s->header;
switch (header->encoding)
{
case AU_ENCODING_ULAW_8:
case AU_ENCODING_IEEE32:
case AU_ENCODING_IEEE64:
sd->format = AFMT_MU_LAW;
break;
case AU_ENCODING_8:
case AU_ENCODING_16:
case AU_ENCODING_24:
case AU_ENCODING_32:
sd->format = AFMT_S16_LE;
break;
default:
error ("Unsupported AU file format");
}
}
else
abort ();
}
static void
vox_init (sd)
struct sound_device *sd;
{
sd->fd = -1;
sd->open = vox_open;
sd->close = vox_close;
sd->configure = vox_configure;
sd->choose_format = vox_choose_format;
sd->write = vox_write;
}
static void
vox_write (sd, buffer, nbytes)
struct sound_device *sd;
char *buffer;
int nbytes;
{
int nwritten = emacs_write (sd->fd, buffer, nbytes);
if (nwritten < 0)
sound_perror ("Error writing to sound device");
}
void
syms_of_sound ()
{
QCdevice = intern (":device");
staticpro (&QCdevice);
QCvolume = intern (":volume");
staticpro (&QCvolume);
Qsound = intern ("sound");
staticpro (&Qsound);
Qplay_sound_functions = intern ("play-sound-functions");
staticpro (&Qplay_sound_functions);
defsubr (&Splay_sound);
}
void
init_sound ()
{
}
#endif