HCoop / bpt / emacs.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
deactive->inactive, inactivate->deactivate spelling fixes (Bug#10150)
[bpt/emacs.git] / src / sound.c
... / ...
CommitLineData
1/* sound.c -- sound support.
2
3Copyright (C) 1998-1999, 2001-2012 Free Software Foundation, Inc.
4
5This file is part of GNU Emacs.
6
7GNU Emacs is free software: you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19
20/* Written by Gerd Moellmann <gerd@gnu.org>. Tested with Luigi's
21 driver on FreeBSD 2.2.7 with a SoundBlaster 16. */
22
23/*
24 Modified by Ben Key <Bkey1@tampabay.rr.com> to add a partial
25 implementation of the play-sound specification for Windows.
26
27 Notes:
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.
32
33 The Windows implementation of play-sound is implemented via the
34 Win32 API functions mciSendString, waveOutGetVolume, and
35 waveOutSetVolume which are exported by Winmm.dll.
36*/
37
38#include <config.h>
39
40#if defined HAVE_SOUND
41
42/* BEGIN: Common Includes */
43#include <fcntl.h>
44#include <unistd.h>
45#include <sys/types.h>
46#include <errno.h>
47#include <setjmp.h>
48#include "lisp.h"
49#include "dispextern.h"
50#include "atimer.h"
51#include <signal.h>
52#include "syssignal.h"
53/* END: Common Includes */
54
55
56/* BEGIN: Non Windows Includes */
57#ifndef WINDOWSNT
58
59#include <sys/ioctl.h>
60
61/* FreeBSD has machine/soundcard.h. Voxware sound driver docs mention
62 sys/soundcard.h. So, let's try whatever's there. */
63
64#ifdef HAVE_MACHINE_SOUNDCARD_H
65#include <machine/soundcard.h>
66#endif
67#ifdef HAVE_SYS_SOUNDCARD_H
68#include <sys/soundcard.h>
69#endif
70#ifdef HAVE_SOUNDCARD_H
71#include <soundcard.h>
72#endif
73#ifdef HAVE_ALSA
74#ifdef ALSA_SUBDIR_INCLUDE
75#include <alsa/asoundlib.h>
76#else
77#include <asoundlib.h>
78#endif /* ALSA_SUBDIR_INCLUDE */
79#endif /* HAVE_ALSA */
80
81/* END: Non Windows Includes */
82
83#else /* WINDOWSNT */
84
85/* BEGIN: Windows Specific Includes */
86#include <stdio.h>
87#include <limits.h>
88#include <windows.h>
89#include <mmsystem.h>
90/* END: Windows Specific Includes */
91
92#endif /* WINDOWSNT */
93
94/* BEGIN: Common Definitions */
95
96/* Symbols. */
97
98static Lisp_Object QCvolume, QCdevice;
99static Lisp_Object Qsound;
100static Lisp_Object Qplay_sound_functions;
101
102/* Indices of attributes in a sound attributes vector. */
103
104enum sound_attr
105{
106 SOUND_FILE,
107 SOUND_DATA,
108 SOUND_DEVICE,
109 SOUND_VOLUME,
110 SOUND_ATTR_SENTINEL
111};
112
113/* END: Common Definitions */
114
115/* BEGIN: Non Windows Definitions */
116#ifndef WINDOWSNT
117
118/* Structure forward declarations. */
119
120struct sound;
121struct sound_device;
122
123/* The file header of RIFF-WAVE files (*.wav). Files are always in
124 little-endian byte-order. */
125
126struct wav_header
127{
128 u_int32_t magic;
129 u_int32_t length;
130 u_int32_t chunk_type;
131 u_int32_t chunk_format;
132 u_int32_t chunk_length;
133 u_int16_t format;
134 u_int16_t channels;
135 u_int32_t sample_rate;
136 u_int32_t bytes_per_second;
137 u_int16_t sample_size;
138 u_int16_t precision;
139 u_int32_t chunk_data;
140 u_int32_t data_length;
141};
142
143/* The file header of Sun adio files (*.au). Files are always in
144 big-endian byte-order. */
145
146struct au_header
147{
148 /* ASCII ".snd" */
149 u_int32_t magic_number;
150
151 /* Offset of data part from start of file. Minimum value is 24. */
152 u_int32_t data_offset;
153
154 /* Size of data part, 0xffffffff if unknown. */
155 u_int32_t data_size;
156
157 /* Data encoding format.
158 1 8-bit ISDN u-law
159 2 8-bit linear PCM (REF-PCM)
160 3 16-bit linear PCM
161 4 24-bit linear PCM
162 5 32-bit linear 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
166 encoding scheme. */
167 u_int32_t encoding;
168
169 /* Number of samples per second. */
170 u_int32_t sample_rate;
171
172 /* Number of interleaved channels. */
173 u_int32_t channels;
174};
175
176/* Maximum of all sound file headers sizes. */
177
178#define MAX_SOUND_HEADER_BYTES \
179 max (sizeof (struct wav_header), sizeof (struct au_header))
180
181/* Interface structure for sound devices. */
182
183struct sound_device
184{
185 /* The name of the device or null meaning use a default device name. */
186 char *file;
187
188 /* File descriptor of the device. */
189 int fd;
190
191 /* Device-dependent format. */
192 int format;
193
194 /* Volume (0..100). Zero means unspecified. */
195 int volume;
196
197 /* Sample size. */
198 int sample_size;
199
200 /* Sample rate. */
201 int sample_rate;
202
203 /* Bytes per second. */
204 int bps;
205
206 /* 1 = mono, 2 = stereo, 0 = don't set. */
207 int channels;
208
209 /* Open device SD. */
210 void (* open) (struct sound_device *sd);
211
212 /* Close device SD. */
213 void (* close) (struct sound_device *sd);
214
215 /* Configure SD according to device-dependent parameters. */
216 void (* configure) (struct sound_device *device);
217
218 /* Choose a device-dependent format for outputting sound S. */
219 void (* choose_format) (struct sound_device *sd,
220 struct sound *s);
221
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);
225
226 /* Write NYBTES bytes from BUFFER to device SD. */
227 void (* write) (struct sound_device *sd, const char *buffer,
228 ptrdiff_t nbytes);
229
230 /* A place for devices to store additional data. */
231 void *data;
232};
233
234/* An enumerator for each supported sound file type. */
235
236enum sound_type
237{
238 RIFF,
239 SUN_AUDIO
240};
241
242/* Interface structure for sound files. */
243
244struct sound
245{
246 /* The type of the file. */
247 enum sound_type type;
248
249 /* File descriptor of a sound file. */
250 int fd;
251
252 /* Pointer to sound file header. This contains header_size bytes
253 read from the start of a sound file. */
254 char *header;
255
256 /* Number of bytes read from sound file. This is always <=
257 MAX_SOUND_HEADER_BYTES. */
258 int header_size;
259
260 /* Sound data, if a string. */
261 Lisp_Object data;
262
263 /* Play sound file S on device SD. */
264 void (* play) (struct sound *s, struct sound_device *sd);
265};
266
267/* These are set during `play-sound-internal' so that sound_cleanup has
268 access to them. */
269
270static struct sound_device *current_sound_device;
271static struct sound *current_sound;
272
273/* Function prototypes. */
274
275static void vox_open (struct sound_device *);
276static void vox_configure (struct sound_device *);
277static void vox_close (struct sound_device *sd);
278static void vox_choose_format (struct sound_device *, struct sound *);
279static int vox_init (struct sound_device *);
280static void vox_write (struct sound_device *, const char *, ptrdiff_t);
281static void find_sound_type (struct sound *);
282static u_int32_t le2hl (u_int32_t);
283static u_int16_t le2hs (u_int16_t);
284static u_int32_t be2hl (u_int32_t);
285static int wav_init (struct sound *);
286static void wav_play (struct sound *, struct sound_device *);
287static int au_init (struct sound *);
288static void au_play (struct sound *, struct sound_device *);
289
290#if 0 /* Currently not used. */
291static u_int16_t be2hs (u_int16_t);
292#endif
293
294/* END: Non Windows Definitions */
295#else /* WINDOWSNT */
296
297/* BEGIN: Windows Specific Definitions */
298static int do_play_sound (const char *, unsigned long);
299/*
300 END: Windows Specific Definitions */
301#endif /* WINDOWSNT */
302
303\f
304/***********************************************************************
305 General
306 ***********************************************************************/
307
308/* BEGIN: Common functions */
309
310/* Like perror, but signals an error. */
311
312static _Noreturn void
313sound_perror (const char *msg)
314{
315 int saved_errno = errno;
316
317 turn_on_atimers (1);
318#ifdef SIGIO
319 sigunblock (sigmask (SIGIO));
320#endif
321 if (saved_errno != 0)
322 error ("%s: %s", msg, strerror (saved_errno));
323 else
324 error ("%s", msg);
325}
326
327
328/* Display a warning message. */
329
330static void
331sound_warning (const char *msg)
332{
333 message ("%s", msg);
334}
335
336
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:
342
343 - `:file FILE'
344
345 FILE is the sound file to play. If it isn't an absolute name,
346 it's searched under `data-directory'.
347
348 - `:data DATA'
349
350 DATA is a string containing sound data. Either :file or :data
351 may be present, but not both.
352
353 - `:device DEVICE'
354
355 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
356 If not specified, a default device is used.
357
358 - `:volume VOL'
359
360 VOL must be an integer in the range [0, 100], or a float in the
361 range [0, 1]. */
362
363static int
364parse_sound (Lisp_Object sound, Lisp_Object *attrs)
365{
366 /* SOUND must be a list starting with the symbol `sound'. */
367 if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
368 return 0;
369
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);
375
376#ifndef WINDOWSNT
377 /* File name or data must be specified. */
378 if (!STRINGP (attrs[SOUND_FILE])
379 && !STRINGP (attrs[SOUND_DATA]))
380 return 0;
381#else /* WINDOWSNT */
382 /*
383 Data is not supported in Windows. Therefore a
384 File name MUST be supplied.
385 */
386 if (!STRINGP (attrs[SOUND_FILE]))
387 {
388 return 0;
389 }
390#endif /* WINDOWSNT */
391
392 /* Volume must be in the range 0..100 or unspecified. */
393 if (!NILP (attrs[SOUND_VOLUME]))
394 {
395 if (INTEGERP (attrs[SOUND_VOLUME]))
396 {
397 if (XINT (attrs[SOUND_VOLUME]) < 0
398 || XINT (attrs[SOUND_VOLUME]) > 100)
399 return 0;
400 }
401 else if (FLOATP (attrs[SOUND_VOLUME]))
402 {
403 if (XFLOAT_DATA (attrs[SOUND_VOLUME]) < 0
404 || XFLOAT_DATA (attrs[SOUND_VOLUME]) > 1)
405 return 0;
406 }
407 else
408 return 0;
409 }
410
411#ifndef WINDOWSNT
412 /* Device must be a string or unspecified. */
413 if (!NILP (attrs[SOUND_DEVICE])
414 && !STRINGP (attrs[SOUND_DEVICE]))
415 return 0;
416#endif /* WINDOWSNT */
417 /*
418 Since device is ignored in Windows, it does not matter
419 what it is.
420 */
421 return 1;
422}
423
424/* END: Common functions */
425
426/* BEGIN: Non Windows functions */
427#ifndef WINDOWSNT
428
429/* Find out the type of the sound file whose file descriptor is FD.
430 S is the sound file structure to fill in. */
431
432static void
433find_sound_type (struct sound *s)
434{
435 if (!wav_init (s) && !au_init (s))
436 error ("Unknown sound format");
437}
438
439
440/* Function installed by play-sound-internal with record_unwind_protect. */
441
442static Lisp_Object
443sound_cleanup (Lisp_Object arg)
444{
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);
451
452 return Qnil;
453}
454
455/***********************************************************************
456 Byte-order Conversion
457 ***********************************************************************/
458
459/* Convert 32-bit value VALUE which is in little-endian byte-order
460 to host byte-order. */
461
462static u_int32_t
463le2hl (u_int32_t value)
464{
465#ifdef WORDS_BIGENDIAN
466 unsigned char *p = (unsigned char *) &value;
467 value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
468#endif
469 return value;
470}
471
472
473/* Convert 16-bit value VALUE which is in little-endian byte-order
474 to host byte-order. */
475
476static u_int16_t
477le2hs (u_int16_t value)
478{
479#ifdef WORDS_BIGENDIAN
480 unsigned char *p = (unsigned char *) &value;
481 value = p[0] + (p[1] << 8);
482#endif
483 return value;
484}
485
486
487/* Convert 32-bit value VALUE which is in big-endian byte-order
488 to host byte-order. */
489
490static u_int32_t
491be2hl (u_int32_t value)
492{
493#ifndef WORDS_BIGENDIAN
494 unsigned char *p = (unsigned char *) &value;
495 value = p[3] + (p[2] << 8) + (p[1] << 16) + (p[0] << 24);
496#endif
497 return value;
498}
499
500
501#if 0 /* Currently not used. */
502
503/* Convert 16-bit value VALUE which is in big-endian byte-order
504 to host byte-order. */
505
506static u_int16_t
507be2hs (u_int16_t value)
508{
509#ifndef WORDS_BIGENDIAN
510 unsigned char *p = (unsigned char *) &value;
511 value = p[1] + (p[0] << 8);
512#endif
513 return value;
514}
515
516#endif /* 0 */
517
518/***********************************************************************
519 RIFF-WAVE (*.wav)
520 ***********************************************************************/
521
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. */
527
528static int
529wav_init (struct sound *s)
530{
531 struct wav_header *header = (struct wav_header *) s->header;
532
533 if (s->header_size < sizeof *header
534 || memcmp (s->header, "RIFF", 4) != 0)
535 return 0;
536
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);
552
553 /* Set up the interface functions for WAV. */
554 s->type = RIFF;
555 s->play = wav_play;
556
557 return 1;
558}
559
560
561/* Play RIFF-WAVE audio file S on sound device SD. */
562
563static void
564wav_play (struct sound *s, struct sound_device *sd)
565{
566 struct wav_header *header = (struct wav_header *) s->header;
567
568 /* Let the device choose a suitable device-dependent format
569 for the file. */
570 sd->choose_format (sd, s);
571
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;
577 sd->configure (sd);
578
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);
586 else
587 {
588 char *buffer;
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;
592
593 buffer = alloca (blksize);
594 lseek (s->fd, sizeof *header, SEEK_SET);
595 while (data_left > 0
596 && (nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
597 {
598 /* Don't play possible garbage at the end of file */
599 if (data_left < nbytes) nbytes = data_left;
600 data_left -= nbytes;
601 sd->write (sd, buffer, nbytes);
602 }
603
604 if (nbytes < 0)
605 sound_perror ("Error reading sound file");
606 }
607}
608
609
610/***********************************************************************
611 Sun Audio (*.au)
612 ***********************************************************************/
613
614/* Sun audio file encodings. */
615
616enum au_encoding
617{
618 AU_ENCODING_ULAW_8 = 1,
619 AU_ENCODING_8,
620 AU_ENCODING_16,
621 AU_ENCODING_24,
622 AU_ENCODING_32,
623 AU_ENCODING_IEEE32,
624 AU_ENCODING_IEEE64,
625 AU_COMPRESSED = 23,
626 AU_ENCODING_ALAW_8 = 27
627};
628
629
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. */
635
636static int
637au_init (struct sound *s)
638{
639 struct au_header *header = (struct au_header *) s->header;
640
641 if (s->header_size < sizeof *header
642 || memcmp (s->header, ".snd", 4) != 0)
643 return 0;
644
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);
651
652 /* Set up the interface functions for AU. */
653 s->type = SUN_AUDIO;
654 s->play = au_play;
655
656 return 1;
657}
658
659
660/* Play Sun audio file S on sound device SD. */
661
662static void
663au_play (struct sound *s, struct sound_device *sd)
664{
665 struct au_header *header = (struct au_header *) s->header;
666
667 sd->sample_size = 0;
668 sd->sample_rate = header->sample_rate;
669 sd->bps = 0;
670 sd->channels = header->channels;
671 sd->choose_format (sd, s);
672 sd->configure (sd);
673
674 if (STRINGP (s->data))
675 sd->write (sd, SSDATA (s->data) + header->data_offset,
676 SBYTES (s->data) - header->data_offset);
677 else
678 {
679 ptrdiff_t blksize = sd->period_size ? sd->period_size (sd) : 2048;
680 char *buffer;
681 ptrdiff_t nbytes;
682
683 /* Seek */
684 lseek (s->fd, header->data_offset, SEEK_SET);
685
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);
690
691 if (nbytes < 0)
692 sound_perror ("Error reading sound file");
693 }
694}
695
696
697/***********************************************************************
698 Voxware Driver Interface
699 ***********************************************************************/
700
701/* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
702 has a compatible own driver aka Luigi's driver. */
703
704
705/* Open device SD. If SD->file is non-null, open that device,
706 otherwise use a default device name. */
707
708static void
709vox_open (struct sound_device *sd)
710{
711 const char *file;
712
713 /* Open the sound device (eg /dev/dsp). */
714 if (sd->file)
715 file = sd->file;
716 else
717 file = DEFAULT_SOUND_DEVICE;
718
719 sd->fd = emacs_open (file, O_WRONLY, 0);
720 if (sd->fd < 0)
721 sound_perror (file);
722}
723
724
725/* Configure device SD from parameters in it. */
726
727static void
728vox_configure (struct sound_device *sd)
729{
730 int val;
731
732 eassert (sd->fd >= 0);
733
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
736 troubles. */
737 turn_on_atimers (0);
738#ifdef SIGIO
739 sigblock (sigmask (SIGIO));
740#endif
741
742 val = sd->format;
743 if (ioctl (sd->fd, SNDCTL_DSP_SETFMT, &sd->format) < 0
744 || val != sd->format)
745 sound_perror ("Could not set sound format");
746
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");
751
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)
755 {
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");
761 }
762
763 if (sd->volume > 0)
764 {
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);
769 }
770
771 turn_on_atimers (1);
772#ifdef SIGIO
773 sigunblock (sigmask (SIGIO));
774#endif
775}
776
777
778/* Close device SD if it is open. */
779
780static void
781vox_close (struct sound_device *sd)
782{
783 if (sd->fd >= 0)
784 {
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
787 troubles. */
788#ifdef SIGIO
789 sigblock (sigmask (SIGIO));
790#endif
791 turn_on_atimers (0);
792
793 /* Flush sound data, and reset the device. */
794 ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL);
795
796 turn_on_atimers (1);
797#ifdef SIGIO
798 sigunblock (sigmask (SIGIO));
799#endif
800
801 /* Close the device. */
802 emacs_close (sd->fd);
803 sd->fd = -1;
804 }
805}
806
807
808/* Choose device-dependent format for device SD from sound file S. */
809
810static void
811vox_choose_format (struct sound_device *sd, struct sound *s)
812{
813 if (s->type == RIFF)
814 {
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;
820 else
821 error ("Unsupported WAV file format");
822 }
823 else if (s->type == SUN_AUDIO)
824 {
825 struct au_header *header = (struct au_header *) s->header;
826 switch (header->encoding)
827 {
828 case AU_ENCODING_ULAW_8:
829 case AU_ENCODING_IEEE32:
830 case AU_ENCODING_IEEE64:
831 sd->format = AFMT_MU_LAW;
832 break;
833
834 case AU_ENCODING_8:
835 case AU_ENCODING_16:
836 case AU_ENCODING_24:
837 case AU_ENCODING_32:
838 sd->format = AFMT_S16_LE;
839 break;
840
841 default:
842 error ("Unsupported AU file format");
843 }
844 }
845 else
846 abort ();
847}
848
849
850/* Initialize device SD. Set up the interface functions in the device
851 structure. */
852
853static int
854vox_init (struct sound_device *sd)
855{
856 const char *file;
857 int fd;
858
859 /* Open the sound device (eg /dev/dsp). */
860 if (sd->file)
861 file = sd->file;
862 else
863 file = DEFAULT_SOUND_DEVICE;
864 fd = emacs_open (file, O_WRONLY, 0);
865 if (fd >= 0)
866 emacs_close (fd);
867 else
868 return 0;
869
870 sd->fd = -1;
871 sd->open = vox_open;
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;
877
878 return 1;
879}
880
881/* Write NBYTES bytes from BUFFER to device SD. */
882
883static void
884vox_write (struct sound_device *sd, const char *buffer, ptrdiff_t nbytes)
885{
886 if (emacs_write (sd->fd, buffer, nbytes) != nbytes)
887 sound_perror ("Error writing to sound device");
888}
889
890#ifdef HAVE_ALSA
891/***********************************************************************
892 ALSA Driver Interface
893 ***********************************************************************/
894
895/* This driver is available on GNU/Linux. */
896
897#ifndef DEFAULT_ALSA_SOUND_DEVICE
898#define DEFAULT_ALSA_SOUND_DEVICE "default"
899#endif
900
901static _Noreturn void
902alsa_sound_perror (const char *msg, int err)
903{
904 error ("%s: %s", msg, snd_strerror (err));
905}
906
907struct alsa_params
908{
909 snd_pcm_t *handle;
910 snd_pcm_hw_params_t *hwparams;
911 snd_pcm_sw_params_t *swparams;
912 snd_pcm_uframes_t period_size;
913};
914
915/* Open device SD. If SD->file is non-null, open that device,
916 otherwise use a default device name. */
917
918static void
919alsa_open (struct sound_device *sd)
920{
921 const char *file;
922 struct alsa_params *p;
923 int err;
924
925 /* Open the sound device. Default is "default". */
926 if (sd->file)
927 file = sd->file;
928 else
929 file = DEFAULT_ALSA_SOUND_DEVICE;
930
931 p = xmalloc (sizeof *p);
932 p->handle = NULL;
933 p->hwparams = NULL;
934 p->swparams = NULL;
935
936 sd->fd = -1;
937 sd->data = p;
938
939
940 err = snd_pcm_open (&p->handle, file, SND_PCM_STREAM_PLAYBACK, 0);
941 if (err < 0)
942 alsa_sound_perror (file, err);
943}
944
945static ptrdiff_t
946alsa_period_size (struct sound_device *sd)
947{
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);
951}
952
953static void
954alsa_configure (struct sound_device *sd)
955{
956 int val, err, dir;
957 unsigned uval;
958 struct alsa_params *p = (struct alsa_params *) sd->data;
959 snd_pcm_uframes_t buffer_size;
960
961 eassert (p->handle != 0);
962
963 err = snd_pcm_hw_params_malloc (&p->hwparams);
964 if (err < 0)
965 alsa_sound_perror ("Could not allocate hardware parameter structure", err);
966
967 err = snd_pcm_sw_params_malloc (&p->swparams);
968 if (err < 0)
969 alsa_sound_perror ("Could not allocate software parameter structure", err);
970
971 err = snd_pcm_hw_params_any (p->handle, p->hwparams);
972 if (err < 0)
973 alsa_sound_perror ("Could not initialize hardware parameter structure", err);
974
975 err = snd_pcm_hw_params_set_access (p->handle, p->hwparams,
976 SND_PCM_ACCESS_RW_INTERLEAVED);
977 if (err < 0)
978 alsa_sound_perror ("Could not set access type", err);
979
980 val = sd->format;
981 err = snd_pcm_hw_params_set_format (p->handle, p->hwparams, val);
982 if (err < 0)
983 alsa_sound_perror ("Could not set sound format", err);
984
985 uval = sd->sample_rate;
986 err = snd_pcm_hw_params_set_rate_near (p->handle, p->hwparams, &uval, 0);
987 if (err < 0)
988 alsa_sound_perror ("Could not set sample rate", err);
989
990 val = sd->channels;
991 err = snd_pcm_hw_params_set_channels (p->handle, p->hwparams, val);
992 if (err < 0)
993 alsa_sound_perror ("Could not set channel count", err);
994
995 err = snd_pcm_hw_params (p->handle, p->hwparams);
996 if (err < 0)
997 alsa_sound_perror ("Could not set parameters", err);
998
999
1000 err = snd_pcm_hw_params_get_period_size (p->hwparams, &p->period_size, &dir);
1001 if (err < 0)
1002 alsa_sound_perror ("Unable to get period size for playback", err);
1003
1004 err = snd_pcm_hw_params_get_buffer_size (p->hwparams, &buffer_size);
1005 if (err < 0)
1006 alsa_sound_perror ("Unable to get buffer size for playback", err);
1007
1008 err = snd_pcm_sw_params_current (p->handle, p->swparams);
1009 if (err < 0)
1010 alsa_sound_perror ("Unable to determine current swparams for playback",
1011 err);
1012
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)
1016 * p->period_size);
1017 if (err < 0)
1018 alsa_sound_perror ("Unable to set start threshold mode for playback", err);
1019
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);
1022 if (err < 0)
1023 alsa_sound_perror ("Unable to set avail min for playback", err);
1024
1025 err = snd_pcm_sw_params (p->handle, p->swparams);
1026 if (err < 0)
1027 alsa_sound_perror ("Unable to set sw params for playback\n", err);
1028
1029 snd_pcm_hw_params_free (p->hwparams);
1030 p->hwparams = NULL;
1031 snd_pcm_sw_params_free (p->swparams);
1032 p->swparams = NULL;
1033
1034 err = snd_pcm_prepare (p->handle);
1035 if (err < 0)
1036 alsa_sound_perror ("Could not prepare audio interface for use", err);
1037
1038 if (sd->volume > 0)
1039 {
1040 int chn;
1041 snd_mixer_t *handle;
1042 snd_mixer_elem_t *e;
1043 const char *file = sd->file ? sd->file : DEFAULT_ALSA_SOUND_DEVICE;
1044
1045 if (snd_mixer_open (&handle, 0) >= 0)
1046 {
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);
1051 e;
1052 e = snd_mixer_elem_next (e))
1053 {
1054 if (snd_mixer_selem_has_playback_volume (e))
1055 {
1056 long pmin, pmax, vol;
1057 snd_mixer_selem_get_playback_volume_range (e, &pmin, &pmax);
1058 vol = pmin + (sd->volume * (pmax - pmin)) / 100;
1059
1060 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++)
1061 snd_mixer_selem_set_playback_volume (e, chn, vol);
1062 }
1063 }
1064 snd_mixer_close (handle);
1065 }
1066 }
1067}
1068
1069
1070/* Close device SD if it is open. */
1071
1072static void
1073alsa_close (struct sound_device *sd)
1074{
1075 struct alsa_params *p = (struct alsa_params *) sd->data;
1076 if (p)
1077 {
1078 if (p->hwparams)
1079 snd_pcm_hw_params_free (p->hwparams);
1080 if (p->swparams)
1081 snd_pcm_sw_params_free (p->swparams);
1082 if (p->handle)
1083 {
1084 snd_pcm_drain (p->handle);
1085 snd_pcm_close (p->handle);
1086 }
1087 xfree (p);
1088 }
1089}
1090
1091/* Choose device-dependent format for device SD from sound file S. */
1092
1093static void
1094alsa_choose_format (struct sound_device *sd, struct sound *s)
1095{
1096 if (s->type == RIFF)
1097 {
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;
1103 else
1104 error ("Unsupported WAV file format");
1105 }
1106 else if (s->type == SUN_AUDIO)
1107 {
1108 struct au_header *header = (struct au_header *) s->header;
1109 switch (header->encoding)
1110 {
1111 case AU_ENCODING_ULAW_8:
1112 sd->format = SND_PCM_FORMAT_MU_LAW;
1113 break;
1114 case AU_ENCODING_ALAW_8:
1115 sd->format = SND_PCM_FORMAT_A_LAW;
1116 break;
1117 case AU_ENCODING_IEEE32:
1118 sd->format = SND_PCM_FORMAT_FLOAT_BE;
1119 break;
1120 case AU_ENCODING_IEEE64:
1121 sd->format = SND_PCM_FORMAT_FLOAT64_BE;
1122 break;
1123 case AU_ENCODING_8:
1124 sd->format = SND_PCM_FORMAT_S8;
1125 break;
1126 case AU_ENCODING_16:
1127 sd->format = SND_PCM_FORMAT_S16_BE;
1128 break;
1129 case AU_ENCODING_24:
1130 sd->format = SND_PCM_FORMAT_S24_BE;
1131 break;
1132 case AU_ENCODING_32:
1133 sd->format = SND_PCM_FORMAT_S32_BE;
1134 break;
1135
1136 default:
1137 error ("Unsupported AU file format");
1138 }
1139 }
1140 else
1141 abort ();
1142}
1143
1144
1145/* Write NBYTES bytes from BUFFER to device SD. */
1146
1147static void
1148alsa_write (struct sound_device *sd, const char *buffer, ptrdiff_t nbytes)
1149{
1150 struct alsa_params *p = (struct alsa_params *) sd->data;
1151
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;
1155 int err;
1156
1157 while (nwritten < nbytes)
1158 {
1159 snd_pcm_uframes_t frames = (nbytes - nwritten)/fact;
1160 if (frames == 0) break;
1161
1162 err = snd_pcm_writei (p->handle, buffer + nwritten, frames);
1163 if (err < 0)
1164 {
1165 if (err == -EPIPE)
1166 { /* under-run */
1167 err = snd_pcm_prepare (p->handle);
1168 if (err < 0)
1169 alsa_sound_perror ("Can't recover from underrun, prepare failed",
1170 err);
1171 }
1172 else if (err == -ESTRPIPE)
1173 {
1174 while ((err = snd_pcm_resume (p->handle)) == -EAGAIN)
1175 sleep (1); /* wait until the suspend flag is released */
1176 if (err < 0)
1177 {
1178 err = snd_pcm_prepare (p->handle);
1179 if (err < 0)
1180 alsa_sound_perror ("Can't recover from suspend, "
1181 "prepare failed",
1182 err);
1183 }
1184 }
1185 else
1186 alsa_sound_perror ("Error writing to sound device", err);
1187
1188 }
1189 else
1190 nwritten += err * fact;
1191 }
1192}
1193
1194static void
1195snd_error_quiet (const char *file, int line, const char *function, int err,
1196 const char *fmt)
1197{
1198}
1199
1200/* Initialize device SD. Set up the interface functions in the device
1201 structure. */
1202
1203static int
1204alsa_init (struct sound_device *sd)
1205{
1206 const char *file;
1207 snd_pcm_t *handle;
1208 int err;
1209
1210 /* Open the sound device. Default is "default". */
1211 if (sd->file)
1212 file = sd->file;
1213 else
1214 file = DEFAULT_ALSA_SOUND_DEVICE;
1215
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);
1219 if (err < 0)
1220 return 0;
1221 snd_pcm_close (handle);
1222
1223 sd->fd = -1;
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;
1230
1231 return 1;
1232}
1233
1234#endif /* HAVE_ALSA */
1235
1236
1237/* END: Non Windows functions */
1238#else /* WINDOWSNT */
1239
1240/* BEGIN: Windows specific functions */
1241
1242#define SOUND_WARNING(fun, error, text) \
1243 { \
1244 char buf[1024]; \
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); \
1250 }
1251
1252static int
1253do_play_sound (const char *psz_file, unsigned long ui_volume)
1254{
1255 int i_result = 0;
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;
1262
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",
1267 psz_file);
1268 mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1269 if (mci_error != 0)
1270 {
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;
1275 return i_result;
1276 }
1277 if ((ui_volume > 0) && (ui_volume != UINT_MAX))
1278 {
1279 mm_result = waveOutGetVolume ((HWAVEOUT) WAVE_MAPPER, &ui_volume_org);
1280 if (mm_result == MMSYSERR_NOERROR)
1281 {
1282 b_reset_volume = TRUE;
1283 mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume);
1284 if (mm_result != MMSYSERR_NOERROR)
1285 {
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 "
1290 "not be used.");
1291 }
1292 }
1293 else
1294 {
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 "
1299 "not be used.");
1300 }
1301 }
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);
1306 if (mci_error != 0)
1307 {
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;
1312 }
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)
1318 {
1319 mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume_org);
1320 if (mm_result != MMSYSERR_NOERROR)
1321 {
1322 SOUND_WARNING (waveOutGetErrorText, mm_result,
1323 "waveOutSetVolume failed to reset the original volume "
1324 "level of the WAVE_MAPPER device.");
1325 }
1326 }
1327 return i_result;
1328}
1329
1330/* END: Windows specific functions */
1331
1332#endif /* WINDOWSNT */
1333
1334DEFUN ("play-sound-internal", Fplay_sound_internal, Splay_sound_internal, 1, 1, 0,
1335 doc: /* Play sound SOUND.
1336
1337Internal use only, use `play-sound' instead. */)
1338 (Lisp_Object sound)
1339{
1340 Lisp_Object attrs[SOUND_ATTR_SENTINEL];
1341 ptrdiff_t count = SPECPDL_INDEX ();
1342
1343#ifndef WINDOWSNT
1344 Lisp_Object file;
1345 struct gcpro gcpro1, gcpro2;
1346 Lisp_Object args[2];
1347#else /* WINDOWSNT */
1348 int len = 0;
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;
1353 int i_result = 0;
1354#endif /* WINDOWSNT */
1355
1356 /* Parse the sound specification. Give up if it is invalid. */
1357 if (!parse_sound (sound, attrs))
1358 error ("Invalid sound specification");
1359
1360#ifndef WINDOWSNT
1361 file = Qnil;
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);
1367
1368 if (STRINGP (attrs[SOUND_FILE]))
1369 {
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");
1375
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");
1382 }
1383 else
1384 {
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);
1389 }
1390
1391 /* Find out the type of sound. Give up if we can't tell. */
1392 find_sound_type (current_sound);
1393
1394 /* Set up a device. */
1395 if (STRINGP (attrs[SOUND_DEVICE]))
1396 {
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]));
1400 }
1401
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;
1406
1407 args[0] = Qplay_sound_functions;
1408 args[1] = sound;
1409 Frun_hook_with_args (2, args);
1410
1411#ifdef HAVE_ALSA
1412 if (!alsa_init (current_sound_device))
1413#endif
1414 if (!vox_init (current_sound_device))
1415 error ("No usable sound device driver found");
1416
1417 /* Open the device. */
1418 current_sound_device->open (current_sound_device);
1419
1420 /* Play the sound. */
1421 current_sound->play (current_sound, current_sound_device);
1422
1423 /* Clean up. */
1424 UNGCPRO;
1425
1426#else /* WINDOWSNT */
1427
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]))
1433 {
1434 ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
1435 }
1436 else if (FLOATP (attrs[SOUND_VOLUME]))
1437 {
1438 ui_volume_tmp = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
1439 }
1440 /*
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.
1448 */
1449 if ((ui_volume_tmp > 0) && (ui_volume_tmp <= 100))
1450 {
1451 ui_volume = ui_volume_tmp * (UINT_MAX / 100);
1452 }
1453 i_result = do_play_sound (psz_file, ui_volume);
1454
1455#endif /* WINDOWSNT */
1456
1457 unbind_to (count, Qnil);
1458 return Qnil;
1459}
1460\f
1461/***********************************************************************
1462 Initialization
1463 ***********************************************************************/
1464
1465void
1466syms_of_sound (void)
1467{
1468 DEFSYM (QCdevice, ":device");
1469 DEFSYM (QCvolume, ":volume");
1470 DEFSYM (Qsound, "sound");
1471 DEFSYM (Qplay_sound_functions, "play-sound-functions");
1472
1473 defsubr (&Splay_sound_internal);
1474}
1475
1476#endif /* HAVE_SOUND */
Unnamed repository; edit this file 'description' to name the repository.