1 /* sound.c -- sound support.
2 Copyright (C) 1998, 1999, 2001 Free Software Foundation.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Written by Gerd Moellmann <gerd@gnu.org>. Tested with Luigi's
22 driver on FreeBSD 2.2.7 with a SoundBlaster 16. */
26 #if defined HAVE_SOUND
30 #include <sys/types.h>
33 #include "dispextern.h"
36 #include "syssignal.h"
39 #include <sys/ioctl.h>
42 /* FreeBSD has machine/soundcard.h. Voxware sound driver docs mention
43 sys/soundcard.h. So, let's try whatever's there. */
45 #ifdef HAVE_MACHINE_SOUNDCARD_H
46 #include <machine/soundcard.h>
48 #ifdef HAVE_SYS_SOUNDCARD_H
49 #include <sys/soundcard.h>
51 #ifdef HAVE_SOUNDCARD_H
52 #include <soundcard.h>
55 #ifndef DEFAULT_SOUND_DEVICE
56 #define DEFAULT_SOUND_DEVICE "/dev/dsp"
59 #define abs(X) ((X) < 0 ? -(X) : (X))
61 /* Structure forward declarations. */
66 /* The file header of RIFF-WAVE files (*.wav). Files are always in
67 little-endian byte-order. */
74 u_int32_t chunk_format
;
75 u_int32_t chunk_length
;
78 u_int32_t sample_rate
;
79 u_int32_t bytes_per_second
;
80 u_int16_t sample_size
;
83 u_int32_t data_length
;
86 /* The file header of Sun adio files (*.au). Files are always in
87 big-endian byte-order. */
92 u_int32_t magic_number
;
94 /* Offset of data part from start of file. Minimum value is 24. */
95 u_int32_t data_offset
;
97 /* Size of data part, 0xffffffff if unknown. */
100 /* Data encoding format.
102 2 8-bit linear PCM (REF-PCM)
106 6 32-bit IEEE floating-point
107 7 64-bit IEEE floating-point
108 23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
112 /* Number of samples per second. */
113 u_int32_t sample_rate
;
115 /* Number of interleaved channels. */
119 /* Maximum of all sound file headers sizes. */
121 #define MAX_SOUND_HEADER_BYTES \
122 max (sizeof (struct wav_header), sizeof (struct au_header))
124 /* Interface structure for sound devices. */
128 /* The name of the device or null meaning use a default device name. */
131 /* File descriptor of the device. */
134 /* Device-dependent format. */
137 /* Volume (0..100). Zero means unspecified. */
146 /* Bytes per second. */
149 /* 1 = mono, 2 = stereo, 0 = don't set. */
152 /* Open device SD. */
153 void (* open
) P_ ((struct sound_device
*sd
));
155 /* Close device SD. */
156 void (* close
) P_ ((struct sound_device
*sd
));
158 /* Configure SD accoring to device-dependent parameters. */
159 void (* configure
) P_ ((struct sound_device
*device
));
161 /* Choose a device-dependent format for outputting sound S. */
162 void (* choose_format
) P_ ((struct sound_device
*sd
,
165 /* Write NYBTES bytes from BUFFER to device SD. */
166 void (* write
) P_ ((struct sound_device
*sd
, char *buffer
, int nbytes
));
168 /* A place for devices to store additional data. */
172 /* An enumerator for each supported sound file type. */
180 /* Interface structure for sound files. */
184 /* The type of the file. */
185 enum sound_type type
;
187 /* File descriptor of a sound file. */
190 /* Pointer to sound file header. This contains header_size bytes
191 read from the start of a sound file. */
194 /* Number of bytes raed from sound file. This is always <=
195 MAX_SOUND_HEADER_BYTES. */
198 /* Sound data, if a string. */
201 /* Play sound file S on device SD. */
202 void (* play
) P_ ((struct sound
*s
, struct sound_device
*sd
));
205 /* Indices of attributes in a sound attributes vector. */
218 extern Lisp_Object QCfile
, QCdata
;
219 Lisp_Object QCvolume
, QCdevice
;
221 Lisp_Object Qplay_sound_functions
;
223 /* These are set during `play-sound' so that sound_cleanup has
226 struct sound_device
*current_sound_device
;
227 struct sound
*current_sound
;
229 /* Function prototypes. */
231 static void vox_open
P_ ((struct sound_device
*));
232 static void vox_configure
P_ ((struct sound_device
*));
233 static void vox_close
P_ ((struct sound_device
*sd
));
234 static void vox_choose_format
P_ ((struct sound_device
*, struct sound
*));
235 static void vox_init
P_ ((struct sound_device
*));
236 static void vox_write
P_ ((struct sound_device
*, char *, int));
237 static void sound_perror
P_ ((char *));
238 static int parse_sound
P_ ((Lisp_Object
, Lisp_Object
*));
239 static void find_sound_type
P_ ((struct sound
*));
240 static u_int32_t le2hl
P_ ((u_int32_t
));
241 static u_int16_t le2hs
P_ ((u_int16_t
));
242 static u_int32_t be2hl
P_ ((u_int32_t
));
243 static int wav_init
P_ ((struct sound
*));
244 static void wav_play
P_ ((struct sound
*, struct sound_device
*));
245 static int au_init
P_ ((struct sound
*));
246 static void au_play
P_ ((struct sound
*, struct sound_device
*));
248 #if 0 /* Currently not used. */
249 static u_int16_t be2hs
P_ ((u_int16_t
));
254 /***********************************************************************
256 ***********************************************************************/
258 /* Like perror, but signals an error. */
264 error ("%s: %s", msg
, strerror (errno
));
268 /* Parse sound specification SOUND, and fill ATTRS with what is
269 found. Value is non-zero if SOUND Is a valid sound specification.
270 A valid sound specification is a list starting with the symbol
271 `sound'. The rest of the list is a property list which may
272 contain the following key/value pairs:
276 FILE is the sound file to play. If it isn't an absolute name,
277 it's searched under `data-directory'.
281 DATA is a string containing sound data. Either :file or :data
282 may be present, but not both.
286 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
287 If not specified, a default device is used.
291 VOL must be an integer in the range [0, 100], or a float in the
295 parse_sound (sound
, attrs
)
299 /* SOUND must be a list starting with the symbol `sound'. */
300 if (!CONSP (sound
) || !EQ (XCAR (sound
), Qsound
))
303 sound
= XCDR (sound
);
304 attrs
[SOUND_FILE
] = Fplist_get (sound
, QCfile
);
305 attrs
[SOUND_DATA
] = Fplist_get (sound
, QCdata
);
306 attrs
[SOUND_DEVICE
] = Fplist_get (sound
, QCdevice
);
307 attrs
[SOUND_VOLUME
] = Fplist_get (sound
, QCvolume
);
309 /* File name or data must be specified. */
310 if (!STRINGP (attrs
[SOUND_FILE
])
311 && !STRINGP (attrs
[SOUND_DATA
]))
314 /* Volume must be in the range 0..100 or unspecified. */
315 if (!NILP (attrs
[SOUND_VOLUME
]))
317 if (INTEGERP (attrs
[SOUND_VOLUME
]))
319 if (XINT (attrs
[SOUND_VOLUME
]) < 0
320 || XINT (attrs
[SOUND_VOLUME
]) > 100)
323 else if (FLOATP (attrs
[SOUND_VOLUME
]))
325 if (XFLOAT_DATA (attrs
[SOUND_VOLUME
]) < 0
326 || XFLOAT_DATA (attrs
[SOUND_VOLUME
]) > 1)
333 /* Device must be a string or unspecified. */
334 if (!NILP (attrs
[SOUND_DEVICE
])
335 && !STRINGP (attrs
[SOUND_DEVICE
]))
342 /* Find out the type of the sound file whose file descriptor is FD.
343 S is the sound file structure to fill in. */
349 if (!wav_init (s
) && !au_init (s
))
350 error ("Unknown sound format");
354 /* Function installed by play-sound with record_unwind_protect. */
360 if (current_sound_device
)
362 if (current_sound_device
->close
)
363 current_sound_device
->close (current_sound_device
);
364 if (current_sound
->fd
> 0)
365 emacs_close (current_sound
->fd
);
372 DEFUN ("play-sound", Fplay_sound
, Splay_sound
, 1, 1, 0,
373 "Play sound SOUND.\n\
374 SOUND is a list of the form `(sound KEYWORD VALUE...)'.\n\
375 The following keywords are recognized:\n\
377 :file FILE.- read sound data from FILE. If FILE isn't an\n\
378 absolute file name, it is searched in `data-directory'.\n\
380 :data DATA - read sound data from string DATA.\n\
382 Exactly one of :file or :data must be present.\n\
384 :volume VOL - set volume to VOL. VOL must an integer in the\n\
385 range 0..100 or a float in the range 0..1.0. If not specified,\n\
386 don't change the volume setting of the sound device.\n\
388 :device DEVICE - play sound on DEVICE. If not specified,\n\
389 a system-dependent default device name is used.")
393 Lisp_Object attrs
[SOUND_ATTR_SENTINEL
];
395 struct gcpro gcpro1
, gcpro2
;
396 struct sound_device sd
;
399 int count
= specpdl_ptr
- specpdl
;
402 GCPRO2 (sound
, file
);
403 bzero (&sd
, sizeof sd
);
404 bzero (&s
, sizeof s
);
405 current_sound_device
= &sd
;
407 record_unwind_protect (sound_cleanup
, Qnil
);
408 s
.header
= (char *) alloca (MAX_SOUND_HEADER_BYTES
);
410 /* Parse the sound specification. Give up if it is invalid. */
411 if (!parse_sound (sound
, attrs
))
412 error ("Invalid sound specification");
414 if (STRINGP (attrs
[SOUND_FILE
]))
416 /* Open the sound file. */
417 s
.fd
= openp (Fcons (Vdata_directory
, Qnil
),
418 attrs
[SOUND_FILE
], Qnil
, &file
, 0);
420 sound_perror ("Open sound file");
422 /* Read the first bytes from the file. */
423 s
.header_size
= emacs_read (s
.fd
, s
.header
, MAX_SOUND_HEADER_BYTES
);
424 if (s
.header_size
< 0)
425 sound_perror ("Reading sound file header");
429 s
.data
= attrs
[SOUND_DATA
];
430 bcopy (XSTRING (s
.data
)->data
, s
.header
,
431 min (MAX_SOUND_HEADER_BYTES
, STRING_BYTES (XSTRING (s
.data
))));
434 /* Find out the type of sound. Give up if we can't tell. */
435 find_sound_type (&s
);
437 /* Set up a device. */
438 if (STRINGP (attrs
[SOUND_DEVICE
]))
440 int len
= XSTRING (attrs
[SOUND_DEVICE
])->size
;
441 sd
.file
= (char *) alloca (len
+ 1);
442 strcpy (sd
.file
, XSTRING (attrs
[SOUND_DEVICE
])->data
);
445 if (INTEGERP (attrs
[SOUND_VOLUME
]))
446 sd
.volume
= XFASTINT (attrs
[SOUND_VOLUME
]);
447 else if (FLOATP (attrs
[SOUND_VOLUME
]))
448 sd
.volume
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]) * 100;
450 args
[0] = Qplay_sound_functions
;
452 Frun_hook_with_args (2, args
);
454 /* There is only one type of device we currently support, the VOX
455 sound driver. Set up the device interface functions for that
459 /* Open the device. */
462 /* Play the sound. */
465 /* Close the input file, if any. */
466 if (!STRINGP (s
.data
))
472 /* Close the device. */
476 current_sound_device
= NULL
;
477 current_sound
= NULL
;
479 unbind_to (count
, Qnil
);
484 /***********************************************************************
485 Byte-order Conversion
486 ***********************************************************************/
488 /* Convert 32-bit value VALUE which is in little-endian byte-order
489 to host byte-order. */
495 #ifdef WORDS_BIG_ENDIAN
496 unsigned char *p
= (unsigned char *) &value
;
497 value
= p
[0] + (p
[1] << 8) + (p
[2] << 16) + (p
[3] << 24);
503 /* Convert 16-bit value VALUE which is in little-endian byte-order
504 to host byte-order. */
510 #ifdef WORDS_BIG_ENDIAN
511 unsigned char *p
= (unsigned char *) &value
;
512 value
= p
[0] + (p
[1] << 8);
518 /* Convert 32-bit value VALUE which is in big-endian byte-order
519 to host byte-order. */
525 #ifndef WORDS_BIG_ENDIAN
526 unsigned char *p
= (unsigned char *) &value
;
527 value
= p
[3] + (p
[2] << 8) + (p
[1] << 16) + (p
[0] << 24);
533 #if 0 /* Currently not used. */
535 /* Convert 16-bit value VALUE which is in big-endian byte-order
536 to host byte-order. */
542 #ifndef WORDS_BIG_ENDIAN
543 unsigned char *p
= (unsigned char *) &value
;
544 value
= p
[1] + (p
[0] << 8);
552 /***********************************************************************
554 ***********************************************************************/
556 /* Try to initialize sound file S from S->header. S->header
557 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
558 sound file. If the file is a WAV-format file, set up interface
559 functions in S and convert header fields to host byte-order.
560 Value is non-zero if the file is a WAV file. */
566 struct wav_header
*header
= (struct wav_header
*) s
->header
;
568 if (s
->header_size
< sizeof *header
569 || bcmp (s
->header
, "RIFF", 4) != 0)
572 /* WAV files are in little-endian order. Convert the header
573 if on a big-endian machine. */
574 header
->magic
= le2hl (header
->magic
);
575 header
->length
= le2hl (header
->length
);
576 header
->chunk_type
= le2hl (header
->chunk_type
);
577 header
->chunk_format
= le2hl (header
->chunk_format
);
578 header
->chunk_length
= le2hl (header
->chunk_length
);
579 header
->format
= le2hs (header
->format
);
580 header
->channels
= le2hs (header
->channels
);
581 header
->sample_rate
= le2hl (header
->sample_rate
);
582 header
->bytes_per_second
= le2hl (header
->bytes_per_second
);
583 header
->sample_size
= le2hs (header
->sample_size
);
584 header
->precision
= le2hs (header
->precision
);
585 header
->chunk_data
= le2hl (header
->chunk_data
);
586 header
->data_length
= le2hl (header
->data_length
);
588 /* Set up the interface functions for WAV. */
596 /* Play RIFF-WAVE audio file S on sound device SD. */
601 struct sound_device
*sd
;
603 struct wav_header
*header
= (struct wav_header
*) s
->header
;
605 /* Let the device choose a suitable device-dependent format
607 sd
->choose_format (sd
, s
);
609 /* Configure the device. */
610 sd
->sample_size
= header
->sample_size
;
611 sd
->sample_rate
= header
->sample_rate
;
612 sd
->bps
= header
->bytes_per_second
;
613 sd
->channels
= header
->channels
;
616 /* Copy sound data to the device. The WAV file specification is
617 actually more complex. This simple scheme worked with all WAV
618 files I found so far. If someone feels inclined to implement the
619 whole RIFF-WAVE spec, please do. */
620 if (STRINGP (s
->data
))
621 sd
->write (sd
, XSTRING (s
->data
)->data
+ sizeof *header
,
622 STRING_BYTES (XSTRING (s
->data
)) - sizeof *header
);
629 buffer
= (char *) alloca (blksize
);
630 lseek (s
->fd
, sizeof *header
, SEEK_SET
);
632 while ((nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
633 sd
->write (sd
, buffer
, nbytes
);
636 sound_perror ("Reading sound file");
642 /***********************************************************************
644 ***********************************************************************/
646 /* Sun audio file encodings. */
650 AU_ENCODING_ULAW_8
= 1,
661 /* Try to initialize sound file S from S->header. S->header
662 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
663 sound file. If the file is a AU-format file, set up interface
664 functions in S and convert header fields to host byte-order.
665 Value is non-zero if the file is an AU file. */
671 struct au_header
*header
= (struct au_header
*) s
->header
;
673 if (s
->header_size
< sizeof *header
674 || bcmp (s
->header
, ".snd", 4) != 0)
677 header
->magic_number
= be2hl (header
->magic_number
);
678 header
->data_offset
= be2hl (header
->data_offset
);
679 header
->data_size
= be2hl (header
->data_size
);
680 header
->encoding
= be2hl (header
->encoding
);
681 header
->sample_rate
= be2hl (header
->sample_rate
);
682 header
->channels
= be2hl (header
->channels
);
684 /* Set up the interface functions for AU. */
692 /* Play Sun audio file S on sound device SD. */
697 struct sound_device
*sd
;
699 struct au_header
*header
= (struct au_header
*) s
->header
;
702 sd
->sample_rate
= header
->sample_rate
;
704 sd
->channels
= header
->channels
;
705 sd
->choose_format (sd
, s
);
708 if (STRINGP (s
->data
))
709 sd
->write (sd
, XSTRING (s
->data
)->data
+ header
->data_offset
,
710 STRING_BYTES (XSTRING (s
->data
)) - header
->data_offset
);
718 lseek (s
->fd
, header
->data_offset
, SEEK_SET
);
720 /* Copy sound data to the device. */
721 buffer
= (char *) alloca (blksize
);
722 while ((nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
723 sd
->write (sd
, buffer
, nbytes
);
726 sound_perror ("Reading sound file");
732 /***********************************************************************
733 Voxware Driver Interface
734 ***********************************************************************/
736 /* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
737 has a compatible own driver aka Luigi's driver. */
740 /* Open device SD. If SD->file is non-null, open that device,
741 otherwise use a default device name. */
745 struct sound_device
*sd
;
749 /* Open the sound device. Default is /dev/dsp. */
753 file
= DEFAULT_SOUND_DEVICE
;
755 sd
->fd
= emacs_open (file
, O_WRONLY
, 0);
761 /* Configure device SD from parameters in it. */
765 struct sound_device
*sd
;
769 xassert (sd
->fd
>= 0);
771 /* On GNU/Linux, it seems that the device driver doesn't like to be
772 interrupted by a signal. Block the ones we know to cause
776 sigblock (sigmask (SIGIO
));
780 if (ioctl (sd
->fd
, SNDCTL_DSP_SETFMT
, &sd
->format
) < 0
781 || val
!= sd
->format
)
782 sound_perror ("Set sound format");
784 val
= sd
->channels
!= 1;
785 if (ioctl (sd
->fd
, SNDCTL_DSP_STEREO
, &val
) < 0
786 || val
!= (sd
->channels
!= 1))
787 sound_perror ("Set stereo/mono");
789 /* I think bps and sampling_rate are the same, but who knows.
790 Check this. and use SND_DSP_SPEED for both. */
791 if (sd
->sample_rate
> 0)
793 val
= sd
->sample_rate
;
794 if (ioctl (sd
->fd
, SNDCTL_DSP_SPEED
, &sd
->sample_rate
) < 0
795 || val
!= sd
->sample_rate
)
796 sound_perror ("Set sound speed");
801 int volume
= sd
->volume
& 0xff;
802 volume
|= volume
<< 8;
803 /* This may fail if there is no mixer. Ignore the failure. */
804 ioctl (sd
->fd
, SOUND_MIXER_WRITE_PCM
, &volume
);
809 sigunblock (sigmask (SIGIO
));
814 /* Close device SD if it is open. */
818 struct sound_device
*sd
;
822 /* On GNU/Linux, it seems that the device driver doesn't like to
823 be interrupted by a signal. Block the ones we know to cause
826 sigblock (sigmask (SIGIO
));
830 /* Flush sound data, and reset the device. */
831 ioctl (sd
->fd
, SNDCTL_DSP_SYNC
, NULL
);
835 sigunblock (sigmask (SIGIO
));
838 /* Close the device. */
839 emacs_close (sd
->fd
);
845 /* Choose device-dependent format for device SD from sound file S. */
848 vox_choose_format (sd
, s
)
849 struct sound_device
*sd
;
854 struct wav_header
*h
= (struct wav_header
*) s
->header
;
855 if (h
->precision
== 8)
856 sd
->format
= AFMT_U8
;
857 else if (h
->precision
== 16)
858 sd
->format
= AFMT_S16_LE
;
860 error ("Unsupported WAV file format");
862 else if (s
->type
== SUN_AUDIO
)
864 struct au_header
*header
= (struct au_header
*) s
->header
;
865 switch (header
->encoding
)
867 case AU_ENCODING_ULAW_8
:
868 case AU_ENCODING_IEEE32
:
869 case AU_ENCODING_IEEE64
:
870 sd
->format
= AFMT_MU_LAW
;
877 sd
->format
= AFMT_S16_LE
;
881 error ("Unsupported AU file format");
889 /* Initialize device SD. Set up the interface functions in the device
894 struct sound_device
*sd
;
898 sd
->close
= vox_close
;
899 sd
->configure
= vox_configure
;
900 sd
->choose_format
= vox_choose_format
;
901 sd
->write
= vox_write
;
905 /* Write NBYTES bytes from BUFFER to device SD. */
908 vox_write (sd
, buffer
, nbytes
)
909 struct sound_device
*sd
;
913 int nwritten
= emacs_write (sd
->fd
, buffer
, nbytes
);
915 sound_perror ("Writing to sound device");
920 /***********************************************************************
922 ***********************************************************************/
927 QCdevice
= intern (":device");
928 staticpro (&QCdevice
);
929 QCvolume
= intern (":volume");
930 staticpro (&QCvolume
);
931 Qsound
= intern ("sound");
933 Qplay_sound_functions
= intern ("play-sound-functions");
934 staticpro (&Qplay_sound_functions
);
936 defsubr (&Splay_sound
);
945 #endif /* HAVE_SOUND */