1 /* sound.c -- sound support.
3 Copyright (C) 1998-1999, 2001-2019 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 (at
10 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 <https://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>
50 #include "syssignal.h"
51 /* END: Common Includes */
54 /* 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 */
93 #include "w32common.h"
95 /* END: Windows Specific Includes */
97 #endif /* WINDOWSNT */
99 /* BEGIN: Common Definitions */
101 /* Indices of attributes in a sound attributes vector. */
112 /* END: Common Definitions */
114 /* BEGIN: Non Windows Definitions */
117 /* Structure forward declarations. */
122 /* The file header of RIFF-WAVE files (*.wav). Files are always in
123 little-endian byte-order. */
129 u_int32_t chunk_type
;
130 u_int32_t chunk_format
;
131 u_int32_t chunk_length
;
134 u_int32_t sample_rate
;
135 u_int32_t bytes_per_second
;
136 u_int16_t sample_size
;
138 u_int32_t chunk_data
;
139 u_int32_t data_length
;
142 /* The file header of Sun adio files (*.au). Files are always in
143 big-endian byte-order. */
148 u_int32_t magic_number
;
150 /* Offset of data part from start of file. Minimum value is 24. */
151 u_int32_t data_offset
;
153 /* Size of data part, 0xffffffff if unknown. */
156 /* Data encoding format.
158 2 8-bit linear PCM (REF-PCM)
162 6 32-bit IEEE floating-point
163 7 64-bit IEEE floating-point
164 23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
168 /* Number of samples per second. */
169 u_int32_t sample_rate
;
171 /* Number of interleaved channels. */
175 /* Maximum of all sound file headers sizes. */
177 #define MAX_SOUND_HEADER_BYTES \
178 max (sizeof (struct wav_header), sizeof (struct au_header))
180 /* Interface structure for sound devices. */
184 /* If a string, the name of the device; otherwise use a default. */
187 /* File descriptor of the device. */
190 /* Device-dependent format. */
193 /* Volume (0..100). Zero means unspecified. */
202 /* Bytes per second. */
205 /* 1 = mono, 2 = stereo, 0 = don't set. */
208 /* Open device SD. */
209 void (* open
) (struct sound_device
*sd
);
211 /* Close device SD. */
212 void (* close
) (struct sound_device
*sd
);
214 /* Configure SD according to device-dependent parameters. */
215 void (* configure
) (struct sound_device
*device
);
217 /* Choose a device-dependent format for outputting sound S. */
218 void (* choose_format
) (struct sound_device
*sd
,
221 /* Return a preferred data size in bytes to be sent to write (below)
222 each time. 2048 is used if this is NULL. */
223 ptrdiff_t (* period_size
) (struct sound_device
*sd
);
225 /* Write NYBTES bytes from BUFFER to device SD. */
226 void (* write
) (struct sound_device
*sd
, const char *buffer
,
229 /* A place for devices to store additional data. */
233 /* An enumerator for each supported sound file type. */
241 /* Interface structure for sound files. */
245 /* The type of the file. */
246 enum sound_type type
;
248 /* File descriptor of a sound file. */
251 /* Pointer to sound file header. This contains header_size bytes
252 read from the start of a sound file. */
255 /* Number of bytes read from sound file. This is always <=
256 MAX_SOUND_HEADER_BYTES. */
259 /* Sound data, if a string. */
262 /* Play sound file S on device SD. */
263 void (* play
) (struct sound
*s
, struct sound_device
*sd
);
266 /* These are set during `play-sound-internal' so that sound_cleanup has
269 static struct sound_device
*current_sound_device
;
270 static struct sound
*current_sound
;
272 /* Function prototypes. */
274 static void vox_write (struct sound_device
*, const char *, ptrdiff_t);
275 static bool wav_init (struct sound
*);
276 static void wav_play (struct sound
*, struct sound_device
*);
277 static bool au_init (struct sound
*);
278 static void au_play (struct sound
*, struct sound_device
*);
280 /* END: Non Windows Definitions */
281 #else /* WINDOWSNT */
283 /* BEGIN: Windows Specific Definitions */
284 static int do_play_sound (const char *, unsigned long);
286 END: Windows Specific Definitions */
287 #endif /* WINDOWSNT */
290 /***********************************************************************
292 ***********************************************************************/
294 /* BEGIN: Common functions */
297 /* Like perror, but signals an error. */
299 static _Noreturn
void
300 sound_perror (const char *msg
)
302 int saved_errno
= errno
;
308 sigemptyset (&unblocked
);
309 sigaddset (&unblocked
, SIGIO
);
310 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
313 if (saved_errno
!= 0)
314 error ("%s: %s", msg
, emacs_strerror (saved_errno
));
319 /* Display a warning message. */
322 sound_warning (const char *msg
)
326 #endif /* !WINDOWSNT */
329 /* Parse sound specification SOUND, and fill ATTRS with what is
330 found. Value is non-zero if SOUND Is a valid sound specification.
331 A valid sound specification is a list starting with the symbol
332 `sound'. The rest of the list is a property list which may
333 contain the following key/value pairs:
337 FILE is the sound file to play. If it isn't an absolute name,
338 it's searched under `data-directory'.
342 DATA is a string containing sound data. Either :file or :data
343 may be present, but not both.
347 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
348 If not specified, a default device is used.
352 VOL must be an integer in the range [0, 100], or a float in the
356 parse_sound (Lisp_Object sound
, Lisp_Object
*attrs
)
358 /* SOUND must be a list starting with the symbol `sound'. */
359 if (!CONSP (sound
) || !EQ (XCAR (sound
), Qsound
))
362 sound
= XCDR (sound
);
363 attrs
[SOUND_FILE
] = Fplist_get (sound
, QCfile
);
364 attrs
[SOUND_DATA
] = Fplist_get (sound
, QCdata
);
365 attrs
[SOUND_DEVICE
] = Fplist_get (sound
, QCdevice
);
366 attrs
[SOUND_VOLUME
] = Fplist_get (sound
, QCvolume
);
369 /* File name or data must be specified. */
370 if (!STRINGP (attrs
[SOUND_FILE
])
371 && !STRINGP (attrs
[SOUND_DATA
]))
373 #else /* WINDOWSNT */
375 Data is not supported in Windows. Therefore a
376 File name MUST be supplied.
378 if (!STRINGP (attrs
[SOUND_FILE
]))
382 #endif /* WINDOWSNT */
384 /* Volume must be in the range 0..100 or unspecified. */
385 if (!NILP (attrs
[SOUND_VOLUME
]))
387 if (INTEGERP (attrs
[SOUND_VOLUME
]))
389 EMACS_INT volume
= XINT (attrs
[SOUND_VOLUME
]);
390 if (! (0 <= volume
&& volume
<= 100))
393 else if (FLOATP (attrs
[SOUND_VOLUME
]))
395 double volume
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]);
396 if (! (0 <= volume
&& volume
<= 1))
404 /* Device must be a string or unspecified. */
405 if (!NILP (attrs
[SOUND_DEVICE
])
406 && !STRINGP (attrs
[SOUND_DEVICE
]))
408 #endif /* WINDOWSNT */
410 Since device is ignored in Windows, it does not matter
416 /* END: Common functions */
418 /* BEGIN: Non Windows functions */
421 /* Return S's value as a string if S is a string, otherwise DEFAULT_VALUE. */
424 string_default (Lisp_Object s
, char const *default_value
)
426 return STRINGP (s
) ? SSDATA (s
) : default_value
;
430 /* Find out the type of the sound file whose file descriptor is FD.
431 S is the sound file structure to fill in. */
434 find_sound_type (struct sound
*s
)
436 if (!wav_init (s
) && !au_init (s
))
437 error ("Unknown sound format");
441 /* Function installed by play-sound-internal with record_unwind_protect_void. */
446 if (current_sound_device
->close
)
447 current_sound_device
->close (current_sound_device
);
448 if (current_sound
->fd
> 0)
449 emacs_close (current_sound
->fd
);
450 xfree (current_sound_device
);
451 xfree (current_sound
);
454 /***********************************************************************
455 Byte-order Conversion
456 ***********************************************************************/
458 /* Convert 32-bit value VALUE which is in little-endian byte-order
459 to host byte-order. */
462 le2hl (u_int32_t value
)
464 #ifdef WORDS_BIGENDIAN
465 value
= bswap_32 (value
);
471 /* Convert 16-bit value VALUE which is in little-endian byte-order
472 to host byte-order. */
475 le2hs (u_int16_t value
)
477 #ifdef WORDS_BIGENDIAN
478 value
= bswap_16 (value
);
484 /* Convert 32-bit value VALUE which is in big-endian byte-order
485 to host byte-order. */
488 be2hl (u_int32_t value
)
490 #ifndef WORDS_BIGENDIAN
491 value
= bswap_32 (value
);
496 /***********************************************************************
498 ***********************************************************************/
500 /* Try to initialize sound file S from S->header. S->header
501 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
502 sound file. If the file is a WAV-format file, set up interface
503 functions in S and convert header fields to host byte-order.
504 Value is true if the file is a WAV file. */
507 wav_init (struct sound
*s
)
509 struct wav_header
*header
= (struct wav_header
*) s
->header
;
511 if (s
->header_size
< sizeof *header
512 || memcmp (s
->header
, "RIFF", 4) != 0)
515 /* WAV files are in little-endian order. Convert the header
516 if on a big-endian machine. */
517 header
->magic
= le2hl (header
->magic
);
518 header
->length
= le2hl (header
->length
);
519 header
->chunk_type
= le2hl (header
->chunk_type
);
520 header
->chunk_format
= le2hl (header
->chunk_format
);
521 header
->chunk_length
= le2hl (header
->chunk_length
);
522 header
->format
= le2hs (header
->format
);
523 header
->channels
= le2hs (header
->channels
);
524 header
->sample_rate
= le2hl (header
->sample_rate
);
525 header
->bytes_per_second
= le2hl (header
->bytes_per_second
);
526 header
->sample_size
= le2hs (header
->sample_size
);
527 header
->precision
= le2hs (header
->precision
);
528 header
->chunk_data
= le2hl (header
->chunk_data
);
529 header
->data_length
= le2hl (header
->data_length
);
531 /* Set up the interface functions for WAV. */
539 /* Play RIFF-WAVE audio file S on sound device SD. */
542 wav_play (struct sound
*s
, struct sound_device
*sd
)
544 struct wav_header
*header
= (struct wav_header
*) s
->header
;
546 /* Let the device choose a suitable device-dependent format
548 sd
->choose_format (sd
, s
);
550 /* Configure the device. */
551 sd
->sample_size
= header
->sample_size
;
552 sd
->sample_rate
= header
->sample_rate
;
553 sd
->bps
= header
->bytes_per_second
;
554 sd
->channels
= header
->channels
;
557 /* Copy sound data to the device. The WAV file specification is
558 actually more complex. This simple scheme worked with all WAV
559 files I found so far. If someone feels inclined to implement the
560 whole RIFF-WAVE spec, please do. */
561 if (STRINGP (s
->data
))
562 sd
->write (sd
, SSDATA (s
->data
) + sizeof *header
,
563 SBYTES (s
->data
) - sizeof *header
);
566 ptrdiff_t nbytes
= 0;
567 ptrdiff_t blksize
= sd
->period_size
? sd
->period_size (sd
) : 2048;
568 ptrdiff_t data_left
= header
->data_length
;
570 char *buffer
= SAFE_ALLOCA (blksize
);
571 lseek (s
->fd
, sizeof *header
, SEEK_SET
);
573 && (nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
575 /* Don't play possible garbage at the end of file */
576 if (data_left
< nbytes
) nbytes
= data_left
;
578 sd
->write (sd
, buffer
, nbytes
);
582 sound_perror ("Error reading sound file");
588 /***********************************************************************
590 ***********************************************************************/
592 /* Sun audio file encodings. */
596 AU_ENCODING_ULAW_8
= 1,
604 AU_ENCODING_ALAW_8
= 27
608 /* Try to initialize sound file S from S->header. S->header
609 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
610 sound file. If the file is a AU-format file, set up interface
611 functions in S and convert header fields to host byte-order.
612 Value is true if the file is an AU file. */
615 au_init (struct sound
*s
)
617 struct au_header
*header
= (struct au_header
*) s
->header
;
619 if (s
->header_size
< sizeof *header
620 || memcmp (s
->header
, ".snd", 4) != 0)
623 header
->magic_number
= be2hl (header
->magic_number
);
624 header
->data_offset
= be2hl (header
->data_offset
);
625 header
->data_size
= be2hl (header
->data_size
);
626 header
->encoding
= be2hl (header
->encoding
);
627 header
->sample_rate
= be2hl (header
->sample_rate
);
628 header
->channels
= be2hl (header
->channels
);
630 /* Set up the interface functions for AU. */
638 /* Play Sun audio file S on sound device SD. */
641 au_play (struct sound
*s
, struct sound_device
*sd
)
643 struct au_header
*header
= (struct au_header
*) s
->header
;
646 sd
->sample_rate
= header
->sample_rate
;
648 sd
->channels
= header
->channels
;
649 sd
->choose_format (sd
, s
);
652 if (STRINGP (s
->data
))
653 sd
->write (sd
, SSDATA (s
->data
) + header
->data_offset
,
654 SBYTES (s
->data
) - header
->data_offset
);
657 ptrdiff_t blksize
= sd
->period_size
? sd
->period_size (sd
) : 2048;
661 lseek (s
->fd
, header
->data_offset
, SEEK_SET
);
663 /* Copy sound data to the device. */
665 char *buffer
= SAFE_ALLOCA (blksize
);
666 while ((nbytes
= emacs_read (s
->fd
, buffer
, blksize
)) > 0)
667 sd
->write (sd
, buffer
, nbytes
);
670 sound_perror ("Error reading sound file");
676 /***********************************************************************
677 Voxware Driver Interface
678 ***********************************************************************/
680 /* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
681 has a compatible own driver aka Luigi's driver. */
684 /* Open device SD. If SD->file is a string, open that device,
685 otherwise use a default device name. */
688 vox_open (struct sound_device
*sd
)
690 /* Open the sound device (eg /dev/dsp). */
691 char const *file
= string_default (sd
->file
, DEFAULT_SOUND_DEVICE
);
692 sd
->fd
= emacs_open (file
, O_WRONLY
, 0);
698 /* Configure device SD from parameters in it. */
701 vox_configure (struct sound_device
*sd
)
705 sigset_t oldset
, blocked
;
708 eassert (sd
->fd
>= 0);
710 /* On GNU/Linux, it seems that the device driver doesn't like to be
711 interrupted by a signal. Block the ones we know to cause
715 sigemptyset (&blocked
);
716 sigaddset (&blocked
, SIGIO
);
717 pthread_sigmask (SIG_BLOCK
, &blocked
, &oldset
);
721 if (ioctl (sd
->fd
, SNDCTL_DSP_SETFMT
, &sd
->format
) < 0
722 || val
!= sd
->format
)
723 sound_perror ("Could not set sound format");
725 val
= sd
->channels
!= 1;
726 if (ioctl (sd
->fd
, SNDCTL_DSP_STEREO
, &val
) < 0
727 || val
!= (sd
->channels
!= 1))
728 sound_perror ("Could not set stereo/mono");
730 /* I think bps and sampling_rate are the same, but who knows.
731 Check this. and use SND_DSP_SPEED for both. */
732 if (sd
->sample_rate
> 0)
734 val
= sd
->sample_rate
;
735 if (ioctl (sd
->fd
, SNDCTL_DSP_SPEED
, &sd
->sample_rate
) < 0)
736 sound_perror ("Could not set sound speed");
737 else if (val
!= sd
->sample_rate
)
738 sound_warning ("Could not set sample rate");
743 int volume
= sd
->volume
& 0xff;
744 volume
|= volume
<< 8;
745 /* This may fail if there is no mixer. Ignore the failure. */
746 ioctl (sd
->fd
, SOUND_MIXER_WRITE_PCM
, &volume
);
751 pthread_sigmask (SIG_SETMASK
, &oldset
, 0);
756 /* Close device SD if it is open. */
759 vox_close (struct sound_device
*sd
)
763 /* On GNU/Linux, it seems that the device driver doesn't like to
764 be interrupted by a signal. Block the ones we know to cause
767 sigset_t blocked
, oldset
;
768 sigemptyset (&blocked
);
769 sigaddset (&blocked
, SIGIO
);
770 pthread_sigmask (SIG_BLOCK
, &blocked
, &oldset
);
774 /* Flush sound data, and reset the device. */
775 ioctl (sd
->fd
, SNDCTL_DSP_SYNC
, NULL
);
779 pthread_sigmask (SIG_SETMASK
, &oldset
, 0);
782 /* Close the device. */
783 emacs_close (sd
->fd
);
789 /* Choose device-dependent format for device SD from sound file S. */
792 vox_choose_format (struct sound_device
*sd
, struct sound
*s
)
796 struct wav_header
*h
= (struct wav_header
*) s
->header
;
797 if (h
->precision
== 8)
798 sd
->format
= AFMT_U8
;
799 else if (h
->precision
== 16)
800 sd
->format
= AFMT_S16_LE
;
802 error ("Unsupported WAV file format");
804 else if (s
->type
== SUN_AUDIO
)
806 struct au_header
*header
= (struct au_header
*) s
->header
;
807 switch (header
->encoding
)
809 case AU_ENCODING_ULAW_8
:
810 case AU_ENCODING_IEEE32
:
811 case AU_ENCODING_IEEE64
:
812 sd
->format
= AFMT_MU_LAW
;
819 sd
->format
= AFMT_S16_LE
;
823 error ("Unsupported AU file format");
831 /* Initialize device SD. Set up the interface functions in the device
835 vox_init (struct sound_device
*sd
)
837 /* Open the sound device (eg /dev/dsp). */
838 char const *file
= string_default (sd
->file
, DEFAULT_SOUND_DEVICE
);
839 int fd
= emacs_open (file
, O_WRONLY
, 0);
847 sd
->close
= vox_close
;
848 sd
->configure
= vox_configure
;
849 sd
->choose_format
= vox_choose_format
;
850 sd
->write
= vox_write
;
851 sd
->period_size
= NULL
;
856 /* Write NBYTES bytes from BUFFER to device SD. */
859 vox_write (struct sound_device
*sd
, const char *buffer
, ptrdiff_t nbytes
)
861 if (emacs_write_sig (sd
->fd
, buffer
, nbytes
) != nbytes
)
862 sound_perror ("Error writing to sound device");
866 /***********************************************************************
867 ALSA Driver Interface
868 ***********************************************************************/
870 /* This driver is available on GNU/Linux. */
872 #ifndef DEFAULT_ALSA_SOUND_DEVICE
873 #define DEFAULT_ALSA_SOUND_DEVICE "default"
876 static _Noreturn
void
877 alsa_sound_perror (const char *msg
, int err
)
879 error ("%s: %s", msg
, snd_strerror (err
));
885 snd_pcm_hw_params_t
*hwparams
;
886 snd_pcm_sw_params_t
*swparams
;
887 snd_pcm_uframes_t period_size
;
890 /* Open device SD. If SD->file is a string, open that device,
891 otherwise use a default device name. */
894 alsa_open (struct sound_device
*sd
)
896 /* Open the sound device. Default is "default". */
897 struct alsa_params
*p
= xmalloc (sizeof *p
);
898 char const *file
= string_default (sd
->file
, DEFAULT_ALSA_SOUND_DEVICE
);
909 err
= snd_pcm_open (&p
->handle
, file
, SND_PCM_STREAM_PLAYBACK
, 0);
911 alsa_sound_perror (file
, err
);
915 alsa_period_size (struct sound_device
*sd
)
917 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
918 int fact
= snd_pcm_format_size (sd
->format
, 1) * sd
->channels
;
919 return p
->period_size
* (fact
> 0 ? fact
: 1);
923 alsa_configure (struct sound_device
*sd
)
927 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
928 snd_pcm_uframes_t buffer_size
;
930 eassert (p
->handle
!= 0);
932 err
= snd_pcm_hw_params_malloc (&p
->hwparams
);
934 alsa_sound_perror ("Could not allocate hardware parameter structure", err
);
936 err
= snd_pcm_sw_params_malloc (&p
->swparams
);
938 alsa_sound_perror ("Could not allocate software parameter structure", err
);
940 err
= snd_pcm_hw_params_any (p
->handle
, p
->hwparams
);
942 alsa_sound_perror ("Could not initialize hardware parameter structure", err
);
944 err
= snd_pcm_hw_params_set_access (p
->handle
, p
->hwparams
,
945 SND_PCM_ACCESS_RW_INTERLEAVED
);
947 alsa_sound_perror ("Could not set access type", err
);
950 err
= snd_pcm_hw_params_set_format (p
->handle
, p
->hwparams
, val
);
952 alsa_sound_perror ("Could not set sound format", err
);
954 uval
= sd
->sample_rate
;
955 err
= snd_pcm_hw_params_set_rate_near (p
->handle
, p
->hwparams
, &uval
, 0);
957 alsa_sound_perror ("Could not set sample rate", err
);
960 err
= snd_pcm_hw_params_set_channels (p
->handle
, p
->hwparams
, val
);
962 alsa_sound_perror ("Could not set channel count", err
);
964 err
= snd_pcm_hw_params (p
->handle
, p
->hwparams
);
966 alsa_sound_perror ("Could not set parameters", err
);
969 err
= snd_pcm_hw_params_get_period_size (p
->hwparams
, &p
->period_size
, &dir
);
971 alsa_sound_perror ("Unable to get period size for playback", err
);
973 err
= snd_pcm_hw_params_get_buffer_size (p
->hwparams
, &buffer_size
);
975 alsa_sound_perror ("Unable to get buffer size for playback", err
);
977 err
= snd_pcm_sw_params_current (p
->handle
, p
->swparams
);
979 alsa_sound_perror ("Unable to determine current swparams for playback",
982 /* Start the transfer when the buffer is almost full */
983 err
= snd_pcm_sw_params_set_start_threshold (p
->handle
, p
->swparams
,
984 (buffer_size
/ p
->period_size
)
987 alsa_sound_perror ("Unable to set start threshold mode for playback", err
);
989 /* Allow the transfer when at least period_size samples can be processed */
990 err
= snd_pcm_sw_params_set_avail_min (p
->handle
, p
->swparams
, p
->period_size
);
992 alsa_sound_perror ("Unable to set avail min for playback", err
);
994 err
= snd_pcm_sw_params (p
->handle
, p
->swparams
);
996 alsa_sound_perror ("Unable to set sw params for playback\n", err
);
998 snd_pcm_hw_params_free (p
->hwparams
);
1000 snd_pcm_sw_params_free (p
->swparams
);
1003 err
= snd_pcm_prepare (p
->handle
);
1005 alsa_sound_perror ("Could not prepare audio interface for use", err
);
1010 snd_mixer_t
*handle
;
1011 snd_mixer_elem_t
*e
;
1012 if (snd_mixer_open (&handle
, 0) >= 0)
1014 char const *file
= string_default (sd
->file
,
1015 DEFAULT_ALSA_SOUND_DEVICE
);
1016 if (snd_mixer_attach (handle
, file
) >= 0
1017 && snd_mixer_load (handle
) >= 0
1018 && snd_mixer_selem_register (handle
, NULL
, NULL
) >= 0)
1019 for (e
= snd_mixer_first_elem (handle
);
1021 e
= snd_mixer_elem_next (e
))
1023 if (snd_mixer_selem_has_playback_volume (e
))
1025 long pmin
, pmax
, vol
;
1026 snd_mixer_selem_get_playback_volume_range (e
, &pmin
, &pmax
);
1027 vol
= pmin
+ (sd
->volume
* (pmax
- pmin
)) / 100;
1029 for (chn
= 0; chn
<= SND_MIXER_SCHN_LAST
; chn
++)
1030 snd_mixer_selem_set_playback_volume (e
, chn
, vol
);
1033 snd_mixer_close (handle
);
1039 /* Close device SD if it is open. */
1042 alsa_close (struct sound_device
*sd
)
1044 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
1048 snd_pcm_hw_params_free (p
->hwparams
);
1050 snd_pcm_sw_params_free (p
->swparams
);
1053 snd_pcm_drain (p
->handle
);
1054 snd_pcm_close (p
->handle
);
1060 /* Choose device-dependent format for device SD from sound file S. */
1063 alsa_choose_format (struct sound_device
*sd
, struct sound
*s
)
1065 if (s
->type
== RIFF
)
1067 struct wav_header
*h
= (struct wav_header
*) s
->header
;
1068 if (h
->precision
== 8)
1069 sd
->format
= SND_PCM_FORMAT_U8
;
1070 else if (h
->precision
== 16)
1071 sd
->format
= SND_PCM_FORMAT_S16_LE
;
1073 error ("Unsupported WAV file format");
1075 else if (s
->type
== SUN_AUDIO
)
1077 struct au_header
*header
= (struct au_header
*) s
->header
;
1078 switch (header
->encoding
)
1080 case AU_ENCODING_ULAW_8
:
1081 sd
->format
= SND_PCM_FORMAT_MU_LAW
;
1083 case AU_ENCODING_ALAW_8
:
1084 sd
->format
= SND_PCM_FORMAT_A_LAW
;
1086 case AU_ENCODING_IEEE32
:
1087 sd
->format
= SND_PCM_FORMAT_FLOAT_BE
;
1089 case AU_ENCODING_IEEE64
:
1090 sd
->format
= SND_PCM_FORMAT_FLOAT64_BE
;
1093 sd
->format
= SND_PCM_FORMAT_S8
;
1095 case AU_ENCODING_16
:
1096 sd
->format
= SND_PCM_FORMAT_S16_BE
;
1098 case AU_ENCODING_24
:
1099 sd
->format
= SND_PCM_FORMAT_S24_BE
;
1101 case AU_ENCODING_32
:
1102 sd
->format
= SND_PCM_FORMAT_S32_BE
;
1106 error ("Unsupported AU file format");
1114 /* Write NBYTES bytes from BUFFER to device SD. */
1117 alsa_write (struct sound_device
*sd
, const char *buffer
, ptrdiff_t nbytes
)
1119 struct alsa_params
*p
= (struct alsa_params
*) sd
->data
;
1121 /* The the third parameter to snd_pcm_writei is frames, not bytes. */
1122 int fact
= snd_pcm_format_size (sd
->format
, 1) * sd
->channels
;
1123 ptrdiff_t nwritten
= 0;
1126 while (nwritten
< nbytes
)
1128 snd_pcm_uframes_t frames
= (nbytes
- nwritten
)/fact
;
1129 if (frames
== 0) break;
1131 err
= snd_pcm_writei (p
->handle
, buffer
+ nwritten
, frames
);
1136 err
= snd_pcm_prepare (p
->handle
);
1138 alsa_sound_perror ("Can't recover from underrun, prepare failed",
1141 else if (err
== -ESTRPIPE
)
1143 while ((err
= snd_pcm_resume (p
->handle
)) == -EAGAIN
)
1144 sleep (1); /* wait until the suspend flag is released */
1147 err
= snd_pcm_prepare (p
->handle
);
1149 alsa_sound_perror ("Can't recover from suspend, "
1155 alsa_sound_perror ("Error writing to sound device", err
);
1159 nwritten
+= err
* fact
;
1164 snd_error_quiet (const char *file
, int line
, const char *function
, int err
,
1169 /* Initialize device SD. Set up the interface functions in the device
1173 alsa_init (struct sound_device
*sd
)
1175 /* Open the sound device. Default is "default". */
1176 char const *file
= string_default (sd
->file
, DEFAULT_ALSA_SOUND_DEVICE
);
1180 snd_lib_error_set_handler ((snd_lib_error_handler_t
) snd_error_quiet
);
1181 err
= snd_pcm_open (&handle
, file
, SND_PCM_STREAM_PLAYBACK
, 0);
1182 snd_lib_error_set_handler (NULL
);
1185 snd_pcm_close (handle
);
1188 sd
->open
= alsa_open
;
1189 sd
->close
= alsa_close
;
1190 sd
->configure
= alsa_configure
;
1191 sd
->choose_format
= alsa_choose_format
;
1192 sd
->write
= alsa_write
;
1193 sd
->period_size
= alsa_period_size
;
1198 #endif /* HAVE_ALSA */
1201 /* END: Non Windows functions */
1202 #else /* WINDOWSNT */
1204 /* BEGIN: Windows specific functions */
1206 #define SOUND_WARNING(func, error, text) \
1209 char err_string[MAXERRORLENGTH]; \
1210 func (error, err_string, sizeof (err_string)); \
1211 _snprintf (buf, sizeof (buf), "%s\nMCI Error: %s", \
1212 text, err_string); \
1213 message_with_string ("%s", build_string (buf), 1); \
1217 do_play_sound (const char *psz_file
, unsigned long ui_volume
)
1220 MCIERROR mci_error
= 0;
1221 char sz_cmd_buf_a
[520];
1222 char sz_ret_buf_a
[520];
1223 MMRESULT mm_result
= MMSYSERR_NOERROR
;
1224 unsigned long ui_volume_org
= 0;
1225 BOOL b_reset_volume
= FALSE
;
1226 char warn_text
[560];
1228 /* Since UNICOWS.DLL includes only a stub for mciSendStringW, we
1229 need to encode the file in the ANSI codepage on Windows 9X even
1230 if w32_unicode_filenames is non-zero. */
1231 if (w32_major_version
<= 4 || !w32_unicode_filenames
)
1233 char fname_a
[MAX_PATH
], shortname
[MAX_PATH
], *fname_to_use
;
1235 filename_to_ansi (psz_file
, fname_a
);
1236 fname_to_use
= fname_a
;
1237 /* If the file name is not encodable in ANSI, try its short 8+3
1238 alias. This will only work if w32_unicode_filenames is
1240 if (_mbspbrk ((const unsigned char *)fname_a
,
1241 (const unsigned char *)"?"))
1243 if (w32_get_short_filename (psz_file
, shortname
, MAX_PATH
))
1244 fname_to_use
= shortname
;
1246 mci_error
= MCIERR_FILE_NOT_FOUND
;
1251 memset (sz_cmd_buf_a
, 0, sizeof (sz_cmd_buf_a
));
1252 memset (sz_ret_buf_a
, 0, sizeof (sz_ret_buf_a
));
1253 sprintf (sz_cmd_buf_a
,
1254 "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
1256 mci_error
= mciSendStringA (sz_cmd_buf_a
,
1257 sz_ret_buf_a
, sizeof (sz_ret_buf_a
), NULL
);
1262 wchar_t sz_cmd_buf_w
[520];
1263 wchar_t sz_ret_buf_w
[520];
1264 wchar_t fname_w
[MAX_PATH
];
1266 filename_to_utf16 (psz_file
, fname_w
);
1267 memset (sz_cmd_buf_w
, 0, sizeof (sz_cmd_buf_w
));
1268 memset (sz_ret_buf_w
, 0, sizeof (sz_ret_buf_w
));
1269 /* _swprintf is not available on Windows 9X, so we construct the
1270 UTF-16 command string by hand. */
1271 wcscpy (sz_cmd_buf_w
, L
"open \"");
1272 wcscat (sz_cmd_buf_w
, fname_w
);
1273 wcscat (sz_cmd_buf_w
, L
"\" alias GNUEmacs_PlaySound_Device wait");
1274 mci_error
= mciSendStringW (sz_cmd_buf_w
,
1275 sz_ret_buf_w
, ARRAYELTS (sz_ret_buf_w
) , NULL
);
1280 "mciSendString: 'open' command failed to open sound file ");
1281 strcat (warn_text
, psz_file
);
1282 SOUND_WARNING (mciGetErrorString
, mci_error
, warn_text
);
1283 i_result
= (int) mci_error
;
1286 if ((ui_volume
> 0) && (ui_volume
!= UINT_MAX
))
1288 mm_result
= waveOutGetVolume ((HWAVEOUT
) WAVE_MAPPER
, &ui_volume_org
);
1289 if (mm_result
== MMSYSERR_NOERROR
)
1291 b_reset_volume
= TRUE
;
1292 mm_result
= waveOutSetVolume ((HWAVEOUT
) WAVE_MAPPER
, ui_volume
);
1293 if (mm_result
!= MMSYSERR_NOERROR
)
1295 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1296 "waveOutSetVolume: failed to set the volume level"
1297 " of the WAVE_MAPPER device.\n"
1298 "As a result, the user selected volume level will"
1304 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1305 "waveOutGetVolume: failed to obtain the original"
1306 " volume level of the WAVE_MAPPER device.\n"
1307 "As a result, the user selected volume level will"
1311 memset (sz_cmd_buf_a
, 0, sizeof (sz_cmd_buf_a
));
1312 memset (sz_ret_buf_a
, 0, sizeof (sz_ret_buf_a
));
1313 strcpy (sz_cmd_buf_a
, "play GNUEmacs_PlaySound_Device wait");
1314 mci_error
= mciSendStringA (sz_cmd_buf_a
, sz_ret_buf_a
, sizeof (sz_ret_buf_a
),
1319 "mciSendString: 'play' command failed to play sound file ");
1320 strcat (warn_text
, psz_file
);
1321 SOUND_WARNING (mciGetErrorString
, mci_error
, warn_text
);
1322 i_result
= (int) mci_error
;
1324 memset (sz_cmd_buf_a
, 0, sizeof (sz_cmd_buf_a
));
1325 memset (sz_ret_buf_a
, 0, sizeof (sz_ret_buf_a
));
1326 strcpy (sz_cmd_buf_a
, "close GNUEmacs_PlaySound_Device wait");
1327 mci_error
= mciSendStringA (sz_cmd_buf_a
, sz_ret_buf_a
, sizeof (sz_ret_buf_a
),
1329 if (b_reset_volume
== TRUE
)
1331 mm_result
= waveOutSetVolume ((HWAVEOUT
) WAVE_MAPPER
, ui_volume_org
);
1332 if (mm_result
!= MMSYSERR_NOERROR
)
1334 SOUND_WARNING (waveOutGetErrorText
, mm_result
,
1335 "waveOutSetVolume: failed to reset the original"
1336 " volume level of the WAVE_MAPPER device.");
1342 /* END: Windows specific functions */
1344 #endif /* WINDOWSNT */
1346 DEFUN ("play-sound-internal", Fplay_sound_internal
, Splay_sound_internal
, 1, 1, 0,
1347 doc
: /* Play sound SOUND.
1349 Internal use only, use `play-sound' instead. */)
1352 Lisp_Object attrs
[SOUND_ATTR_SENTINEL
];
1353 ptrdiff_t count
= SPECPDL_INDEX ();
1356 unsigned long ui_volume_tmp
= UINT_MAX
;
1357 unsigned long ui_volume
= UINT_MAX
;
1358 #endif /* WINDOWSNT */
1360 /* Parse the sound specification. Give up if it is invalid. */
1361 if (!parse_sound (sound
, attrs
))
1362 error ("Invalid sound specification");
1364 Lisp_Object file
= Qnil
;
1367 current_sound_device
= xzalloc (sizeof *current_sound_device
);
1368 current_sound
= xzalloc (sizeof *current_sound
);
1369 record_unwind_protect_void (sound_cleanup
);
1370 char headerbuf
[MAX_SOUND_HEADER_BYTES
];
1371 current_sound
->header
= headerbuf
;
1373 if (STRINGP (attrs
[SOUND_FILE
]))
1375 /* Open the sound file. */
1376 current_sound
->fd
= openp (list1 (Vdata_directory
),
1377 attrs
[SOUND_FILE
], Qnil
, &file
, Qnil
, false);
1378 if (current_sound
->fd
< 0)
1379 sound_perror ("Could not open sound file");
1381 /* Read the first bytes from the file. */
1382 current_sound
->header_size
1383 = emacs_read (current_sound
->fd
, current_sound
->header
,
1384 MAX_SOUND_HEADER_BYTES
);
1385 if (current_sound
->header_size
< 0)
1386 sound_perror ("Invalid sound file header");
1390 current_sound
->data
= attrs
[SOUND_DATA
];
1391 current_sound
->header_size
= min (MAX_SOUND_HEADER_BYTES
, SBYTES (current_sound
->data
));
1392 memcpy (current_sound
->header
, SDATA (current_sound
->data
),
1393 current_sound
->header_size
);
1396 /* Find out the type of sound. Give up if we can't tell. */
1397 find_sound_type (current_sound
);
1399 /* Set up a device. */
1400 current_sound_device
->file
= 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 CALLN (Frun_hook_with_args
, Qplay_sound_functions
, sound
);
1410 if (!alsa_init (current_sound_device
))
1412 if (!vox_init (current_sound_device
))
1413 error ("No usable sound device driver found");
1415 /* Open the device. */
1416 current_sound_device
->open (current_sound_device
);
1418 /* Play the sound. */
1419 current_sound
->play (current_sound
, current_sound_device
);
1421 #else /* WINDOWSNT */
1423 file
= Fexpand_file_name (attrs
[SOUND_FILE
], Vdata_directory
);
1424 file
= ENCODE_FILE (file
);
1425 if (INTEGERP (attrs
[SOUND_VOLUME
]))
1427 ui_volume_tmp
= XFASTINT (attrs
[SOUND_VOLUME
]);
1429 else if (FLOATP (attrs
[SOUND_VOLUME
]))
1431 ui_volume_tmp
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]) * 100;
1434 CALLN (Frun_hook_with_args
, Qplay_sound_functions
, sound
);
1437 Based on some experiments I have conducted, a value of 100 or less
1438 for the sound volume is much too low. You cannot even hear it.
1439 A value of UINT_MAX indicates that you wish for the sound to played
1440 at the maximum possible volume. A value of UINT_MAX/2 plays the
1441 sound at 50% maximum volume. Therefore the value passed to do_play_sound
1442 (and thus to waveOutSetVolume) must be some fraction of UINT_MAX.
1443 The following code adjusts the user specified volume level appropriately.
1445 if ((ui_volume_tmp
> 0) && (ui_volume_tmp
<= 100))
1447 ui_volume
= ui_volume_tmp
* (UINT_MAX
/ 100);
1449 (void)do_play_sound (SSDATA (file
), ui_volume
);
1451 #endif /* WINDOWSNT */
1453 return unbind_to (count
, Qnil
);
1456 /***********************************************************************
1458 ***********************************************************************/
1461 syms_of_sound (void)
1463 DEFSYM (QCdevice
, ":device");
1464 DEFSYM (QCvolume
, ":volume");
1465 DEFSYM (Qsound
, "sound");
1466 DEFSYM (Qplay_sound_functions
, "play-sound-functions");
1468 defsubr (&Splay_sound_internal
);
1471 #endif /* HAVE_SOUND */