1 /* sound.c -- sound support.
3 Copyright (C) 1998-1999, 2001-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* Written by Gerd Moellmann <gerd@gnu.org>. Tested with Luigi's
21 driver on FreeBSD 2.2.7 with a SoundBlaster 16. */
24 Modified by Ben Key <Bkey1@tampabay.rr.com> to add a partial
25 implementation of the play-sound specification for Windows.
28 In the Windows implementation of play-sound-internal only the
29 :file and :volume keywords are supported. The :device keyword,
30 if present, is ignored. The :data keyword, if present, will
31 cause an error to be generated.
33 The Windows implementation of play-sound is implemented via the
34 Windows API functions mciSendString, waveOutGetVolume, and
35 waveOutSetVolume which are exported by Winmm.dll.
40 #if defined HAVE_SOUND
42 /* BEGIN: Common Includes */
45 #include <sys/types.h>
49 #include "dispextern.h"
52 #include "syssignal.h"
53 /* END: Common Includes */
56 /* BEGIN: Non Windows Includes */
59 #include <sys/ioctl.h>
61 /* FreeBSD has machine/soundcard.h. Voxware sound driver docs mention
62 sys/soundcard.h. So, let's try whatever's there. */
64 #ifdef HAVE_MACHINE_SOUNDCARD_H
65 #include <machine/soundcard.h>
67 #ifdef HAVE_SYS_SOUNDCARD_H
68 #include <sys/soundcard.h>
70 #ifdef HAVE_SOUNDCARD_H
71 #include <soundcard.h>
74 #ifdef ALSA_SUBDIR_INCLUDE
75 #include <alsa/asoundlib.h>
77 #include <asoundlib.h>
78 #endif /* ALSA_SUBDIR_INCLUDE */
79 #endif /* HAVE_ALSA */
81 /* END: Non Windows Includes */
85 /* BEGIN: Windows Specific Includes */
90 /* END: Windows Specific Includes */
92 #endif /* WINDOWSNT */
94 /* BEGIN: Common Definitions */
98 static Lisp_Object QCvolume
, QCdevice
;
99 static Lisp_Object Qsound
;
100 static Lisp_Object Qplay_sound_functions
;
102 /* Indices of attributes in a sound attributes vector. */
113 /* END: Common Definitions */
115 /* BEGIN: Non Windows Definitions */
118 /* Structure forward declarations. */
123 /* The file header of RIFF-WAVE files (*.wav). Files are always in
124 little-endian byte-order. */
130 u_int32_t chunk_type
;
131 u_int32_t chunk_format
;
132 u_int32_t chunk_length
;
135 u_int32_t sample_rate
;
136 u_int32_t bytes_per_second
;
137 u_int16_t sample_size
;
139 u_int32_t chunk_data
;
140 u_int32_t data_length
;
143 /* The file header of Sun adio files (*.au). Files are always in
144 big-endian byte-order. */
149 u_int32_t magic_number
;
151 /* Offset of data part from start of file. Minimum value is 24. */
152 u_int32_t data_offset
;
154 /* Size of data part, 0xffffffff if unknown. */
157 /* Data encoding format.
159 2 8-bit linear PCM (REF-PCM)
163 6 32-bit IEEE floating-point
164 7 64-bit IEEE floating-point
165 23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
169 /* Number of samples per second. */
170 u_int32_t sample_rate
;
172 /* Number of interleaved channels. */
176 /* Maximum of all sound file headers sizes. */
178 #define MAX_SOUND_HEADER_BYTES \
179 max (sizeof (struct wav_header), sizeof (struct au_header))
181 /* Interface structure for sound devices. */
185 /* The name of the device or null meaning use a default device name. */
188 /* File descriptor of the device. */
191 /* Device-dependent format. */
194 /* Volume (0..100). Zero means unspecified. */
203 /* Bytes per second. */
206 /* 1 = mono, 2 = stereo, 0 = don't set. */
209 /* Open device SD. */
210 void (* open
) (struct sound_device
*sd
);
212 /* Close device SD. */
213 void (* close
) (struct sound_device
*sd
);
215 /* Configure SD according to device-dependent parameters. */
216 void (* configure
) (struct sound_device
*device
);
218 /* Choose a device-dependent format for outputting sound S. */
219 void (* choose_format
) (struct sound_device
*sd
,
222 /* Return a preferred data size in bytes to be sent to write (below)
223 each time. 2048 is used if this is NULL. */
224 ptrdiff_t (* period_size
) (struct sound_device
*sd
);
226 /* Write NYBTES bytes from BUFFER to device SD. */
227 void (* write
) (struct sound_device
*sd
, const char *buffer
,
230 /* A place for devices to store additional data. */
234 /* An enumerator for each supported sound file type. */
242 /* Interface structure for sound files. */
246 /* The type of the file. */
247 enum sound_type type
;
249 /* File descriptor of a sound file. */
252 /* Pointer to sound file header. This contains header_size bytes
253 read from the start of a sound file. */
256 /* Number of bytes read from sound file. This is always <=
257 MAX_SOUND_HEADER_BYTES. */
260 /* Sound data, if a string. */
263 /* Play sound file S on device SD. */
264 void (* play
) (struct sound
*s
, struct sound_device
*sd
);
267 /* These are set during `play-sound-internal' so that sound_cleanup has
270 static struct sound_device
*current_sound_device
;
271 static struct sound
*current_sound
;
273 /* Function prototypes. */
275 static void vox_open (struct sound_device
*);
276 static void vox_configure (struct sound_device
*);
277 static void vox_close (struct sound_device
*sd
);
278 static void vox_choose_format (struct sound_device
*, struct sound
*);
279 static int vox_init (struct sound_device
*);
280 static void vox_write (struct sound_device
*, const char *, ptrdiff_t);
281 static void find_sound_type (struct sound
*);
282 static u_int32_t
le2hl (u_int32_t
);
283 static u_int16_t
le2hs (u_int16_t
);
284 static u_int32_t
be2hl (u_int32_t
);
285 static int wav_init (struct sound
*);
286 static void wav_play (struct sound
*, struct sound_device
*);
287 static int au_init (struct sound
*);
288 static void au_play (struct sound
*, struct sound_device
*);
290 #if 0 /* Currently not used. */
291 static u_int16_t
be2hs (u_int16_t
);
294 /* END: Non Windows Definitions */
295 #else /* WINDOWSNT */
297 /* BEGIN: Windows Specific Definitions */
298 static int do_play_sound (const char *, unsigned long);
300 END: Windows Specific Definitions */
301 #endif /* WINDOWSNT */
304 /***********************************************************************
306 ***********************************************************************/
308 /* BEGIN: Common functions */
310 /* Like perror, but signals an error. */
312 static _Noreturn
void
313 sound_perror (const char *msg
)
315 int saved_errno
= errno
;
319 sigunblock (sigmask (SIGIO
));
321 if (saved_errno
!= 0)
322 error ("%s: %s", msg
, strerror (saved_errno
));
328 /* Display a warning message. */
331 sound_warning (const char *msg
)
337 /* Parse sound specification SOUND, and fill ATTRS with what is
338 found. Value is non-zero if SOUND Is a valid sound specification.
339 A valid sound specification is a list starting with the symbol
340 `sound'. The rest of the list is a property list which may
341 contain the following key/value pairs:
345 FILE is the sound file to play. If it isn't an absolute name,
346 it's searched under `data-directory'.
350 DATA is a string containing sound data. Either :file or :data
351 may be present, but not both.
355 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
356 If not specified, a default device is used.
360 VOL must be an integer in the range [0, 100], or a float in the
364 parse_sound (Lisp_Object sound
, Lisp_Object
*attrs
)
366 /* SOUND must be a list starting with the symbol `sound'. */
367 if (!CONSP (sound
) || !EQ (XCAR (sound
), Qsound
))
370 sound
= XCDR (sound
);
371 attrs
[SOUND_FILE
] = Fplist_get (sound
, QCfile
);
372 attrs
[SOUND_DATA
] = Fplist_get (sound
, QCdata
);
373 attrs
[SOUND_DEVICE
] = Fplist_get (sound
, QCdevice
);
374 attrs
[SOUND_VOLUME
] = Fplist_get (sound
, QCvolume
);
377 /* File name or data must be specified. */
378 if (!STRINGP (attrs
[SOUND_FILE
])
379 && !STRINGP (attrs
[SOUND_DATA
]))
381 #else /* WINDOWSNT */
383 Data is not supported in Windows. Therefore a
384 File name MUST be supplied.
386 if (!STRINGP (attrs
[SOUND_FILE
]))
390 #endif /* WINDOWSNT */
392 /* Volume must be in the range 0..100 or unspecified. */
393 if (!NILP (attrs
[SOUND_VOLUME
]))
395 if (INTEGERP (attrs
[SOUND_VOLUME
]))
397 if (XINT (attrs
[SOUND_VOLUME
]) < 0
398 || XINT (attrs
[SOUND_VOLUME
]) > 100)
401 else if (FLOATP (attrs
[SOUND_VOLUME
]))
403 if (XFLOAT_DATA (attrs
[SOUND_VOLUME
]) < 0
404 || XFLOAT_DATA (attrs
[SOUND_VOLUME
]) > 1)
412 /* Device must be a string or unspecified. */
413 if (!NILP (attrs
[SOUND_DEVICE
])
414 && !STRINGP (attrs
[SOUND_DEVICE
]))
416 #endif /* WINDOWSNT */
418 Since device is ignored in Windows, it does not matter
424 /* END: Common functions */
426 /* BEGIN: Non Windows functions */
429 /* Find out the type of the sound file whose file descriptor is FD.
430 S is the sound file structure to fill in. */
433 find_sound_type (struct sound
*s
)
435 if (!wav_init (s
) && !au_init (s
))
436 error ("Unknown sound format");
440 /* Function installed by play-sound-internal with record_unwind_protect. */
443 sound_cleanup (Lisp_Object arg
)
445 if (current_sound_device
->close
)
446 current_sound_device
->close (current_sound_device
);
447 if (current_sound
->fd
> 0)
448 emacs_close (current_sound
->fd
);
449 xfree (current_sound_device
);
450 xfree (current_sound
);
455 /***********************************************************************
456 Byte-order Conversion
457 ***********************************************************************/
459 /* Convert 32-bit value VALUE which is in little-endian byte-order
460 to host byte-order. */
463 le2hl (u_int32_t value
)
465 #ifdef WORDS_BIGENDIAN
466 unsigned char *p
= (unsigned char *) &value
;
467 value
= p
[0] + (p
[1] << 8) + (p
[2] << 16) + (p
[3] << 24);
473 /* Convert 16-bit value VALUE which is in little-endian byte-order
474 to host byte-order. */
477 le2hs (u_int16_t value
)
479 #ifdef WORDS_BIGENDIAN
480 unsigned char *p
= (unsigned char *) &value
;
481 value
= p
[0] + (p
[1] << 8);
487 /* Convert 32-bit value VALUE which is in big-endian byte-order
488 to host byte-order. */
491 be2hl (u_int32_t value
)
493 #ifndef WORDS_BIGENDIAN
494 unsigned char *p
= (unsigned char *) &value
;
495 value
= p
[3] + (p
[2] << 8) + (p
[1] << 16) + (p
[0] << 24);
501 #if 0 /* Currently not used. */
503 /* Convert 16-bit value VALUE which is in big-endian byte-order
504 to host byte-order. */
507 be2hs (u_int16_t value
)
509 #ifndef WORDS_BIGENDIAN
510 unsigned char *p
= (unsigned char *) &value
;
511 value
= p
[1] + (p
[0] << 8);
518 /***********************************************************************
520 ***********************************************************************/
522 /* Try to initialize sound file S from S->header. S->header
523 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
524 sound file. If the file is a WAV-format file, set up interface
525 functions in S and convert header fields to host byte-order.
526 Value is non-zero if the file is a WAV file. */
529 wav_init (struct sound
*s
)
531 struct wav_header
*header
= (struct wav_header
*) s
->header
;
533 if (s
->header_size
< sizeof *header
534 || memcmp (s
->header
, "RIFF", 4) != 0)
537 /* WAV files are in little-endian order. Convert the header
538 if on a big-endian machine. */
539 header
->magic
= le2hl (header
->magic
);
540 header
->length
= le2hl (header
->length
);
541 header
->chunk_type
= le2hl (header
->chunk_type
);
542 header
->chunk_format
= le2hl (header
->chunk_format
);
543 header
->chunk_length
= le2hl (header
->chunk_length
);
544 header
->format
= le2hs (header
->format
);
545 header
->channels
= le2hs (header
->channels
);
546 header
->sample_rate
= le2hl (header
->sample_rate
);
547 header
->bytes_per_second
= le2hl (header
->bytes_per_second
);
548 header
->sample_size
= le2hs (header
->sample_size
);
549 header
->precision
= le2hs (header
->precision
);
550 header
->chunk_data
= le2hl (header
->chunk_data
);
551 header
->data_length
= le2hl (header
->data_length
);
553 /* Set up the interface functions for WAV. */
561 /* Play RIFF-WAVE audio file S on sound device SD. */
564 wav_play (struct sound
*s
, struct sound_device
*sd
)
566 struct wav_header
*header
= (struct wav_header
*) s
->header
;
568 /* Let the device choose a suitable device-dependent format
570 sd
->choose_format (sd
, s
);
572 /* Configure the device. */
573 sd
->sample_size
= header
->sample_size
;
574 sd
->sample_rate
= header
->sample_rate
;
575 sd
->bps
= header
->bytes_per_second
;
576 sd
->channels
= header
->channels
;
579 /* Copy sound data to the device. The WAV file specification is
580 actually more complex. This simple scheme worked with all WAV
581 files I found so far. If someone feels inclined to implement the
582 whole RIFF-WAVE spec, please do. */
583 if (STRINGP (s
->data
))
584 sd
->write (sd
, SSDATA (s
->data
) + sizeof *header
,
585 SBYTES (s
->data
) - sizeof *header
);
589 ptrdiff_t nbytes
= 0;
590 ptrdiff_t blksize
= sd
->period_size
? sd
->period_size (sd
) : 2048;
591 ptrdiff_t data_left
= header
->data_length
;
593 buffer
= alloca (blksize
);
594 lseek (s
->fd
, sizeof *header
, SEEK_SET
);
596 && (nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
598 /* Don't play possible garbage at the end of file */
599 if (data_left
< nbytes
) nbytes
= data_left
;
601 sd
->write (sd
, buffer
, nbytes
);
605 sound_perror ("Error reading sound file");
610 /***********************************************************************
612 ***********************************************************************/
614 /* Sun audio file encodings. */
618 AU_ENCODING_ULAW_8
= 1,
626 AU_ENCODING_ALAW_8
= 27
630 /* Try to initialize sound file S from S->header. S->header
631 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
632 sound file. If the file is a AU-format file, set up interface
633 functions in S and convert header fields to host byte-order.
634 Value is non-zero if the file is an AU file. */
637 au_init (struct sound
*s
)
639 struct au_header
*header
= (struct au_header
*) s
->header
;
641 if (s
->header_size
< sizeof *header
642 || memcmp (s
->header
, ".snd", 4) != 0)
645 header
->magic_number
= be2hl (header
->magic_number
);
646 header
->data_offset
= be2hl (header
->data_offset
);
647 header
->data_size
= be2hl (header
->data_size
);
648 header
->encoding
= be2hl (header
->encoding
);
649 header
->sample_rate
= be2hl (header
->sample_rate
);
650 header
->channels
= be2hl (header
->channels
);
652 /* Set up the interface functions for AU. */
660 /* Play Sun audio file S on sound device SD. */
663 au_play (struct sound
*s
, struct sound_device
*sd
)
665 struct au_header
*header
= (struct au_header
*) s
->header
;
668 sd
->sample_rate
= header
->sample_rate
;
670 sd
->channels
= header
->channels
;
671 sd
->choose_format (sd
, s
);
674 if (STRINGP (s
->data
))
675 sd
->write (sd
, SSDATA (s
->data
) + header
->data_offset
,
676 SBYTES (s
->data
) - header
->data_offset
);
679 ptrdiff_t blksize
= sd
->period_size
? sd
->period_size (sd
) : 2048;
684 lseek (s
->fd
, header
->data_offset
, SEEK_SET
);
686 /* Copy sound data to the device. */
687 buffer
= alloca (blksize
);
688 while ((nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
689 sd
->write (sd
, buffer
, nbytes
);
692 sound_perror ("Error reading sound file");
697 /***********************************************************************
698 Voxware Driver Interface
699 ***********************************************************************/
701 /* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
702 has a compatible own driver aka Luigi's driver. */
705 /* Open device SD. If SD->file is non-null, open that device,
706 otherwise use a default device name. */
709 vox_open (struct sound_device
*sd
)
713 /* Open the sound device (eg /dev/dsp). */
717 file
= DEFAULT_SOUND_DEVICE
;
719 sd
->fd
= emacs_open (file
, O_WRONLY
, 0);
725 /* Configure device SD from parameters in it. */
728 vox_configure (struct sound_device
*sd
)
732 eassert (sd
->fd
>= 0);
734 /* On GNU/Linux, it seems that the device driver doesn't like to be
735 interrupted by a signal. Block the ones we know to cause
739 sigblock (sigmask (SIGIO
));
743 if (ioctl (sd
->fd
, SNDCTL_DSP_SETFMT
, &sd
->format
) < 0
744 || val
!= sd
->format
)
745 sound_perror ("Could not set sound format");
747 val
= sd
->channels
!= 1;
748 if (ioctl (sd
->fd
, SNDCTL_DSP_STEREO
, &val
) < 0
749 || val
!= (sd
->channels
!= 1))
750 sound_perror ("Could not set stereo/mono");
752 /* I think bps and sampling_rate are the same, but who knows.
753 Check this. and use SND_DSP_SPEED for both. */
754 if (sd
->sample_rate
> 0)
756 val
= sd
->sample_rate
;
757 if (ioctl (sd
->fd
, SNDCTL_DSP_SPEED
, &sd
->sample_rate
) < 0)
758 sound_perror ("Could not set sound speed");
759 else if (val
!= sd
->sample_rate
)
760 sound_warning ("Could not set sample rate");
765 int volume
= sd
->volume
& 0xff;
766 volume
|= volume
<< 8;
767 /* This may fail if there is no mixer. Ignore the failure. */
768 ioctl (sd
->fd
, SOUND_MIXER_WRITE_PCM
, &volume
);
773 sigunblock (sigmask (SIGIO
));
778 /* Close device SD if it is open. */
781 vox_close (struct sound_device
*sd
)
785 /* On GNU/Linux, it seems that the device driver doesn't like to
786 be interrupted by a signal. Block the ones we know to cause
789 sigblock (sigmask (SIGIO
));
793 /* Flush sound data, and reset the device. */
794 ioctl (sd
->fd
, SNDCTL_DSP_SYNC
, NULL
);
798 sigunblock (sigmask (SIGIO
));
801 /* Close the device. */
802 emacs_close (sd
->fd
);
808 /* Choose device-dependent format for device SD from sound file S. */
811 vox_choose_format (struct sound_device
*sd
, struct sound
*s
)
815 struct wav_header
*h
= (struct wav_header
*) s
->header
;
816 if (h
->precision
== 8)
817 sd
->format
= AFMT_U8
;
818 else if (h
->precision
== 16)
819 sd
->format
= AFMT_S16_LE
;
821 error ("Unsupported WAV file format");
823 else if (s
->type
== SUN_AUDIO
)
825 struct au_header
*header
= (struct au_header
*) s
->header
;
826 switch (header
->encoding
)
828 case AU_ENCODING_ULAW_8
:
829 case AU_ENCODING_IEEE32
:
830 case AU_ENCODING_IEEE64
:
831 sd
->format
= AFMT_MU_LAW
;
838 sd
->format
= AFMT_S16_LE
;
842 error ("Unsupported AU file format");
850 /* Initialize device SD. Set up the interface functions in the device
854 vox_init (struct sound_device
*sd
)
859 /* Open the sound device (eg /dev/dsp). */
863 file
= DEFAULT_SOUND_DEVICE
;
864 fd
= emacs_open (file
, O_WRONLY
, 0);
872 sd
->close
= vox_close
;
873 sd
->configure
= vox_configure
;
874 sd
->choose_format
= vox_choose_format
;
875 sd
->write
= vox_write
;
876 sd
->period_size
= NULL
;
881 /* Write NBYTES bytes from BUFFER to device SD. */
884 vox_write (struct sound_device
*sd
, const char *buffer
, ptrdiff_t nbytes
)
886 if (emacs_write (sd
->fd
, buffer
, nbytes
) != nbytes
)
887 sound_perror ("Error writing to sound device");
891 /***********************************************************************
892 ALSA Driver Interface
893 ***********************************************************************/
895 /* This driver is available on GNU/Linux. */
897 #ifndef DEFAULT_ALSA_SOUND_DEVICE
898 #define DEFAULT_ALSA_SOUND_DEVICE "default"
901 static _Noreturn
void
902 alsa_sound_perror (const char *msg
, int err
)
904 error ("%s: %s", msg
, snd_strerror (err
));
910 snd_pcm_hw_params_t
*hwparams
;
911 snd_pcm_sw_params_t
*swparams
;
912 snd_pcm_uframes_t period_size
;
915 /* Open device SD. If SD->file is non-null, open that device,
916 otherwise use a default device name. */
919 alsa_open (struct sound_device
*sd
)
922 struct alsa_params
*p
;
925 /* Open the sound device. Default is "default". */
929 file
= DEFAULT_ALSA_SOUND_DEVICE
;
931 p
= xmalloc (sizeof *p
);
940 err
= snd_pcm_open (&p
->handle
, file
, SND_PCM_STREAM_PLAYBACK
, 0);
942 alsa_sound_perror (file
, err
);
946 alsa_period_size (struct sound_device
*sd
)
948 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
949 int fact
= snd_pcm_format_size (sd
->format
, 1) * sd
->channels
;
950 return p
->period_size
* (fact
> 0 ? fact
: 1);
954 alsa_configure (struct sound_device
*sd
)
958 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
959 snd_pcm_uframes_t buffer_size
;
961 eassert (p
->handle
!= 0);
963 err
= snd_pcm_hw_params_malloc (&p
->hwparams
);
965 alsa_sound_perror ("Could not allocate hardware parameter structure", err
);
967 err
= snd_pcm_sw_params_malloc (&p
->swparams
);
969 alsa_sound_perror ("Could not allocate software parameter structure", err
);
971 err
= snd_pcm_hw_params_any (p
->handle
, p
->hwparams
);
973 alsa_sound_perror ("Could not initialize hardware parameter structure", err
);
975 err
= snd_pcm_hw_params_set_access (p
->handle
, p
->hwparams
,
976 SND_PCM_ACCESS_RW_INTERLEAVED
);
978 alsa_sound_perror ("Could not set access type", err
);
981 err
= snd_pcm_hw_params_set_format (p
->handle
, p
->hwparams
, val
);
983 alsa_sound_perror ("Could not set sound format", err
);
985 uval
= sd
->sample_rate
;
986 err
= snd_pcm_hw_params_set_rate_near (p
->handle
, p
->hwparams
, &uval
, 0);
988 alsa_sound_perror ("Could not set sample rate", err
);
991 err
= snd_pcm_hw_params_set_channels (p
->handle
, p
->hwparams
, val
);
993 alsa_sound_perror ("Could not set channel count", err
);
995 err
= snd_pcm_hw_params (p
->handle
, p
->hwparams
);
997 alsa_sound_perror ("Could not set parameters", err
);
1000 err
= snd_pcm_hw_params_get_period_size (p
->hwparams
, &p
->period_size
, &dir
);
1002 alsa_sound_perror ("Unable to get period size for playback", err
);
1004 err
= snd_pcm_hw_params_get_buffer_size (p
->hwparams
, &buffer_size
);
1006 alsa_sound_perror ("Unable to get buffer size for playback", err
);
1008 err
= snd_pcm_sw_params_current (p
->handle
, p
->swparams
);
1010 alsa_sound_perror ("Unable to determine current swparams for playback",
1013 /* Start the transfer when the buffer is almost full */
1014 err
= snd_pcm_sw_params_set_start_threshold (p
->handle
, p
->swparams
,
1015 (buffer_size
/ p
->period_size
)
1018 alsa_sound_perror ("Unable to set start threshold mode for playback", err
);
1020 /* Allow the transfer when at least period_size samples can be processed */
1021 err
= snd_pcm_sw_params_set_avail_min (p
->handle
, p
->swparams
, p
->period_size
);
1023 alsa_sound_perror ("Unable to set avail min for playback", err
);
1025 err
= snd_pcm_sw_params (p
->handle
, p
->swparams
);
1027 alsa_sound_perror ("Unable to set sw params for playback\n", err
);
1029 snd_pcm_hw_params_free (p
->hwparams
);
1031 snd_pcm_sw_params_free (p
->swparams
);
1034 err
= snd_pcm_prepare (p
->handle
);
1036 alsa_sound_perror ("Could not prepare audio interface for use", err
);
1041 snd_mixer_t
*handle
;
1042 snd_mixer_elem_t
*e
;
1043 const char *file
= sd
->file
? sd
->file
: DEFAULT_ALSA_SOUND_DEVICE
;
1045 if (snd_mixer_open (&handle
, 0) >= 0)
1047 if (snd_mixer_attach (handle
, file
) >= 0
1048 && snd_mixer_load (handle
) >= 0
1049 && snd_mixer_selem_register (handle
, NULL
, NULL
) >= 0)
1050 for (e
= snd_mixer_first_elem (handle
);
1052 e
= snd_mixer_elem_next (e
))
1054 if (snd_mixer_selem_has_playback_volume (e
))
1056 long pmin
, pmax
, vol
;
1057 snd_mixer_selem_get_playback_volume_range (e
, &pmin
, &pmax
);
1058 vol
= pmin
+ (sd
->volume
* (pmax
- pmin
)) / 100;
1060 for (chn
= 0; chn
<= SND_MIXER_SCHN_LAST
; chn
++)
1061 snd_mixer_selem_set_playback_volume (e
, chn
, vol
);
1064 snd_mixer_close (handle
);
1070 /* Close device SD if it is open. */
1073 alsa_close (struct sound_device
*sd
)
1075 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
1079 snd_pcm_hw_params_free (p
->hwparams
);
1081 snd_pcm_sw_params_free (p
->swparams
);
1084 snd_pcm_drain (p
->handle
);
1085 snd_pcm_close (p
->handle
);
1091 /* Choose device-dependent format for device SD from sound file S. */
1094 alsa_choose_format (struct sound_device
*sd
, struct sound
*s
)
1096 if (s
->type
== RIFF
)
1098 struct wav_header
*h
= (struct wav_header
*) s
->header
;
1099 if (h
->precision
== 8)
1100 sd
->format
= SND_PCM_FORMAT_U8
;
1101 else if (h
->precision
== 16)
1102 sd
->format
= SND_PCM_FORMAT_S16_LE
;
1104 error ("Unsupported WAV file format");
1106 else if (s
->type
== SUN_AUDIO
)
1108 struct au_header
*header
= (struct au_header
*) s
->header
;
1109 switch (header
->encoding
)
1111 case AU_ENCODING_ULAW_8
:
1112 sd
->format
= SND_PCM_FORMAT_MU_LAW
;
1114 case AU_ENCODING_ALAW_8
:
1115 sd
->format
= SND_PCM_FORMAT_A_LAW
;
1117 case AU_ENCODING_IEEE32
:
1118 sd
->format
= SND_PCM_FORMAT_FLOAT_BE
;
1120 case AU_ENCODING_IEEE64
:
1121 sd
->format
= SND_PCM_FORMAT_FLOAT64_BE
;
1124 sd
->format
= SND_PCM_FORMAT_S8
;
1126 case AU_ENCODING_16
:
1127 sd
->format
= SND_PCM_FORMAT_S16_BE
;
1129 case AU_ENCODING_24
:
1130 sd
->format
= SND_PCM_FORMAT_S24_BE
;
1132 case AU_ENCODING_32
:
1133 sd
->format
= SND_PCM_FORMAT_S32_BE
;
1137 error ("Unsupported AU file format");
1145 /* Write NBYTES bytes from BUFFER to device SD. */
1148 alsa_write (struct sound_device
*sd
, const char *buffer
, ptrdiff_t nbytes
)
1150 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
1152 /* The the third parameter to snd_pcm_writei is frames, not bytes. */
1153 int fact
= snd_pcm_format_size (sd
->format
, 1) * sd
->channels
;
1154 ptrdiff_t nwritten
= 0;
1157 while (nwritten
< nbytes
)
1159 snd_pcm_uframes_t frames
= (nbytes
- nwritten
)/fact
;
1160 if (frames
== 0) break;
1162 err
= snd_pcm_writei (p
->handle
, buffer
+ nwritten
, frames
);
1167 err
= snd_pcm_prepare (p
->handle
);
1169 alsa_sound_perror ("Can't recover from underrun, prepare failed",
1172 else if (err
== -ESTRPIPE
)
1174 while ((err
= snd_pcm_resume (p
->handle
)) == -EAGAIN
)
1175 sleep (1); /* wait until the suspend flag is released */
1178 err
= snd_pcm_prepare (p
->handle
);
1180 alsa_sound_perror ("Can't recover from suspend, "
1186 alsa_sound_perror ("Error writing to sound device", err
);
1190 nwritten
+= err
* fact
;
1195 snd_error_quiet (const char *file
, int line
, const char *function
, int err
,
1200 /* Initialize device SD. Set up the interface functions in the device
1204 alsa_init (struct sound_device
*sd
)
1210 /* Open the sound device. Default is "default". */
1214 file
= DEFAULT_ALSA_SOUND_DEVICE
;
1216 snd_lib_error_set_handler ((snd_lib_error_handler_t
) snd_error_quiet
);
1217 err
= snd_pcm_open (&handle
, file
, SND_PCM_STREAM_PLAYBACK
, 0);
1218 snd_lib_error_set_handler (NULL
);
1221 snd_pcm_close (handle
);
1224 sd
->open
= alsa_open
;
1225 sd
->close
= alsa_close
;
1226 sd
->configure
= alsa_configure
;
1227 sd
->choose_format
= alsa_choose_format
;
1228 sd
->write
= alsa_write
;
1229 sd
->period_size
= alsa_period_size
;
1234 #endif /* HAVE_ALSA */
1237 /* END: Non Windows functions */
1238 #else /* WINDOWSNT */
1240 /* BEGIN: Windows specific functions */
1242 #define SOUND_WARNING(fun, error, text) \
1245 char err_string[MAXERRORLENGTH]; \
1246 fun (error, err_string, sizeof (err_string)); \
1247 _snprintf (buf, sizeof (buf), "%s\nError: %s", \
1248 text, err_string); \
1249 sound_warning (buf); \
1253 do_play_sound (const char *psz_file
, unsigned long ui_volume
)
1256 MCIERROR mci_error
= 0;
1257 char sz_cmd_buf
[520] = {0};
1258 char sz_ret_buf
[520] = {0};
1259 MMRESULT mm_result
= MMSYSERR_NOERROR
;
1260 unsigned long ui_volume_org
= 0;
1261 BOOL b_reset_volume
= FALSE
;
1263 memset (sz_cmd_buf
, 0, sizeof (sz_cmd_buf
));
1264 memset (sz_ret_buf
, 0, sizeof (sz_ret_buf
));
1265 sprintf (sz_cmd_buf
,
1266 "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
1268 mci_error
= mciSendString (sz_cmd_buf
, sz_ret_buf
, sizeof (sz_ret_buf
), NULL
);
1271 SOUND_WARNING (mciGetErrorString
, mci_error
,
1272 "The open mciSendString command failed to open "
1273 "the specified sound file.");
1274 i_result
= (int) mci_error
;
1277 if ((ui_volume
> 0) && (ui_volume
!= UINT_MAX
))
1279 mm_result
= waveOutGetVolume ((HWAVEOUT
) WAVE_MAPPER
, &ui_volume_org
);
1280 if (mm_result
== MMSYSERR_NOERROR
)
1282 b_reset_volume
= TRUE
;
1283 mm_result
= waveOutSetVolume ((HWAVEOUT
) WAVE_MAPPER
, ui_volume
);
1284 if (mm_result
!= MMSYSERR_NOERROR
)
1286 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1287 "waveOutSetVolume failed to set the volume level "
1288 "of the WAVE_MAPPER device.\n"
1289 "As a result, the user selected volume level will "
1295 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1296 "waveOutGetVolume failed to obtain the original "
1297 "volume level of the WAVE_MAPPER device.\n"
1298 "As a result, the user selected volume level will "
1302 memset (sz_cmd_buf
, 0, sizeof (sz_cmd_buf
));
1303 memset (sz_ret_buf
, 0, sizeof (sz_ret_buf
));
1304 strcpy (sz_cmd_buf
, "play GNUEmacs_PlaySound_Device wait");
1305 mci_error
= mciSendString (sz_cmd_buf
, sz_ret_buf
, sizeof (sz_ret_buf
), NULL
);
1308 SOUND_WARNING (mciGetErrorString
, mci_error
,
1309 "The play mciSendString command failed to play the "
1310 "opened sound file.");
1311 i_result
= (int) mci_error
;
1313 memset (sz_cmd_buf
, 0, sizeof (sz_cmd_buf
));
1314 memset (sz_ret_buf
, 0, sizeof (sz_ret_buf
));
1315 strcpy (sz_cmd_buf
, "close GNUEmacs_PlaySound_Device wait");
1316 mci_error
= mciSendString (sz_cmd_buf
, sz_ret_buf
, sizeof (sz_ret_buf
), NULL
);
1317 if (b_reset_volume
== TRUE
)
1319 mm_result
= waveOutSetVolume ((HWAVEOUT
) WAVE_MAPPER
, ui_volume_org
);
1320 if (mm_result
!= MMSYSERR_NOERROR
)
1322 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1323 "waveOutSetVolume failed to reset the original volume "
1324 "level of the WAVE_MAPPER device.");
1330 /* END: Windows specific functions */
1332 #endif /* WINDOWSNT */
1334 DEFUN ("play-sound-internal", Fplay_sound_internal
, Splay_sound_internal
, 1, 1, 0,
1335 doc
: /* Play sound SOUND.
1337 Internal use only, use `play-sound' instead. */)
1340 Lisp_Object attrs
[SOUND_ATTR_SENTINEL
];
1341 ptrdiff_t count
= SPECPDL_INDEX ();
1345 struct gcpro gcpro1
, gcpro2
;
1346 Lisp_Object args
[2];
1347 #else /* WINDOWSNT */
1349 Lisp_Object lo_file
= {0};
1350 char * psz_file
= NULL
;
1351 unsigned long ui_volume_tmp
= UINT_MAX
;
1352 unsigned long ui_volume
= UINT_MAX
;
1354 #endif /* WINDOWSNT */
1356 /* Parse the sound specification. Give up if it is invalid. */
1357 if (!parse_sound (sound
, attrs
))
1358 error ("Invalid sound specification");
1362 GCPRO2 (sound
, file
);
1363 current_sound_device
= xzalloc (sizeof *current_sound_device
);
1364 current_sound
= xzalloc (sizeof *current_sound
);
1365 record_unwind_protect (sound_cleanup
, Qnil
);
1366 current_sound
->header
= alloca (MAX_SOUND_HEADER_BYTES
);
1368 if (STRINGP (attrs
[SOUND_FILE
]))
1370 /* Open the sound file. */
1371 current_sound
->fd
= openp (Fcons (Vdata_directory
, Qnil
),
1372 attrs
[SOUND_FILE
], Qnil
, &file
, Qnil
);
1373 if (current_sound
->fd
< 0)
1374 sound_perror ("Could not open sound file");
1376 /* Read the first bytes from the file. */
1377 current_sound
->header_size
1378 = emacs_read (current_sound
->fd
, current_sound
->header
,
1379 MAX_SOUND_HEADER_BYTES
);
1380 if (current_sound
->header_size
< 0)
1381 sound_perror ("Invalid sound file header");
1385 current_sound
->data
= attrs
[SOUND_DATA
];
1386 current_sound
->header_size
= min (MAX_SOUND_HEADER_BYTES
, SBYTES (current_sound
->data
));
1387 memcpy (current_sound
->header
, SDATA (current_sound
->data
),
1388 current_sound
->header_size
);
1391 /* Find out the type of sound. Give up if we can't tell. */
1392 find_sound_type (current_sound
);
1394 /* Set up a device. */
1395 if (STRINGP (attrs
[SOUND_DEVICE
]))
1397 int len
= SCHARS (attrs
[SOUND_DEVICE
]);
1398 current_sound_device
->file
= alloca (len
+ 1);
1399 strcpy (current_sound_device
->file
, SSDATA (attrs
[SOUND_DEVICE
]));
1402 if (INTEGERP (attrs
[SOUND_VOLUME
]))
1403 current_sound_device
->volume
= XFASTINT (attrs
[SOUND_VOLUME
]);
1404 else if (FLOATP (attrs
[SOUND_VOLUME
]))
1405 current_sound_device
->volume
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]) * 100;
1407 args
[0] = Qplay_sound_functions
;
1409 Frun_hook_with_args (2, args
);
1412 if (!alsa_init (current_sound_device
))
1414 if (!vox_init (current_sound_device
))
1415 error ("No usable sound device driver found");
1417 /* Open the device. */
1418 current_sound_device
->open (current_sound_device
);
1420 /* Play the sound. */
1421 current_sound
->play (current_sound
, current_sound_device
);
1426 #else /* WINDOWSNT */
1428 lo_file
= Fexpand_file_name (attrs
[SOUND_FILE
], Qnil
);
1429 len
= XSTRING (lo_file
)->size
;
1430 psz_file
= alloca (len
+ 1);
1431 strcpy (psz_file
, XSTRING (lo_file
)->data
);
1432 if (INTEGERP (attrs
[SOUND_VOLUME
]))
1434 ui_volume_tmp
= XFASTINT (attrs
[SOUND_VOLUME
]);
1436 else if (FLOATP (attrs
[SOUND_VOLUME
]))
1438 ui_volume_tmp
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]) * 100;
1441 Based on some experiments I have conducted, a value of 100 or less
1442 for the sound volume is much too low. You cannot even hear it.
1443 A value of UINT_MAX indicates that you wish for the sound to played
1444 at the maximum possible volume. A value of UINT_MAX/2 plays the
1445 sound at 50% maximum volume. Therefore the value passed to do_play_sound
1446 (and thus to waveOutSetVolume) must be some fraction of UINT_MAX.
1447 The following code adjusts the user specified volume level appropriately.
1449 if ((ui_volume_tmp
> 0) && (ui_volume_tmp
<= 100))
1451 ui_volume
= ui_volume_tmp
* (UINT_MAX
/ 100);
1453 i_result
= do_play_sound (psz_file
, ui_volume
);
1455 #endif /* WINDOWSNT */
1457 unbind_to (count
, Qnil
);
1461 /***********************************************************************
1463 ***********************************************************************/
1466 syms_of_sound (void)
1468 DEFSYM (QCdevice
, ":device");
1469 DEFSYM (QCvolume
, ":volume");
1470 DEFSYM (Qsound
, "sound");
1471 DEFSYM (Qplay_sound_functions
, "play-sound-functions");
1473 defsubr (&Splay_sound_internal
);
1476 #endif /* HAVE_SOUND */