Merge from emacs-23; up to 2010-06-22T07:41:10Z!rgm@gnu.org
[emacs.git] / src / sound.c
blob362c04b7d4089b10c1996fa61a773a0f474bce98
1 /* sound.c -- sound support.
2 Copyright (C) 1998-1999, 2001-2011 Free Software Foundation, Inc.
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 3 of the License, or
9 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
19 /* Written by Gerd Moellmann <gerd@gnu.org>. Tested with Luigi's
20 driver on FreeBSD 2.2.7 with a SoundBlaster 16. */
23 Modified by Ben Key <Bkey1@tampabay.rr.com> to add a partial
24 implementation of the play-sound specification for Windows.
26 Notes:
27 In the Windows implementation of play-sound-internal only the
28 :file and :volume keywords are supported. The :device keyword,
29 if present, is ignored. The :data keyword, if present, will
30 cause an error to be generated.
32 The Windows implementation of play-sound is implemented via the
33 Win32 API functions mciSendString, waveOutGetVolume, and
34 waveOutSetVolume which are exported by Winmm.dll.
37 #include <config.h>
39 #if defined HAVE_SOUND
41 /* BEGIN: Common Includes */
42 #include <fcntl.h>
43 #include <unistd.h>
44 #include <sys/types.h>
45 #include <errno.h>
46 #include <setjmp.h>
47 #include "lisp.h"
48 #include "dispextern.h"
49 #include "atimer.h"
50 #include <signal.h>
51 #include "syssignal.h"
52 /* END: Common Includes */
55 /* BEGIN: Non Windows Includes */
56 #ifndef WINDOWSNT
58 #include <sys/ioctl.h>
60 /* FreeBSD has machine/soundcard.h. Voxware sound driver docs mention
61 sys/soundcard.h. So, let's try whatever's there. */
63 #ifdef HAVE_MACHINE_SOUNDCARD_H
64 #include <machine/soundcard.h>
65 #endif
66 #ifdef HAVE_SYS_SOUNDCARD_H
67 #include <sys/soundcard.h>
68 #endif
69 #ifdef HAVE_SOUNDCARD_H
70 #include <soundcard.h>
71 #endif
72 #ifdef HAVE_ALSA
73 #ifdef ALSA_SUBDIR_INCLUDE
74 #include <alsa/asoundlib.h>
75 #else
76 #include <asoundlib.h>
77 #endif /* ALSA_SUBDIR_INCLUDE */
78 #endif /* HAVE_ALSA */
80 /* END: Non Windows Includes */
82 #else /* WINDOWSNT */
84 /* BEGIN: Windows Specific Includes */
85 #include <stdio.h>
86 #include <limits.h>
87 #include <windows.h>
88 #include <mmsystem.h>
89 /* END: Windows Specific Includes */
91 #endif /* WINDOWSNT */
93 /* BEGIN: Common Definitions */
95 /* Symbols. */
97 static Lisp_Object QCvolume, QCdevice;
98 static Lisp_Object Qsound;
99 static Lisp_Object Qplay_sound_functions;
101 /* Indices of attributes in a sound attributes vector. */
103 enum sound_attr
105 SOUND_FILE,
106 SOUND_DATA,
107 SOUND_DEVICE,
108 SOUND_VOLUME,
109 SOUND_ATTR_SENTINEL
112 #ifdef HAVE_ALSA
113 static void alsa_sound_perror (const char *, int) NO_RETURN;
114 #endif
115 static void sound_perror (const char *) NO_RETURN;
116 static void sound_warning (const char *);
117 static int parse_sound (Lisp_Object, Lisp_Object *);
119 /* END: Common Definitions */
121 /* BEGIN: Non Windows Definitions */
122 #ifndef WINDOWSNT
124 #ifndef DEFAULT_SOUND_DEVICE
125 #define DEFAULT_SOUND_DEVICE "/dev/dsp"
126 #endif
127 #ifndef DEFAULT_ALSA_SOUND_DEVICE
128 #define DEFAULT_ALSA_SOUND_DEVICE "default"
129 #endif
132 /* Structure forward declarations. */
134 struct sound;
135 struct sound_device;
137 /* The file header of RIFF-WAVE files (*.wav). Files are always in
138 little-endian byte-order. */
140 struct wav_header
142 u_int32_t magic;
143 u_int32_t length;
144 u_int32_t chunk_type;
145 u_int32_t chunk_format;
146 u_int32_t chunk_length;
147 u_int16_t format;
148 u_int16_t channels;
149 u_int32_t sample_rate;
150 u_int32_t bytes_per_second;
151 u_int16_t sample_size;
152 u_int16_t precision;
153 u_int32_t chunk_data;
154 u_int32_t data_length;
157 /* The file header of Sun adio files (*.au). Files are always in
158 big-endian byte-order. */
160 struct au_header
162 /* ASCII ".snd" */
163 u_int32_t magic_number;
165 /* Offset of data part from start of file. Minimum value is 24. */
166 u_int32_t data_offset;
168 /* Size of data part, 0xffffffff if unknown. */
169 u_int32_t data_size;
171 /* Data encoding format.
172 1 8-bit ISDN u-law
173 2 8-bit linear PCM (REF-PCM)
174 3 16-bit linear PCM
175 4 24-bit linear PCM
176 5 32-bit linear PCM
177 6 32-bit IEEE floating-point
178 7 64-bit IEEE floating-point
179 23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
180 encoding scheme. */
181 u_int32_t encoding;
183 /* Number of samples per second. */
184 u_int32_t sample_rate;
186 /* Number of interleaved channels. */
187 u_int32_t channels;
190 /* Maximum of all sound file headers sizes. */
192 #define MAX_SOUND_HEADER_BYTES \
193 max (sizeof (struct wav_header), sizeof (struct au_header))
195 /* Interface structure for sound devices. */
197 struct sound_device
199 /* The name of the device or null meaning use a default device name. */
200 char *file;
202 /* File descriptor of the device. */
203 int fd;
205 /* Device-dependent format. */
206 int format;
208 /* Volume (0..100). Zero means unspecified. */
209 int volume;
211 /* Sample size. */
212 int sample_size;
214 /* Sample rate. */
215 int sample_rate;
217 /* Bytes per second. */
218 int bps;
220 /* 1 = mono, 2 = stereo, 0 = don't set. */
221 int channels;
223 /* Open device SD. */
224 void (* open) (struct sound_device *sd);
226 /* Close device SD. */
227 void (* close) (struct sound_device *sd);
229 /* Configure SD accoring to device-dependent parameters. */
230 void (* configure) (struct sound_device *device);
232 /* Choose a device-dependent format for outputting sound S. */
233 void (* choose_format) (struct sound_device *sd,
234 struct sound *s);
236 /* Return a preferred data size in bytes to be sent to write (below)
237 each time. 2048 is used if this is NULL. */
238 EMACS_INT (* period_size) (struct sound_device *sd);
240 /* Write NYBTES bytes from BUFFER to device SD. */
241 void (* write) (struct sound_device *sd, const char *buffer,
242 EMACS_INT nbytes);
244 /* A place for devices to store additional data. */
245 void *data;
248 /* An enumerator for each supported sound file type. */
250 enum sound_type
252 RIFF,
253 SUN_AUDIO
256 /* Interface structure for sound files. */
258 struct sound
260 /* The type of the file. */
261 enum sound_type type;
263 /* File descriptor of a sound file. */
264 int fd;
266 /* Pointer to sound file header. This contains header_size bytes
267 read from the start of a sound file. */
268 char *header;
270 /* Number of bytes raed from sound file. This is always <=
271 MAX_SOUND_HEADER_BYTES. */
272 int header_size;
274 /* Sound data, if a string. */
275 Lisp_Object data;
277 /* Play sound file S on device SD. */
278 void (* play) (struct sound *s, struct sound_device *sd);
281 /* These are set during `play-sound-internal' so that sound_cleanup has
282 access to them. */
284 static struct sound_device *current_sound_device;
285 static struct sound *current_sound;
287 /* Function prototypes. */
289 static void vox_open (struct sound_device *);
290 static void vox_configure (struct sound_device *);
291 static void vox_close (struct sound_device *sd);
292 static void vox_choose_format (struct sound_device *, struct sound *);
293 static int vox_init (struct sound_device *);
294 static void vox_write (struct sound_device *, const char *, EMACS_INT);
295 static void find_sound_type (struct sound *);
296 static u_int32_t le2hl (u_int32_t);
297 static u_int16_t le2hs (u_int16_t);
298 static u_int32_t be2hl (u_int32_t);
299 static int wav_init (struct sound *);
300 static void wav_play (struct sound *, struct sound_device *);
301 static int au_init (struct sound *);
302 static void au_play (struct sound *, struct sound_device *);
304 #if 0 /* Currently not used. */
305 static u_int16_t be2hs (u_int16_t);
306 #endif
308 /* END: Non Windows Definitions */
309 #else /* WINDOWSNT */
311 /* BEGIN: Windows Specific Definitions */
312 static int do_play_sound (const char *, unsigned long);
314 END: Windows Specific Definitions */
315 #endif /* WINDOWSNT */
318 /***********************************************************************
319 General
320 ***********************************************************************/
322 /* BEGIN: Common functions */
324 /* Like perror, but signals an error. */
326 static void
327 sound_perror (const char *msg)
329 int saved_errno = errno;
331 turn_on_atimers (1);
332 #ifdef SIGIO
333 sigunblock (sigmask (SIGIO));
334 #endif
335 if (saved_errno != 0)
336 error ("%s: %s", msg, strerror (saved_errno));
337 else
338 error ("%s", msg);
342 /* Display a warning message. */
344 static void
345 sound_warning (const char *msg)
347 message ("%s", msg);
351 /* Parse sound specification SOUND, and fill ATTRS with what is
352 found. Value is non-zero if SOUND Is a valid sound specification.
353 A valid sound specification is a list starting with the symbol
354 `sound'. The rest of the list is a property list which may
355 contain the following key/value pairs:
357 - `:file FILE'
359 FILE is the sound file to play. If it isn't an absolute name,
360 it's searched under `data-directory'.
362 - `:data DATA'
364 DATA is a string containing sound data. Either :file or :data
365 may be present, but not both.
367 - `:device DEVICE'
369 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
370 If not specified, a default device is used.
372 - `:volume VOL'
374 VOL must be an integer in the range [0, 100], or a float in the
375 range [0, 1]. */
377 static int
378 parse_sound (Lisp_Object sound, Lisp_Object *attrs)
380 /* SOUND must be a list starting with the symbol `sound'. */
381 if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
382 return 0;
384 sound = XCDR (sound);
385 attrs[SOUND_FILE] = Fplist_get (sound, QCfile);
386 attrs[SOUND_DATA] = Fplist_get (sound, QCdata);
387 attrs[SOUND_DEVICE] = Fplist_get (sound, QCdevice);
388 attrs[SOUND_VOLUME] = Fplist_get (sound, QCvolume);
390 #ifndef WINDOWSNT
391 /* File name or data must be specified. */
392 if (!STRINGP (attrs[SOUND_FILE])
393 && !STRINGP (attrs[SOUND_DATA]))
394 return 0;
395 #else /* WINDOWSNT */
397 Data is not supported in Windows. Therefore a
398 File name MUST be supplied.
400 if (!STRINGP (attrs[SOUND_FILE]))
402 return 0;
404 #endif /* WINDOWSNT */
406 /* Volume must be in the range 0..100 or unspecified. */
407 if (!NILP (attrs[SOUND_VOLUME]))
409 if (INTEGERP (attrs[SOUND_VOLUME]))
411 if (XINT (attrs[SOUND_VOLUME]) < 0
412 || XINT (attrs[SOUND_VOLUME]) > 100)
413 return 0;
415 else if (FLOATP (attrs[SOUND_VOLUME]))
417 if (XFLOAT_DATA (attrs[SOUND_VOLUME]) < 0
418 || XFLOAT_DATA (attrs[SOUND_VOLUME]) > 1)
419 return 0;
421 else
422 return 0;
425 #ifndef WINDOWSNT
426 /* Device must be a string or unspecified. */
427 if (!NILP (attrs[SOUND_DEVICE])
428 && !STRINGP (attrs[SOUND_DEVICE]))
429 return 0;
430 #endif /* WINDOWSNT */
432 Since device is ignored in Windows, it does not matter
433 what it is.
435 return 1;
438 /* END: Common functions */
440 /* BEGIN: Non Windows functions */
441 #ifndef WINDOWSNT
443 /* Find out the type of the sound file whose file descriptor is FD.
444 S is the sound file structure to fill in. */
446 static void
447 find_sound_type (struct sound *s)
449 if (!wav_init (s) && !au_init (s))
450 error ("Unknown sound format");
454 /* Function installed by play-sound-internal with record_unwind_protect. */
456 static Lisp_Object
457 sound_cleanup (Lisp_Object arg)
459 if (current_sound_device->close)
460 current_sound_device->close (current_sound_device);
461 if (current_sound->fd > 0)
462 emacs_close (current_sound->fd);
463 xfree (current_sound_device);
464 xfree (current_sound);
466 return Qnil;
469 /***********************************************************************
470 Byte-order Conversion
471 ***********************************************************************/
473 /* Convert 32-bit value VALUE which is in little-endian byte-order
474 to host byte-order. */
476 static u_int32_t
477 le2hl (u_int32_t value)
479 #ifdef WORDS_BIGENDIAN
480 unsigned char *p = (unsigned char *) &value;
481 value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
482 #endif
483 return value;
487 /* Convert 16-bit value VALUE which is in little-endian byte-order
488 to host byte-order. */
490 static u_int16_t
491 le2hs (u_int16_t value)
493 #ifdef WORDS_BIGENDIAN
494 unsigned char *p = (unsigned char *) &value;
495 value = p[0] + (p[1] << 8);
496 #endif
497 return value;
501 /* Convert 32-bit value VALUE which is in big-endian byte-order
502 to host byte-order. */
504 static u_int32_t
505 be2hl (u_int32_t value)
507 #ifndef WORDS_BIGENDIAN
508 unsigned char *p = (unsigned char *) &value;
509 value = p[3] + (p[2] << 8) + (p[1] << 16) + (p[0] << 24);
510 #endif
511 return value;
515 #if 0 /* Currently not used. */
517 /* Convert 16-bit value VALUE which is in big-endian byte-order
518 to host byte-order. */
520 static u_int16_t
521 be2hs (u_int16_t value)
523 #ifndef WORDS_BIGENDIAN
524 unsigned char *p = (unsigned char *) &value;
525 value = p[1] + (p[0] << 8);
526 #endif
527 return value;
530 #endif /* 0 */
532 /***********************************************************************
533 RIFF-WAVE (*.wav)
534 ***********************************************************************/
536 /* Try to initialize sound file S from S->header. S->header
537 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
538 sound file. If the file is a WAV-format file, set up interface
539 functions in S and convert header fields to host byte-order.
540 Value is non-zero if the file is a WAV file. */
542 static int
543 wav_init (struct sound *s)
545 struct wav_header *header = (struct wav_header *) s->header;
547 if (s->header_size < sizeof *header
548 || memcmp (s->header, "RIFF", 4) != 0)
549 return 0;
551 /* WAV files are in little-endian order. Convert the header
552 if on a big-endian machine. */
553 header->magic = le2hl (header->magic);
554 header->length = le2hl (header->length);
555 header->chunk_type = le2hl (header->chunk_type);
556 header->chunk_format = le2hl (header->chunk_format);
557 header->chunk_length = le2hl (header->chunk_length);
558 header->format = le2hs (header->format);
559 header->channels = le2hs (header->channels);
560 header->sample_rate = le2hl (header->sample_rate);
561 header->bytes_per_second = le2hl (header->bytes_per_second);
562 header->sample_size = le2hs (header->sample_size);
563 header->precision = le2hs (header->precision);
564 header->chunk_data = le2hl (header->chunk_data);
565 header->data_length = le2hl (header->data_length);
567 /* Set up the interface functions for WAV. */
568 s->type = RIFF;
569 s->play = wav_play;
571 return 1;
575 /* Play RIFF-WAVE audio file S on sound device SD. */
577 static void
578 wav_play (struct sound *s, struct sound_device *sd)
580 struct wav_header *header = (struct wav_header *) s->header;
582 /* Let the device choose a suitable device-dependent format
583 for the file. */
584 sd->choose_format (sd, s);
586 /* Configure the device. */
587 sd->sample_size = header->sample_size;
588 sd->sample_rate = header->sample_rate;
589 sd->bps = header->bytes_per_second;
590 sd->channels = header->channels;
591 sd->configure (sd);
593 /* Copy sound data to the device. The WAV file specification is
594 actually more complex. This simple scheme worked with all WAV
595 files I found so far. If someone feels inclined to implement the
596 whole RIFF-WAVE spec, please do. */
597 if (STRINGP (s->data))
598 sd->write (sd, SSDATA (s->data) + sizeof *header,
599 SBYTES (s->data) - sizeof *header);
600 else
602 char *buffer;
603 EMACS_INT nbytes = 0;
604 EMACS_INT blksize = sd->period_size ? sd->period_size (sd) : 2048;
605 EMACS_INT data_left = header->data_length;
607 buffer = (char *) alloca (blksize);
608 lseek (s->fd, sizeof *header, SEEK_SET);
609 while (data_left > 0
610 && (nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
612 /* Don't play possible garbage at the end of file */
613 if (data_left < nbytes) nbytes = data_left;
614 data_left -= nbytes;
615 sd->write (sd, buffer, nbytes);
618 if (nbytes < 0)
619 sound_perror ("Error reading sound file");
624 /***********************************************************************
625 Sun Audio (*.au)
626 ***********************************************************************/
628 /* Sun audio file encodings. */
630 enum au_encoding
632 AU_ENCODING_ULAW_8 = 1,
633 AU_ENCODING_8,
634 AU_ENCODING_16,
635 AU_ENCODING_24,
636 AU_ENCODING_32,
637 AU_ENCODING_IEEE32,
638 AU_ENCODING_IEEE64,
639 AU_COMPRESSED = 23,
640 AU_ENCODING_ALAW_8 = 27
644 /* Try to initialize sound file S from S->header. S->header
645 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
646 sound file. If the file is a AU-format file, set up interface
647 functions in S and convert header fields to host byte-order.
648 Value is non-zero if the file is an AU file. */
650 static int
651 au_init (struct sound *s)
653 struct au_header *header = (struct au_header *) s->header;
655 if (s->header_size < sizeof *header
656 || memcmp (s->header, ".snd", 4) != 0)
657 return 0;
659 header->magic_number = be2hl (header->magic_number);
660 header->data_offset = be2hl (header->data_offset);
661 header->data_size = be2hl (header->data_size);
662 header->encoding = be2hl (header->encoding);
663 header->sample_rate = be2hl (header->sample_rate);
664 header->channels = be2hl (header->channels);
666 /* Set up the interface functions for AU. */
667 s->type = SUN_AUDIO;
668 s->play = au_play;
670 return 1;
674 /* Play Sun audio file S on sound device SD. */
676 static void
677 au_play (struct sound *s, struct sound_device *sd)
679 struct au_header *header = (struct au_header *) s->header;
681 sd->sample_size = 0;
682 sd->sample_rate = header->sample_rate;
683 sd->bps = 0;
684 sd->channels = header->channels;
685 sd->choose_format (sd, s);
686 sd->configure (sd);
688 if (STRINGP (s->data))
689 sd->write (sd, SSDATA (s->data) + header->data_offset,
690 SBYTES (s->data) - header->data_offset);
691 else
693 EMACS_INT blksize = sd->period_size ? sd->period_size (sd) : 2048;
694 char *buffer;
695 EMACS_INT nbytes;
697 /* Seek */
698 lseek (s->fd, header->data_offset, SEEK_SET);
700 /* Copy sound data to the device. */
701 buffer = (char *) alloca (blksize);
702 while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
703 sd->write (sd, buffer, nbytes);
705 if (nbytes < 0)
706 sound_perror ("Error reading sound file");
711 /***********************************************************************
712 Voxware Driver Interface
713 ***********************************************************************/
715 /* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
716 has a compatible own driver aka Luigi's driver. */
719 /* Open device SD. If SD->file is non-null, open that device,
720 otherwise use a default device name. */
722 static void
723 vox_open (struct sound_device *sd)
725 const char *file;
727 /* Open the sound device. Default is /dev/dsp. */
728 if (sd->file)
729 file = sd->file;
730 else
731 file = DEFAULT_SOUND_DEVICE;
733 sd->fd = emacs_open (file, O_WRONLY, 0);
734 if (sd->fd < 0)
735 sound_perror (file);
739 /* Configure device SD from parameters in it. */
741 static void
742 vox_configure (struct sound_device *sd)
744 int val;
746 xassert (sd->fd >= 0);
748 /* On GNU/Linux, it seems that the device driver doesn't like to be
749 interrupted by a signal. Block the ones we know to cause
750 troubles. */
751 turn_on_atimers (0);
752 #ifdef SIGIO
753 sigblock (sigmask (SIGIO));
754 #endif
756 val = sd->format;
757 if (ioctl (sd->fd, SNDCTL_DSP_SETFMT, &sd->format) < 0
758 || val != sd->format)
759 sound_perror ("Could not set sound format");
761 val = sd->channels != 1;
762 if (ioctl (sd->fd, SNDCTL_DSP_STEREO, &val) < 0
763 || val != (sd->channels != 1))
764 sound_perror ("Could not set stereo/mono");
766 /* I think bps and sampling_rate are the same, but who knows.
767 Check this. and use SND_DSP_SPEED for both. */
768 if (sd->sample_rate > 0)
770 val = sd->sample_rate;
771 if (ioctl (sd->fd, SNDCTL_DSP_SPEED, &sd->sample_rate) < 0)
772 sound_perror ("Could not set sound speed");
773 else if (val != sd->sample_rate)
774 sound_warning ("Could not set sample rate");
777 if (sd->volume > 0)
779 int volume = sd->volume & 0xff;
780 volume |= volume << 8;
781 /* This may fail if there is no mixer. Ignore the failure. */
782 ioctl (sd->fd, SOUND_MIXER_WRITE_PCM, &volume);
785 turn_on_atimers (1);
786 #ifdef SIGIO
787 sigunblock (sigmask (SIGIO));
788 #endif
792 /* Close device SD if it is open. */
794 static void
795 vox_close (struct sound_device *sd)
797 if (sd->fd >= 0)
799 /* On GNU/Linux, it seems that the device driver doesn't like to
800 be interrupted by a signal. Block the ones we know to cause
801 troubles. */
802 #ifdef SIGIO
803 sigblock (sigmask (SIGIO));
804 #endif
805 turn_on_atimers (0);
807 /* Flush sound data, and reset the device. */
808 ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL);
810 turn_on_atimers (1);
811 #ifdef SIGIO
812 sigunblock (sigmask (SIGIO));
813 #endif
815 /* Close the device. */
816 emacs_close (sd->fd);
817 sd->fd = -1;
822 /* Choose device-dependent format for device SD from sound file S. */
824 static void
825 vox_choose_format (struct sound_device *sd, struct sound *s)
827 if (s->type == RIFF)
829 struct wav_header *h = (struct wav_header *) s->header;
830 if (h->precision == 8)
831 sd->format = AFMT_U8;
832 else if (h->precision == 16)
833 sd->format = AFMT_S16_LE;
834 else
835 error ("Unsupported WAV file format");
837 else if (s->type == SUN_AUDIO)
839 struct au_header *header = (struct au_header *) s->header;
840 switch (header->encoding)
842 case AU_ENCODING_ULAW_8:
843 case AU_ENCODING_IEEE32:
844 case AU_ENCODING_IEEE64:
845 sd->format = AFMT_MU_LAW;
846 break;
848 case AU_ENCODING_8:
849 case AU_ENCODING_16:
850 case AU_ENCODING_24:
851 case AU_ENCODING_32:
852 sd->format = AFMT_S16_LE;
853 break;
855 default:
856 error ("Unsupported AU file format");
859 else
860 abort ();
864 /* Initialize device SD. Set up the interface functions in the device
865 structure. */
867 static int
868 vox_init (struct sound_device *sd)
870 const char *file;
871 int fd;
873 /* Open the sound device. Default is /dev/dsp. */
874 if (sd->file)
875 file = sd->file;
876 else
877 file = DEFAULT_SOUND_DEVICE;
878 fd = emacs_open (file, O_WRONLY, 0);
879 if (fd >= 0)
880 emacs_close (fd);
881 else
882 return 0;
884 sd->fd = -1;
885 sd->open = vox_open;
886 sd->close = vox_close;
887 sd->configure = vox_configure;
888 sd->choose_format = vox_choose_format;
889 sd->write = vox_write;
890 sd->period_size = NULL;
892 return 1;
895 /* Write NBYTES bytes from BUFFER to device SD. */
897 static void
898 vox_write (struct sound_device *sd, const char *buffer, EMACS_INT nbytes)
900 if (emacs_write (sd->fd, buffer, nbytes) != nbytes)
901 sound_perror ("Error writing to sound device");
904 #ifdef HAVE_ALSA
905 /***********************************************************************
906 ALSA Driver Interface
907 ***********************************************************************/
909 /* This driver is available on GNU/Linux. */
911 static void
912 alsa_sound_perror (const char *msg, int err)
914 error ("%s: %s", msg, snd_strerror (err));
917 struct alsa_params
919 snd_pcm_t *handle;
920 snd_pcm_hw_params_t *hwparams;
921 snd_pcm_sw_params_t *swparams;
922 snd_pcm_uframes_t period_size;
925 /* Open device SD. If SD->file is non-null, open that device,
926 otherwise use a default device name. */
928 static void
929 alsa_open (struct sound_device *sd)
931 const char *file;
932 struct alsa_params *p;
933 int err;
935 /* Open the sound device. Default is "default". */
936 if (sd->file)
937 file = sd->file;
938 else
939 file = DEFAULT_ALSA_SOUND_DEVICE;
941 p = xmalloc (sizeof (*p));
942 p->handle = NULL;
943 p->hwparams = NULL;
944 p->swparams = NULL;
946 sd->fd = -1;
947 sd->data = p;
950 err = snd_pcm_open (&p->handle, file, SND_PCM_STREAM_PLAYBACK, 0);
951 if (err < 0)
952 alsa_sound_perror (file, err);
955 static EMACS_INT
956 alsa_period_size (struct sound_device *sd)
958 struct alsa_params *p = (struct alsa_params *) sd->data;
959 int fact = snd_pcm_format_size (sd->format, 1) * sd->channels;
960 return p->period_size * (fact > 0 ? fact : 1);
963 static void
964 alsa_configure (struct sound_device *sd)
966 int val, err, dir;
967 unsigned uval;
968 struct alsa_params *p = (struct alsa_params *) sd->data;
969 snd_pcm_uframes_t buffer_size;
971 xassert (p->handle != 0);
973 err = snd_pcm_hw_params_malloc (&p->hwparams);
974 if (err < 0)
975 alsa_sound_perror ("Could not allocate hardware parameter structure", err);
977 err = snd_pcm_sw_params_malloc (&p->swparams);
978 if (err < 0)
979 alsa_sound_perror ("Could not allocate software parameter structure", err);
981 err = snd_pcm_hw_params_any (p->handle, p->hwparams);
982 if (err < 0)
983 alsa_sound_perror ("Could not initialize hardware parameter structure", err);
985 err = snd_pcm_hw_params_set_access (p->handle, p->hwparams,
986 SND_PCM_ACCESS_RW_INTERLEAVED);
987 if (err < 0)
988 alsa_sound_perror ("Could not set access type", err);
990 val = sd->format;
991 err = snd_pcm_hw_params_set_format (p->handle, p->hwparams, val);
992 if (err < 0)
993 alsa_sound_perror ("Could not set sound format", err);
995 uval = sd->sample_rate;
996 err = snd_pcm_hw_params_set_rate_near (p->handle, p->hwparams, &uval, 0);
997 if (err < 0)
998 alsa_sound_perror ("Could not set sample rate", err);
1000 val = sd->channels;
1001 err = snd_pcm_hw_params_set_channels (p->handle, p->hwparams, val);
1002 if (err < 0)
1003 alsa_sound_perror ("Could not set channel count", err);
1005 err = snd_pcm_hw_params (p->handle, p->hwparams);
1006 if (err < 0)
1007 alsa_sound_perror ("Could not set parameters", err);
1010 err = snd_pcm_hw_params_get_period_size (p->hwparams, &p->period_size, &dir);
1011 if (err < 0)
1012 alsa_sound_perror ("Unable to get period size for playback", err);
1014 err = snd_pcm_hw_params_get_buffer_size (p->hwparams, &buffer_size);
1015 if (err < 0)
1016 alsa_sound_perror ("Unable to get buffer size for playback", err);
1018 err = snd_pcm_sw_params_current (p->handle, p->swparams);
1019 if (err < 0)
1020 alsa_sound_perror ("Unable to determine current swparams for playback",
1021 err);
1023 /* Start the transfer when the buffer is almost full */
1024 err = snd_pcm_sw_params_set_start_threshold (p->handle, p->swparams,
1025 (buffer_size / p->period_size)
1026 * p->period_size);
1027 if (err < 0)
1028 alsa_sound_perror ("Unable to set start threshold mode for playback", err);
1030 /* Allow the transfer when at least period_size samples can be processed */
1031 err = snd_pcm_sw_params_set_avail_min (p->handle, p->swparams, p->period_size);
1032 if (err < 0)
1033 alsa_sound_perror ("Unable to set avail min for playback", err);
1035 err = snd_pcm_sw_params (p->handle, p->swparams);
1036 if (err < 0)
1037 alsa_sound_perror ("Unable to set sw params for playback\n", err);
1039 snd_pcm_hw_params_free (p->hwparams);
1040 p->hwparams = NULL;
1041 snd_pcm_sw_params_free (p->swparams);
1042 p->swparams = NULL;
1044 err = snd_pcm_prepare (p->handle);
1045 if (err < 0)
1046 alsa_sound_perror ("Could not prepare audio interface for use", err);
1048 if (sd->volume > 0)
1050 int chn;
1051 snd_mixer_t *handle;
1052 snd_mixer_elem_t *e;
1053 const char *file = sd->file ? sd->file : DEFAULT_ALSA_SOUND_DEVICE;
1055 if (snd_mixer_open (&handle, 0) >= 0)
1057 if (snd_mixer_attach (handle, file) >= 0
1058 && snd_mixer_load (handle) >= 0
1059 && snd_mixer_selem_register (handle, NULL, NULL) >= 0)
1060 for (e = snd_mixer_first_elem (handle);
1062 e = snd_mixer_elem_next (e))
1064 if (snd_mixer_selem_has_playback_volume (e))
1066 long pmin, pmax, vol;
1067 snd_mixer_selem_get_playback_volume_range (e, &pmin, &pmax);
1068 vol = pmin + (sd->volume * (pmax - pmin)) / 100;
1070 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++)
1071 snd_mixer_selem_set_playback_volume (e, chn, vol);
1074 snd_mixer_close (handle);
1080 /* Close device SD if it is open. */
1082 static void
1083 alsa_close (struct sound_device *sd)
1085 struct alsa_params *p = (struct alsa_params *) sd->data;
1086 if (p)
1088 if (p->hwparams)
1089 snd_pcm_hw_params_free (p->hwparams);
1090 if (p->swparams)
1091 snd_pcm_sw_params_free (p->swparams);
1092 if (p->handle)
1094 snd_pcm_drain (p->handle);
1095 snd_pcm_close (p->handle);
1097 xfree (p);
1101 /* Choose device-dependent format for device SD from sound file S. */
1103 static void
1104 alsa_choose_format (struct sound_device *sd, struct sound *s)
1106 if (s->type == RIFF)
1108 struct wav_header *h = (struct wav_header *) s->header;
1109 if (h->precision == 8)
1110 sd->format = SND_PCM_FORMAT_U8;
1111 else if (h->precision == 16)
1112 sd->format = SND_PCM_FORMAT_S16_LE;
1113 else
1114 error ("Unsupported WAV file format");
1116 else if (s->type == SUN_AUDIO)
1118 struct au_header *header = (struct au_header *) s->header;
1119 switch (header->encoding)
1121 case AU_ENCODING_ULAW_8:
1122 sd->format = SND_PCM_FORMAT_MU_LAW;
1123 break;
1124 case AU_ENCODING_ALAW_8:
1125 sd->format = SND_PCM_FORMAT_A_LAW;
1126 break;
1127 case AU_ENCODING_IEEE32:
1128 sd->format = SND_PCM_FORMAT_FLOAT_BE;
1129 break;
1130 case AU_ENCODING_IEEE64:
1131 sd->format = SND_PCM_FORMAT_FLOAT64_BE;
1132 break;
1133 case AU_ENCODING_8:
1134 sd->format = SND_PCM_FORMAT_S8;
1135 break;
1136 case AU_ENCODING_16:
1137 sd->format = SND_PCM_FORMAT_S16_BE;
1138 break;
1139 case AU_ENCODING_24:
1140 sd->format = SND_PCM_FORMAT_S24_BE;
1141 break;
1142 case AU_ENCODING_32:
1143 sd->format = SND_PCM_FORMAT_S32_BE;
1144 break;
1146 default:
1147 error ("Unsupported AU file format");
1150 else
1151 abort ();
1155 /* Write NBYTES bytes from BUFFER to device SD. */
1157 static void
1158 alsa_write (struct sound_device *sd, const char *buffer, EMACS_INT nbytes)
1160 struct alsa_params *p = (struct alsa_params *) sd->data;
1162 /* The the third parameter to snd_pcm_writei is frames, not bytes. */
1163 int fact = snd_pcm_format_size (sd->format, 1) * sd->channels;
1164 EMACS_INT nwritten = 0;
1165 int err;
1167 while (nwritten < nbytes)
1169 snd_pcm_uframes_t frames = (nbytes - nwritten)/fact;
1170 if (frames == 0) break;
1172 err = snd_pcm_writei (p->handle, buffer + nwritten, frames);
1173 if (err < 0)
1175 if (err == -EPIPE)
1176 { /* under-run */
1177 err = snd_pcm_prepare (p->handle);
1178 if (err < 0)
1179 alsa_sound_perror ("Can't recover from underrun, prepare failed",
1180 err);
1182 else if (err == -ESTRPIPE)
1184 while ((err = snd_pcm_resume (p->handle)) == -EAGAIN)
1185 sleep (1); /* wait until the suspend flag is released */
1186 if (err < 0)
1188 err = snd_pcm_prepare (p->handle);
1189 if (err < 0)
1190 alsa_sound_perror ("Can't recover from suspend, "
1191 "prepare failed",
1192 err);
1195 else
1196 alsa_sound_perror ("Error writing to sound device", err);
1199 else
1200 nwritten += err * fact;
1204 static void
1205 snd_error_quiet (const char *file, int line, const char *function, int err,
1206 const char *fmt)
1210 /* Initialize device SD. Set up the interface functions in the device
1211 structure. */
1213 static int
1214 alsa_init (struct sound_device *sd)
1216 const char *file;
1217 snd_pcm_t *handle;
1218 int err;
1220 /* Open the sound device. Default is "default". */
1221 if (sd->file)
1222 file = sd->file;
1223 else
1224 file = DEFAULT_ALSA_SOUND_DEVICE;
1226 snd_lib_error_set_handler ((snd_lib_error_handler_t) snd_error_quiet);
1227 err = snd_pcm_open (&handle, file, SND_PCM_STREAM_PLAYBACK, 0);
1228 snd_lib_error_set_handler (NULL);
1229 if (err < 0)
1230 return 0;
1231 snd_pcm_close (handle);
1233 sd->fd = -1;
1234 sd->open = alsa_open;
1235 sd->close = alsa_close;
1236 sd->configure = alsa_configure;
1237 sd->choose_format = alsa_choose_format;
1238 sd->write = alsa_write;
1239 sd->period_size = alsa_period_size;
1241 return 1;
1244 #endif /* HAVE_ALSA */
1247 /* END: Non Windows functions */
1248 #else /* WINDOWSNT */
1250 /* BEGIN: Windows specific functions */
1252 #define SOUND_WARNING(fun, error, text) \
1254 char buf[1024]; \
1255 char err_string[MAXERRORLENGTH]; \
1256 fun (error, err_string, sizeof (err_string)); \
1257 _snprintf (buf, sizeof (buf), "%s\nError: %s", \
1258 text, err_string); \
1259 sound_warning (buf); \
1262 static int
1263 do_play_sound (const char *psz_file, unsigned long ui_volume)
1265 int i_result = 0;
1266 MCIERROR mci_error = 0;
1267 char sz_cmd_buf[520] = {0};
1268 char sz_ret_buf[520] = {0};
1269 MMRESULT mm_result = MMSYSERR_NOERROR;
1270 unsigned long ui_volume_org = 0;
1271 BOOL b_reset_volume = FALSE;
1273 memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1274 memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1275 sprintf (sz_cmd_buf,
1276 "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
1277 psz_file);
1278 mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1279 if (mci_error != 0)
1281 SOUND_WARNING (mciGetErrorString, mci_error,
1282 "The open mciSendString command failed to open "
1283 "the specified sound file.");
1284 i_result = (int) mci_error;
1285 return i_result;
1287 if ((ui_volume > 0) && (ui_volume != UINT_MAX))
1289 mm_result = waveOutGetVolume ((HWAVEOUT) WAVE_MAPPER, &ui_volume_org);
1290 if (mm_result == MMSYSERR_NOERROR)
1292 b_reset_volume = TRUE;
1293 mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume);
1294 if (mm_result != MMSYSERR_NOERROR)
1296 SOUND_WARNING (waveOutGetErrorText, mm_result,
1297 "waveOutSetVolume failed to set the volume level "
1298 "of the WAVE_MAPPER device.\n"
1299 "As a result, the user selected volume level will "
1300 "not be used.");
1303 else
1305 SOUND_WARNING (waveOutGetErrorText, mm_result,
1306 "waveOutGetVolume failed to obtain the original "
1307 "volume level of the WAVE_MAPPER device.\n"
1308 "As a result, the user selected volume level will "
1309 "not be used.");
1312 memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1313 memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1314 strcpy (sz_cmd_buf, "play GNUEmacs_PlaySound_Device wait");
1315 mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1316 if (mci_error != 0)
1318 SOUND_WARNING (mciGetErrorString, mci_error,
1319 "The play mciSendString command failed to play the "
1320 "opened sound file.");
1321 i_result = (int) mci_error;
1323 memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1324 memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1325 strcpy (sz_cmd_buf, "close GNUEmacs_PlaySound_Device wait");
1326 mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1327 if (b_reset_volume == TRUE)
1329 mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume_org);
1330 if (mm_result != MMSYSERR_NOERROR)
1332 SOUND_WARNING (waveOutGetErrorText, mm_result,
1333 "waveOutSetVolume failed to reset the original volume "
1334 "level of the WAVE_MAPPER device.");
1337 return i_result;
1340 /* END: Windows specific functions */
1342 #endif /* WINDOWSNT */
1344 DEFUN ("play-sound-internal", Fplay_sound_internal, Splay_sound_internal, 1, 1, 0,
1345 doc: /* Play sound SOUND.
1347 Internal use only, use `play-sound' instead. */)
1348 (Lisp_Object sound)
1350 Lisp_Object attrs[SOUND_ATTR_SENTINEL];
1351 int count = SPECPDL_INDEX ();
1353 #ifndef WINDOWSNT
1354 Lisp_Object file;
1355 struct gcpro gcpro1, gcpro2;
1356 Lisp_Object args[2];
1357 #else /* WINDOWSNT */
1358 int len = 0;
1359 Lisp_Object lo_file = {0};
1360 char * psz_file = NULL;
1361 unsigned long ui_volume_tmp = UINT_MAX;
1362 unsigned long ui_volume = UINT_MAX;
1363 int i_result = 0;
1364 #endif /* WINDOWSNT */
1366 /* Parse the sound specification. Give up if it is invalid. */
1367 if (!parse_sound (sound, attrs))
1368 error ("Invalid sound specification");
1370 #ifndef WINDOWSNT
1371 file = Qnil;
1372 GCPRO2 (sound, file);
1373 current_sound_device = (struct sound_device *) xmalloc (sizeof (struct sound_device));
1374 memset (current_sound_device, 0, sizeof (struct sound_device));
1375 current_sound = (struct sound *) xmalloc (sizeof (struct sound));
1376 memset (current_sound, 0, sizeof (struct sound));
1377 record_unwind_protect (sound_cleanup, Qnil);
1378 current_sound->header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
1380 if (STRINGP (attrs[SOUND_FILE]))
1382 /* Open the sound file. */
1383 current_sound->fd = openp (Fcons (Vdata_directory, Qnil),
1384 attrs[SOUND_FILE], Qnil, &file, Qnil);
1385 if (current_sound->fd < 0)
1386 sound_perror ("Could not open sound file");
1388 /* Read the first bytes from the file. */
1389 current_sound->header_size
1390 = emacs_read (current_sound->fd, current_sound->header,
1391 MAX_SOUND_HEADER_BYTES);
1392 if (current_sound->header_size < 0)
1393 sound_perror ("Invalid sound file header");
1395 else
1397 current_sound->data = attrs[SOUND_DATA];
1398 current_sound->header_size = min (MAX_SOUND_HEADER_BYTES, SBYTES (current_sound->data));
1399 memcpy (current_sound->header, SDATA (current_sound->data),
1400 current_sound->header_size);
1403 /* Find out the type of sound. Give up if we can't tell. */
1404 find_sound_type (current_sound);
1406 /* Set up a device. */
1407 if (STRINGP (attrs[SOUND_DEVICE]))
1409 int len = SCHARS (attrs[SOUND_DEVICE]);
1410 current_sound_device->file = (char *) alloca (len + 1);
1411 strcpy (current_sound_device->file, SSDATA (attrs[SOUND_DEVICE]));
1414 if (INTEGERP (attrs[SOUND_VOLUME]))
1415 current_sound_device->volume = XFASTINT (attrs[SOUND_VOLUME]);
1416 else if (FLOATP (attrs[SOUND_VOLUME]))
1417 current_sound_device->volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
1419 args[0] = Qplay_sound_functions;
1420 args[1] = sound;
1421 Frun_hook_with_args (2, args);
1423 #ifdef HAVE_ALSA
1424 if (!alsa_init (current_sound_device))
1425 #endif
1426 if (!vox_init (current_sound_device))
1427 error ("No usable sound device driver found");
1429 /* Open the device. */
1430 current_sound_device->open (current_sound_device);
1432 /* Play the sound. */
1433 current_sound->play (current_sound, current_sound_device);
1435 /* Clean up. */
1436 UNGCPRO;
1438 #else /* WINDOWSNT */
1440 lo_file = Fexpand_file_name (attrs[SOUND_FILE], Qnil);
1441 len = XSTRING (lo_file)->size;
1442 psz_file = (char *) alloca (len + 1);
1443 strcpy (psz_file, XSTRING (lo_file)->data);
1444 if (INTEGERP (attrs[SOUND_VOLUME]))
1446 ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
1448 else if (FLOATP (attrs[SOUND_VOLUME]))
1450 ui_volume_tmp = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
1453 Based on some experiments I have conducted, a value of 100 or less
1454 for the sound volume is much too low. You cannot even hear it.
1455 A value of UINT_MAX indicates that you wish for the sound to played
1456 at the maximum possible volume. A value of UINT_MAX/2 plays the
1457 sound at 50% maximum volume. Therefore the value passed to do_play_sound
1458 (and thus to waveOutSetVolume) must be some fraction of UINT_MAX.
1459 The following code adjusts the user specified volume level appropriately.
1461 if ((ui_volume_tmp > 0) && (ui_volume_tmp <= 100))
1463 ui_volume = ui_volume_tmp * (UINT_MAX / 100);
1465 i_result = do_play_sound (psz_file, ui_volume);
1467 #endif /* WINDOWSNT */
1469 unbind_to (count, Qnil);
1470 return Qnil;
1473 /***********************************************************************
1474 Initialization
1475 ***********************************************************************/
1477 void
1478 syms_of_sound (void)
1480 DEFSYM (QCdevice, ":device");
1481 DEFSYM (QCvolume, ":volume");
1482 DEFSYM (Qsound, "sound");
1483 DEFSYM (Qplay_sound_functions, "play-sound-functions");
1485 defsubr (&Splay_sound_internal);
1489 void
1490 init_sound (void)
1494 #endif /* HAVE_SOUND */