1 /* sound.c -- sound support.
2 Copyright (C) 1998 Free Software Foundation.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Written by Gerd Moellmann <gerd@gnu.org>. Tested with Luigi's
22 driver on FreeBSD 2.2.7 with a SoundBlaster 16. */
26 #if defined HAVE_SOUND
31 #include <sys/types.h>
32 #include <dispextern.h>
35 /* FreeBSD has machine/soundcard.h. Voxware sound driver docs mention
36 sys/soundcard.h. So, let's try whatever's there. */
38 #ifdef HAVE_MACHINE_SOUNDCARD_H
39 #include <machine/soundcard.h>
41 #ifdef HAVE_SYS_SOUNDCARD_H
42 #include <sys/soundcard.h>
45 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
46 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
47 #define abs(X) ((X) < 0 ? -(X) : (X))
49 /* Structure forward declarations. */
54 /* The file header of RIFF-WAVE files (*.wav). Files are always in
55 little-endian byte-order. */
62 u_int32_t chunk_format
;
63 u_int32_t chunk_length
;
66 u_int32_t sample_rate
;
67 u_int32_t bytes_per_second
;
68 u_int16_t sample_size
;
71 u_int32_t data_length
;
74 /* The file header of Sun adio files (*.au). Files are always in
75 big-endian byte-order. */
80 u_int32_t magic_number
;
82 /* Offset of data part from start of file. Minimum value is 24. */
83 u_int32_t data_offset
;
85 /* Size of data part, 0xffffffff if unknown. */
88 /* Data encoding format.
90 2 8-bit linear PCM (REF-PCM)
94 6 32-bit IEEE floating-point
95 7 64-bit IEEE floating-point
96 23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
100 /* Number of samples per second. */
101 u_int32_t sample_rate
;
103 /* Number of interleaved channels. */
107 /* Maximum of all sound file headers sizes. */
109 #define MAX_SOUND_HEADER_BYTES \
110 max (sizeof (struct wav_header), sizeof (struct au_header))
112 /* Interface structure for sound devices. */
116 /* The name of the device or null meaning use a default device name. */
119 /* File descriptor of the device. */
122 /* Device-dependent format. */
125 /* Volume (0..100). Zero means unspecified. */
134 /* Bytes per second. */
137 /* 1 = mono, 2 = stereo, 0 = don't set. */
140 /* Open device SD. */
141 void (* open
) P_ ((struct sound_device
*sd
));
143 /* Close device SD. */
144 void (* close
) P_ ((struct sound_device
*sd
));
146 /* Configure SD accoring to device-dependent parameters. */
147 void (* configure
) P_ ((struct sound_device
*device
));
149 /* Choose a device-dependent format for outputting sound file SF. */
150 void (* choose_format
) P_ ((struct sound_device
*sd
,
151 struct sound_file
*sf
));
153 /* Write NYBTES bytes from BUFFER to device SD. */
154 void (* write
) P_ ((struct sound_device
*sd
, char *buffer
, int nbytes
));
156 /* A place for devices to store additional data. */
160 /* An enumerator for each supported sound file type. */
168 /* Interface structure for sound files. */
172 /* The type of the file. */
173 enum sound_type type
;
175 /* File descriptor of the file. */
178 /* Pointer to sound file header. This contains the first
179 MAX_SOUND_HEADER_BYTES read from the file. */
182 /* Play sound file SF on device SD. */
183 void (* play
) P_ ((struct sound_file
*sf
, struct sound_device
*sd
));
186 /* Indices of attributes in a sound attributes vector. */
198 extern Lisp_Object QCfile
;
199 Lisp_Object QCvolume
, QCdevice
;
201 Lisp_Object Qplay_sound_functions
;
203 /* These are set during `play-sound' so that sound_cleanup has
206 struct sound_device
*sound_device
;
207 struct sound_file
*sound_file
;
209 /* Function prototypes. */
211 static void vox_open
P_ ((struct sound_device
*));
212 static void vox_configure
P_ ((struct sound_device
*));
213 static void vox_close
P_ ((struct sound_device
*sd
));
214 static void vox_choose_format
P_ ((struct sound_device
*, struct sound_file
*));
215 static void vox_init
P_ ((struct sound_device
*));
216 static void vox_write
P_ ((struct sound_device
*, char *, int));
217 static void sound_perror
P_ ((char *));
218 static int parse_sound
P_ ((Lisp_Object
, Lisp_Object
*));
219 static void find_sound_file_type
P_ ((struct sound_file
*));
220 static u_int32_t le2hl
P_ ((u_int32_t
));
221 static u_int16_t le2hs
P_ ((u_int16_t
));
222 static u_int32_t be2hl
P_ ((u_int32_t
));
223 static u_int16_t be2hs
P_ ((u_int16_t
));
224 static int wav_init
P_ ((struct sound_file
*));
225 static void wav_play
P_ ((struct sound_file
*, struct sound_device
*));
226 static int au_init
P_ ((struct sound_file
*));
227 static void au_play
P_ ((struct sound_file
*, struct sound_device
*));
231 /***********************************************************************
233 ***********************************************************************/
235 /* Like perror, but signals an error. */
241 error ("%s: %s", msg
, strerror (errno
));
245 /* Parse sound specification SOUND, and fill ATTRS with what is
246 found. Value is non-zero if SOUND Is a valid sound specification.
247 A valid sound specification is a list starting with the symbol
248 `sound'. The rest of the list is a property list which may
249 contain the following key/value pairs:
253 FILE is the sound file to play. If it isn't an absolute name,
254 it's searched under `data-directory'.
258 DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
259 If not specified, a default device is used.
263 VOL must be an integer in the range [0, 100], or a float in the
267 parse_sound (sound
, attrs
)
271 /* SOUND must be a list starting with the symbol `sound'. */
272 if (!CONSP (sound
) || !EQ (XCAR (sound
), Qsound
))
275 sound
= XCDR (sound
);
276 attrs
[SOUND_FILE
] = Fplist_get (sound
, QCfile
);
277 attrs
[SOUND_DEVICE
] = Fplist_get (sound
, QCdevice
);
278 attrs
[SOUND_VOLUME
] = Fplist_get (sound
, QCvolume
);
280 /* File name must be specified. */
281 if (!STRINGP (attrs
[SOUND_FILE
]))
284 /* Volume must be in the range 0..100 or unspecified. */
285 if (!NILP (attrs
[SOUND_VOLUME
]))
287 if (INTEGERP (attrs
[SOUND_VOLUME
]))
289 if (XINT (attrs
[SOUND_VOLUME
]) < 0
290 || XINT (attrs
[SOUND_VOLUME
]) > 100)
293 else if (FLOATP (attrs
[SOUND_VOLUME
]))
295 if (XFLOAT_DATA (attrs
[SOUND_VOLUME
]) < 0
296 || XFLOAT_DATA (attrs
[SOUND_VOLUME
]) > 1)
303 /* Device must be a string or unspecified. */
304 if (!NILP (attrs
[SOUND_DEVICE
])
305 && !STRINGP (attrs
[SOUND_DEVICE
]))
312 /* Find out the type of the sound file whose file descriptor is FD.
313 SF is the sound file structure to fill in. */
316 find_sound_file_type (sf
)
317 struct sound_file
*sf
;
321 error ("Unknown sound file format");
325 /* Function installed by play-sound with record_unwind_protect. */
333 sound_device
->close (sound_device
);
334 if (sound_file
->fd
> 0)
335 close (sound_file
->fd
);
340 DEFUN ("play-sound", Fplay_sound
, Splay_sound
, 1, 1, 0,
345 Lisp_Object attrs
[SOUND_ATTR_SENTINEL
];
348 struct gcpro gcpro1
, gcpro2
;
351 struct sound_device sd
;
352 struct sound_file sf
;
354 int count
= specpdl_ptr
- specpdl
;
357 GCPRO2 (sound
, file
);
358 bzero (&sd
, sizeof sd
);
359 bzero (&sf
, sizeof sf
);
360 sf
.header
= (char *) alloca (MAX_SOUND_HEADER_BYTES
);
364 record_unwind_protect (sound_cleanup
, Qnil
);
366 /* Parse the sound specification. Give up if it is invalid. */
367 if (!parse_sound (sound
, attrs
))
370 error ("Invalid sound specification");
373 /* Open the sound file. */
374 sf
.fd
= openp (Fcons (Vdata_directory
, Qnil
),
375 attrs
[SOUND_FILE
], "", &file
, 0);
377 sound_perror ("Open sound file");
379 /* Read the first bytes from the file. */
380 nbytes
= read (sf
.fd
, sf
.header
, MAX_SOUND_HEADER_BYTES
);
382 sound_perror ("Reading sound file header");
384 /* Find out the type of sound file. Give up if we can't tell. */
385 find_sound_file_type (&sf
);
387 /* Set up a device. */
388 if (STRINGP (attrs
[SOUND_DEVICE
]))
390 int len
= XSTRING (attrs
[SOUND_DEVICE
])->size
;
391 sd
.file
= (char *) alloca (len
+ 1);
392 strcpy (sd
.file
, XSTRING (attrs
[SOUND_DEVICE
])->data
);
394 if (INTEGERP (attrs
[SOUND_VOLUME
]))
395 sd
.volume
= XFASTINT (attrs
[SOUND_VOLUME
]);
396 else if (FLOATP (attrs
[SOUND_VOLUME
]))
397 sd
.volume
= XFLOAT_DATA (attrs
[SOUND_VOLUME
]) * 100;
399 args
[0] = Qplay_sound_functions
;
401 Frun_hook_with_args (make_number (2), args
);
413 unbind_to (count
, Qnil
);
418 /***********************************************************************
419 Byte-order Conversion
420 ***********************************************************************/
422 /* Convert 32-bit value VALUE which is in little-endian byte-order
423 to host byte-order. */
429 #ifdef WORDS_BIG_ENDIAN
430 unsigned char *p
= (unsigned char *) &value
;
431 value
= p
[0] + (p
[1] << 8) + (p
[2] << 16) + (p
[3] << 24);
437 /* Convert 16-bit value VALUE which is in little-endian byte-order
438 to host byte-order. */
444 #ifdef WORDS_BIG_ENDIAN
445 unsigned char *p
= (unsigned char *) &value
;
446 value
= p
[0] + (p
[1] << 8);
452 /* Convert 32-bit value VALUE which is in big-endian byte-order
453 to host byte-order. */
459 #ifndef WORDS_BIG_ENDIAN
460 unsigned char *p
= (unsigned char *) &value
;
461 value
= p
[3] + (p
[2] << 8) + (p
[1] << 16) + (p
[0] << 24);
467 /* Convert 16-bit value VALUE which is in big-endian byte-order
468 to host byte-order. */
474 #ifndef WORDS_BIG_ENDIAN
475 unsigned char *p
= (unsigned char *) &value
;
476 value
= p
[1] + (p
[0] << 8);
483 /***********************************************************************
485 ***********************************************************************/
487 /* Try to initialize sound file SF from SF->header. SF->header
488 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
489 sound file. If the file is a WAV-format file, set up interface
490 functions in SF and convert header fields to host byte-order.
491 Value is non-zero if the file is a WAV file. */
495 struct sound_file
*sf
;
497 struct wav_header
*header
= (struct wav_header
*) sf
->header
;
499 if (bcmp (sf
->header
, "RIFF", 4) != 0)
502 /* WAV files are in little-endian order. Convert the header
503 if on a big-endian machine. */
504 header
->magic
= le2hl (header
->magic
);
505 header
->length
= le2hl (header
->length
);
506 header
->chunk_type
= le2hl (header
->chunk_type
);
507 header
->chunk_format
= le2hl (header
->chunk_format
);
508 header
->chunk_length
= le2hl (header
->chunk_length
);
509 header
->format
= le2hs (header
->format
);
510 header
->channels
= le2hs (header
->channels
);
511 header
->sample_rate
= le2hl (header
->sample_rate
);
512 header
->bytes_per_second
= le2hl (header
->bytes_per_second
);
513 header
->sample_size
= le2hs (header
->sample_size
);
514 header
->precision
= le2hs (header
->precision
);
515 header
->chunk_data
= le2hl (header
->chunk_data
);
516 header
->data_length
= le2hl (header
->data_length
);
518 /* Set up the interface functions for WAV. */
526 /* Play RIFF-WAVE audio file SF on sound device SD. */
530 struct sound_file
*sf
;
531 struct sound_device
*sd
;
533 struct wav_header
*header
= (struct wav_header
*) sf
->header
;
538 /* Let the device choose a suitable device-dependent format
540 sd
->choose_format (sd
, sf
);
542 /* Configure the device. */
543 sd
->sample_size
= header
->sample_size
;
544 sd
->sample_rate
= header
->sample_rate
;
545 sd
->bps
= header
->bytes_per_second
;
546 sd
->channels
= header
->channels
;
549 /* Copy sound data to the device. The WAV file specification is
550 actually more complex. This simple scheme worked with all WAV
551 files I found so far. If someone feels inclined to implement the
552 whole RIFF-WAVE spec, please do. */
553 buffer
= (char *) alloca (blksize
);
554 lseek (sf
->fd
, sizeof *header
, SEEK_SET
);
556 while ((nbytes
= read (sf
->fd
, buffer
, blksize
)) > 0)
557 sd
->write (sd
, buffer
, nbytes
);
560 sound_perror ("Reading sound file");
565 /***********************************************************************
567 ***********************************************************************/
569 /* Sun audio file encodings. */
573 AU_ENCODING_ULAW_8
= 1,
584 /* Try to initialize sound file SF from SF->header. SF->header
585 contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
586 sound file. If the file is a AU-format file, set up interface
587 functions in SF and convert header fields to host byte-order.
588 Value is non-zero if the file is an AU file. */
592 struct sound_file
*sf
;
594 struct au_header
*header
= (struct au_header
*) sf
->header
;
596 if (bcmp (sf
->header
, ".snd", 4) != 0)
599 header
->magic_number
= be2hl (header
->magic_number
);
600 header
->data_offset
= be2hl (header
->data_offset
);
601 header
->data_size
= be2hl (header
->data_size
);
602 header
->encoding
= be2hl (header
->encoding
);
603 header
->sample_rate
= be2hl (header
->sample_rate
);
604 header
->channels
= be2hl (header
->channels
);
606 /* Set up the interface functions for AU. */
607 sf
->type
= SUN_AUDIO
;
614 /* Play Sun audio file SF on sound device SD. */
618 struct sound_file
*sf
;
619 struct sound_device
*sd
;
621 struct au_header
*header
= (struct au_header
*) sf
->header
;
627 sd
->sample_rate
= header
->sample_rate
;
629 sd
->channels
= header
->channels
;
630 sd
->choose_format (sd
, sf
);
634 lseek (sf
->fd
, header
->data_offset
, SEEK_SET
);
636 /* Copy sound data to the device. */
637 buffer
= (char *) alloca (blksize
);
638 while ((nbytes
= read (sf
->fd
, buffer
, blksize
)) > 0)
639 sd
->write (sd
, buffer
, nbytes
);
642 sound_perror ("Reading sound file");
647 /***********************************************************************
648 Voxware Driver Interface
649 ***********************************************************************/
651 /* This driver is available on GNU/Linux, and the free BSDs. FreeBSD
652 has a compatible own driver aka Luigi's driver. */
655 /* Open device SD. If SD->file is non-null, open that device,
656 otherwise use a default device name. */
660 struct sound_device
*sd
;
664 /* Open the sound device. Default is /dev/dsp. */
670 sd
->fd
= open (file
, O_WRONLY
);
676 /* Configure device SD from parameters in it. */
680 struct sound_device
*sd
;
684 xassert (sd
->fd
>= 0);
686 /* Device parameters apparently depend on each other in undocumented
687 ways (not to imply that there is any real documentation). Be
688 careful when reordering the calls below. */
689 if (sd
->sample_size
> 0
690 && ioctl (sd
->fd
, SNDCTL_DSP_SAMPLESIZE
, &sd
->sample_size
) < 0)
691 sound_perror ("Setting sample size");
694 && ioctl (sd
->fd
, SNDCTL_DSP_SPEED
, &sd
->bps
) < 0)
695 sound_perror ("Setting speed");
697 if (sd
->sample_rate
> 0
698 && ioctl (sd
->fd
, SOUND_PCM_WRITE_RATE
, &sd
->sample_rate
) < 0)
699 sound_perror ("Setting sample rate");
701 requested
= sd
->format
;
702 if (ioctl (sd
->fd
, SNDCTL_DSP_SETFMT
, &sd
->format
) < 0)
703 sound_perror ("Setting format");
704 else if (requested
!= sd
->format
)
705 error ("Setting format");
708 && ioctl (sd
->fd
, SNDCTL_DSP_STEREO
, &sd
->channels
) < 0)
709 sound_perror ("Setting channels");
712 && ioctl (sd
->fd
, SOUND_MIXER_WRITE_PCM
, &sd
->volume
) < 0)
713 sound_perror ("Setting volume");
717 /* Close device SD if it is open. */
721 struct sound_device
*sd
;
725 /* Flush sound data, and reset the device. */
726 ioctl (sd
->fd
, SNDCTL_DSP_SYNC
, NULL
);
727 ioctl (sd
->fd
, SNDCTL_DSP_RESET
, NULL
);
729 /* Close the device. */
736 /* Choose device-dependent format for device SD from sound file SF. */
739 vox_choose_format (sd
, sf
)
740 struct sound_device
*sd
;
741 struct sound_file
*sf
;
743 if (sf
->type
== RIFF
)
745 struct wav_header
*h
= (struct wav_header
*) sf
->header
;
746 if (h
->precision
== 8)
747 sd
->format
= AFMT_U8
;
748 else if (h
->precision
== 16)
749 sd
->format
= AFMT_S16_LE
;
751 error ("Unsupported WAV file format");
753 else if (sf
->type
== SUN_AUDIO
)
755 struct au_header
*header
= (struct au_header
*) sf
->header
;
756 switch (header
->encoding
)
758 case AU_ENCODING_ULAW_8
:
759 case AU_ENCODING_IEEE32
:
760 case AU_ENCODING_IEEE64
:
761 sd
->format
= AFMT_MU_LAW
;
768 sd
->format
= AFMT_S16_LE
;
772 error ("Unsupported AU file format");
780 /* Initialize device SD. Set up the interface functions in the device
785 struct sound_device
*sd
;
789 sd
->close
= vox_close
;
790 sd
->configure
= vox_configure
;
791 sd
->choose_format
= vox_choose_format
;
792 sd
->write
= vox_write
;
796 /* Write NBYTES bytes from BUFFER to device SD. */
799 vox_write (sd
, buffer
, nbytes
)
800 struct sound_device
*sd
;
804 int nwritten
= write (sd
->fd
, buffer
, nbytes
);
806 sound_perror ("Writing to sound device");
811 /***********************************************************************
813 ***********************************************************************/
818 QCdevice
= intern (":device");
819 staticpro (&QCdevice
);
820 QCvolume
= intern (":volume");
821 staticpro (&QCvolume
);
822 Qsound
= intern ("sound");
824 Qplay_sound_functions
= intern ("play-sound-functions");
825 staticpro (&Qplay_sound_functions
);
827 defsubr (&Splay_sound
);
836 #endif /* HAVE_SOUND */