src/sound.c

   1 /* sound.c -- sound support.
   2    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004,
   3                  2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  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.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  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 "lisp.h"
  48 #include "dispextern.h"
  49 #include "atimer.h"
  50 #include <signal.h>
  51 #include "syssignal.h"
  52 /* END: Common Includes */
  53
  54
  55 /* BEGIN: Non Windows Includes */
  56 #ifndef WINDOWSNT
  57
  58 #ifndef MSDOS
  59 #include <sys/ioctl.h>
  60 #endif
  61
  62 /* FreeBSD has machine/soundcard.h.  Voxware sound driver docs mention
  63    sys/soundcard.h.  So, let's try whatever's there.  */
  64
  65 #ifdef HAVE_MACHINE_SOUNDCARD_H
  66 #include <machine/soundcard.h>
  67 #endif
  68 #ifdef HAVE_SYS_SOUNDCARD_H
  69 #include <sys/soundcard.h>
  70 #endif
  71 #ifdef HAVE_SOUNDCARD_H
  72 #include <soundcard.h>
  73 #endif
  74 #ifdef HAVE_ALSA
  75 #ifdef ALSA_SUBDIR_INCLUDE
  76 #include <alsa/asoundlib.h>
  77 #else
  78 #include <asoundlib.h>
  79 #endif /* ALSA_SUBDIR_INCLUDE */
  80 #endif /* HAVE_ALSA */
  81
  82 /* END: Non Windows Includes */
  83
  84 #else /* WINDOWSNT */
  85
  86 /* BEGIN: Windows Specific Includes */
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <string.h>
  90 #include <limits.h>
  91 #include <windows.h>
  92 #include <mmsystem.h>
  93 /* END: Windows Specific Includes */
  94
  95 #endif /* WINDOWSNT */
  96
  97 /* BEGIN: Common Definitions */
  98
  99 /* Symbols.  */
 100
 101 extern Lisp_Object QCfile, QCdata;
 102 Lisp_Object QCvolume, QCdevice;
 103 Lisp_Object Qsound;
 104 Lisp_Object Qplay_sound_functions;
 105
 106 /* Indices of attributes in a sound attributes vector.  */
 107
 108 enum sound_attr
 109 {
 110   SOUND_FILE,
 111   SOUND_DATA,
 112   SOUND_DEVICE,
 113   SOUND_VOLUME,
 114   SOUND_ATTR_SENTINEL
 115 };
 116
 117 static void alsa_sound_perror P_ ((char *, int)) NO_RETURN;
 118 static void sound_perror P_ ((char *)) NO_RETURN;
 119 static void sound_warning P_ ((char *));
 120 static int parse_sound P_ ((Lisp_Object, Lisp_Object *));
 121
 122 /* END: Common Definitions */
 123
 124 /* BEGIN: Non Windows Definitions */
 125 #ifndef WINDOWSNT
 126
 127 #ifndef DEFAULT_SOUND_DEVICE
 128 #define DEFAULT_SOUND_DEVICE "/dev/dsp"
 129 #endif
 130 #ifndef DEFAULT_ALSA_SOUND_DEVICE
 131 #define DEFAULT_ALSA_SOUND_DEVICE "default"
 132 #endif
 133
 134
 135 /* Structure forward declarations.  */
 136
 137 struct sound;
 138 struct sound_device;
 139
 140 /* The file header of RIFF-WAVE files (*.wav).  Files are always in
 141    little-endian byte-order.  */
 142
 143 struct wav_header
 144 {
 145   u_int32_t magic;
 146   u_int32_t length;
 147   u_int32_t chunk_type;
 148   u_int32_t chunk_format;
 149   u_int32_t chunk_length;
 150   u_int16_t format;
 151   u_int16_t channels;
 152   u_int32_t sample_rate;
 153   u_int32_t bytes_per_second;
 154   u_int16_t sample_size;
 155   u_int16_t precision;
 156   u_int32_t chunk_data;
 157   u_int32_t data_length;
 158 };
 159
 160 /* The file header of Sun adio files (*.au).  Files are always in
 161    big-endian byte-order.  */
 162
 163 struct au_header
 164 {
 165   /* ASCII ".snd" */
 166   u_int32_t magic_number;
 167
 168   /* Offset of data part from start of file. Minimum value is 24.  */
 169   u_int32_t data_offset;
 170
 171   /* Size of data part, 0xffffffff if unknown.  */
 172   u_int32_t data_size;
 173
 174   /* Data encoding format.
 175      1  8-bit ISDN u-law
 176      2  8-bit linear PCM (REF-PCM)
 177      3  16-bit linear PCM
 178      4  24-bit linear PCM
 179      5  32-bit linear PCM
 180      6  32-bit IEEE floating-point
 181      7  64-bit IEEE floating-point
 182      23 8-bit u-law compressed using CCITT 0.721 ADPCM voice data
 183      encoding scheme.  */
 184   u_int32_t encoding;
 185
 186   /* Number of samples per second.  */
 187   u_int32_t sample_rate;
 188
 189   /* Number of interleaved channels.  */
 190   u_int32_t channels;
 191 };
 192
 193 /* Maximum of all sound file headers sizes.  */
 194
 195 #define MAX_SOUND_HEADER_BYTES \
 196      max (sizeof (struct wav_header), sizeof (struct au_header))
 197
 198 /* Interface structure for sound devices.  */
 199
 200 struct sound_device
 201 {
 202   /* The name of the device or null meaning use a default device name.  */
 203   char *file;
 204
 205   /* File descriptor of the device.  */
 206   int fd;
 207
 208   /* Device-dependent format.  */
 209   int format;
 210
 211   /* Volume (0..100).  Zero means unspecified.  */
 212   int volume;
 213
 214   /* Sample size.  */
 215   int sample_size;
 216
 217   /* Sample rate.  */
 218   int sample_rate;
 219
 220   /* Bytes per second.  */
 221   int bps;
 222
 223   /* 1 = mono, 2 = stereo, 0 = don't set.  */
 224   int channels;
 225
 226   /* Open device SD.  */
 227   void (* open) P_ ((struct sound_device *sd));
 228
 229   /* Close device SD.  */
 230   void (* close) P_ ((struct sound_device *sd));
 231
 232   /* Configure SD accoring to device-dependent parameters.  */
 233   void (* configure) P_ ((struct sound_device *device));
 234
 235   /* Choose a device-dependent format for outputting sound S.  */
 236   void (* choose_format) P_ ((struct sound_device *sd,
 237                               struct sound *s));
 238
 239   /* Return a preferred data size in bytes to be sent to write (below)
 240      each time.  2048 is used if this is NULL.  */
 241   int (* period_size) P_ ((struct sound_device *sd));
 242
 243   /* Write NYBTES bytes from BUFFER to device SD.  */
 244   void (* write) P_ ((struct sound_device *sd, const char *buffer,
 245                       int nbytes));
 246
 247   /* A place for devices to store additional data.  */
 248   void *data;
 249 };
 250
 251 /* An enumerator for each supported sound file type.  */
 252
 253 enum sound_type
 254 {
 255   RIFF,
 256   SUN_AUDIO
 257 };
 258
 259 /* Interface structure for sound files.  */
 260
 261 struct sound
 262 {
 263   /* The type of the file.  */
 264   enum sound_type type;
 265
 266   /* File descriptor of a sound file.  */
 267   int fd;
 268
 269   /* Pointer to sound file header.  This contains header_size bytes
 270      read from the start of a sound file.  */
 271   char *header;
 272
 273   /* Number of bytes raed from sound file.  This is always <=
 274      MAX_SOUND_HEADER_BYTES.  */
 275   int header_size;
 276
 277   /* Sound data, if a string.  */
 278   Lisp_Object data;
 279
 280   /* Play sound file S on device SD.  */
 281   void (* play) P_ ((struct sound *s, struct sound_device *sd));
 282 };
 283
 284 /* These are set during `play-sound-internal' so that sound_cleanup has
 285    access to them.  */
 286
 287 struct sound_device *current_sound_device;
 288 struct sound *current_sound;
 289
 290 /* Function prototypes.  */
 291
 292 static void vox_open P_ ((struct sound_device *));
 293 static void vox_configure P_ ((struct sound_device *));
 294 static void vox_close P_ ((struct sound_device *sd));
 295 static void vox_choose_format P_ ((struct sound_device *, struct sound *));
 296 static int vox_init P_ ((struct sound_device *));
 297 static void vox_write P_ ((struct sound_device *, const char *, int));
 298 static void find_sound_type P_ ((struct sound *));
 299 static u_int32_t le2hl P_ ((u_int32_t));
 300 static u_int16_t le2hs P_ ((u_int16_t));
 301 static u_int32_t be2hl P_ ((u_int32_t));
 302 static int wav_init P_ ((struct sound *));
 303 static void wav_play P_ ((struct sound *, struct sound_device *));
 304 static int au_init P_ ((struct sound *));
 305 static void au_play P_ ((struct sound *, struct sound_device *));
 306
 307 #if 0 /* Currently not used.  */
 308 static u_int16_t be2hs P_ ((u_int16_t));
 309 #endif
 310
 311 /* END: Non Windows Definitions */
 312 #else /* WINDOWSNT */
 313
 314 /* BEGIN: Windows Specific Definitions */
 315 static int do_play_sound P_ ((const char *, unsigned long));
 316 /*
 317   END: Windows Specific Definitions */
 318 #endif /* WINDOWSNT */
 319
 320 \f
 321 /***********************************************************************
 322                                General
 323  ***********************************************************************/
 324
 325 /* BEGIN: Common functions */
 326
 327 /* Like perror, but signals an error.  */
 328
 329 static void
 330 sound_perror (msg)
 331      char *msg;
 332 {
 333   int saved_errno = errno;
 334
 335   turn_on_atimers (1);
 336 #ifdef SIGIO
 337   sigunblock (sigmask (SIGIO));
 338 #endif
 339   if (saved_errno != 0)
 340     error ("%s: %s", msg, strerror (saved_errno));
 341   else
 342     error ("%s", msg);
 343 }
 344
 345
 346 /* Display a warning message.  */
 347
 348 static void
 349 sound_warning (msg)
 350      char *msg;
 351 {
 352   message (msg);
 353 }
 354
 355
 356 /* Parse sound specification SOUND, and fill ATTRS with what is
 357    found.  Value is non-zero if SOUND Is a valid sound specification.
 358    A valid sound specification is a list starting with the symbol
 359    `sound'.  The rest of the list is a property list which may
 360    contain the following key/value pairs:
 361
 362    - `:file FILE'
 363
 364    FILE is the sound file to play.  If it isn't an absolute name,
 365    it's searched under `data-directory'.
 366
 367    - `:data DATA'
 368
 369    DATA is a string containing sound data.  Either :file or :data
 370    may be present, but not both.
 371
 372    - `:device DEVICE'
 373
 374    DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
 375    If not specified, a default device is used.
 376
 377    - `:volume VOL'
 378
 379    VOL must be an integer in the range [0, 100], or a float in the
 380    range [0, 1].  */
 381
 382 static int
 383 parse_sound (sound, attrs)
 384      Lisp_Object sound;
 385      Lisp_Object *attrs;
 386 {
 387   /* SOUND must be a list starting with the symbol `sound'.  */
 388   if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
 389     return 0;
 390
 391   sound = XCDR (sound);
 392   attrs[SOUND_FILE] = Fplist_get (sound, QCfile);
 393   attrs[SOUND_DATA] = Fplist_get (sound, QCdata);
 394   attrs[SOUND_DEVICE] = Fplist_get (sound, QCdevice);
 395   attrs[SOUND_VOLUME] = Fplist_get (sound, QCvolume);
 396
 397 #ifndef WINDOWSNT
 398   /* File name or data must be specified.  */
 399   if (!STRINGP (attrs[SOUND_FILE])
 400       && !STRINGP (attrs[SOUND_DATA]))
 401     return 0;
 402 #else /* WINDOWSNT */
 403   /*
 404     Data is not supported in Windows.  Therefore a
 405     File name MUST be supplied.
 406   */
 407   if (!STRINGP (attrs[SOUND_FILE]))
 408     {
 409       return 0;
 410     }
 411 #endif /* WINDOWSNT */
 412
 413   /* Volume must be in the range 0..100 or unspecified.  */
 414   if (!NILP (attrs[SOUND_VOLUME]))
 415     {
 416       if (INTEGERP (attrs[SOUND_VOLUME]))
 417         {
 418           if (XINT (attrs[SOUND_VOLUME]) < 0
 419               || XINT (attrs[SOUND_VOLUME]) > 100)
 420             return 0;
 421         }
 422       else if (FLOATP (attrs[SOUND_VOLUME]))
 423         {
 424           if (XFLOAT_DATA (attrs[SOUND_VOLUME]) < 0
 425               || XFLOAT_DATA (attrs[SOUND_VOLUME]) > 1)
 426             return 0;
 427         }
 428       else
 429         return 0;
 430     }
 431
 432 #ifndef WINDOWSNT
 433   /* Device must be a string or unspecified.  */
 434   if (!NILP (attrs[SOUND_DEVICE])
 435       && !STRINGP (attrs[SOUND_DEVICE]))
 436     return 0;
 437 #endif  /* WINDOWSNT */
 438   /*
 439     Since device is ignored in Windows, it does not matter
 440     what it is.
 441    */
 442   return 1;
 443 }
 444
 445 /* END: Common functions */
 446
 447 /* BEGIN: Non Windows functions */
 448 #ifndef WINDOWSNT
 449
 450 /* Find out the type of the sound file whose file descriptor is FD.
 451    S is the sound file structure to fill in.  */
 452
 453 static void
 454 find_sound_type (s)
 455      struct sound *s;
 456 {
 457   if (!wav_init (s) && !au_init (s))
 458     error ("Unknown sound format");
 459 }
 460
 461
 462 /* Function installed by play-sound-internal with record_unwind_protect.  */
 463
 464 static Lisp_Object
 465 sound_cleanup (arg)
 466      Lisp_Object arg;
 467 {
 468   if (current_sound_device->close)
 469     current_sound_device->close (current_sound_device);
 470   if (current_sound->fd > 0)
 471     emacs_close (current_sound->fd);
 472   free (current_sound_device);
 473   free (current_sound);
 474
 475   return Qnil;
 476 }
 477
 478 /***********************************************************************
 479                         Byte-order Conversion
 480  ***********************************************************************/
 481
 482 /* Convert 32-bit value VALUE which is in little-endian byte-order
 483    to host byte-order.  */
 484
 485 static u_int32_t
 486 le2hl (value)
 487      u_int32_t value;
 488 {
 489 #ifdef WORDS_BIG_ENDIAN
 490   unsigned char *p = (unsigned char *) &value;
 491   value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
 492 #endif
 493   return value;
 494 }
 495
 496
 497 /* Convert 16-bit value VALUE which is in little-endian byte-order
 498    to host byte-order.  */
 499
 500 static u_int16_t
 501 le2hs (value)
 502      u_int16_t value;
 503 {
 504 #ifdef WORDS_BIG_ENDIAN
 505   unsigned char *p = (unsigned char *) &value;
 506   value = p[0] + (p[1] << 8);
 507 #endif
 508   return value;
 509 }
 510
 511
 512 /* Convert 32-bit value VALUE which is in big-endian byte-order
 513    to host byte-order.  */
 514
 515 static u_int32_t
 516 be2hl (value)
 517      u_int32_t value;
 518 {
 519 #ifndef WORDS_BIG_ENDIAN
 520   unsigned char *p = (unsigned char *) &value;
 521   value = p[3] + (p[2] << 8) + (p[1] << 16) + (p[0] << 24);
 522 #endif
 523   return value;
 524 }
 525
 526
 527 #if 0 /* Currently not used.  */
 528
 529 /* Convert 16-bit value VALUE which is in big-endian byte-order
 530    to host byte-order.  */
 531
 532 static u_int16_t
 533 be2hs (value)
 534      u_int16_t value;
 535 {
 536 #ifndef WORDS_BIG_ENDIAN
 537   unsigned char *p = (unsigned char *) &value;
 538   value = p[1] + (p[0] << 8);
 539 #endif
 540   return value;
 541 }
 542
 543 #endif /* 0 */
 544
 545 /***********************************************************************
 546                           RIFF-WAVE (*.wav)
 547  ***********************************************************************/
 548
 549 /* Try to initialize sound file S from S->header.  S->header
 550    contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
 551    sound file.  If the file is a WAV-format file, set up interface
 552    functions in S and convert header fields to host byte-order.
 553    Value is non-zero if the file is a WAV file.  */
 554
 555 static int
 556 wav_init (s)
 557      struct sound *s;
 558 {
 559   struct wav_header *header = (struct wav_header *) s->header;
 560
 561   if (s->header_size < sizeof *header
 562       || bcmp (s->header, "RIFF", 4) != 0)
 563     return 0;
 564
 565   /* WAV files are in little-endian order.  Convert the header
 566      if on a big-endian machine.  */
 567   header->magic = le2hl (header->magic);
 568   header->length = le2hl (header->length);
 569   header->chunk_type = le2hl (header->chunk_type);
 570   header->chunk_format = le2hl (header->chunk_format);
 571   header->chunk_length = le2hl (header->chunk_length);
 572   header->format = le2hs (header->format);
 573   header->channels = le2hs (header->channels);
 574   header->sample_rate = le2hl (header->sample_rate);
 575   header->bytes_per_second = le2hl (header->bytes_per_second);
 576   header->sample_size = le2hs (header->sample_size);
 577   header->precision = le2hs (header->precision);
 578   header->chunk_data = le2hl (header->chunk_data);
 579   header->data_length = le2hl (header->data_length);
 580
 581   /* Set up the interface functions for WAV.  */
 582   s->type = RIFF;
 583   s->play = wav_play;
 584
 585   return 1;
 586 }
 587
 588
 589 /* Play RIFF-WAVE audio file S on sound device SD.  */
 590
 591 static void
 592 wav_play (s, sd)
 593      struct sound *s;
 594      struct sound_device *sd;
 595 {
 596   struct wav_header *header = (struct wav_header *) s->header;
 597
 598   /* Let the device choose a suitable device-dependent format
 599      for the file.  */
 600   sd->choose_format (sd, s);
 601
 602   /* Configure the device.  */
 603   sd->sample_size = header->sample_size;
 604   sd->sample_rate = header->sample_rate;
 605   sd->bps = header->bytes_per_second;
 606   sd->channels = header->channels;
 607   sd->configure (sd);
 608
 609   /* Copy sound data to the device.  The WAV file specification is
 610      actually more complex.  This simple scheme worked with all WAV
 611      files I found so far.  If someone feels inclined to implement the
 612      whole RIFF-WAVE spec, please do.  */
 613   if (STRINGP (s->data))
 614     sd->write (sd, SDATA (s->data) + sizeof *header,
 615                SBYTES (s->data) - sizeof *header);
 616   else
 617     {
 618       char *buffer;
 619       int nbytes;
 620       int blksize = sd->period_size ? sd->period_size (sd) : 2048;
 621       int data_left = header->data_length;
 622
 623       buffer = (char *) alloca (blksize);
 624       lseek (s->fd, sizeof *header, SEEK_SET);
 625       while (data_left > 0
 626              && (nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
 627         {
 628           /* Don't play possible garbage at the end of file */
 629           if (data_left < nbytes) nbytes = data_left;
 630           data_left -= nbytes;
 631           sd->write (sd, buffer, nbytes);
 632         }
 633
 634       if (nbytes < 0)
 635         sound_perror ("Error reading sound file");
 636     }
 637 }
 638
 639
 640 /***********************************************************************
 641                            Sun Audio (*.au)
 642  ***********************************************************************/
 643
 644 /* Sun audio file encodings.  */
 645
 646 enum au_encoding
 647 {
 648   AU_ENCODING_ULAW_8 = 1,
 649   AU_ENCODING_8,
 650   AU_ENCODING_16,
 651   AU_ENCODING_24,
 652   AU_ENCODING_32,
 653   AU_ENCODING_IEEE32,
 654   AU_ENCODING_IEEE64,
 655   AU_COMPRESSED = 23,
 656   AU_ENCODING_ALAW_8 = 27
 657 };
 658
 659
 660 /* Try to initialize sound file S from S->header.  S->header
 661    contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
 662    sound file.  If the file is a AU-format file, set up interface
 663    functions in S and convert header fields to host byte-order.
 664    Value is non-zero if the file is an AU file.  */
 665
 666 static int
 667 au_init (s)
 668      struct sound *s;
 669 {
 670   struct au_header *header = (struct au_header *) s->header;
 671
 672   if (s->header_size < sizeof *header
 673       || bcmp (s->header, ".snd", 4) != 0)
 674     return 0;
 675
 676   header->magic_number = be2hl (header->magic_number);
 677   header->data_offset = be2hl (header->data_offset);
 678   header->data_size = be2hl (header->data_size);
 679   header->encoding = be2hl (header->encoding);
 680   header->sample_rate = be2hl (header->sample_rate);
 681   header->channels = be2hl (header->channels);
 682
 683   /* Set up the interface functions for AU.  */
 684   s->type = SUN_AUDIO;
 685   s->play = au_play;
 686
 687   return 1;
 688 }
 689
 690
 691 /* Play Sun audio file S on sound device SD.  */
 692
 693 static void
 694 au_play (s, sd)
 695      struct sound *s;
 696      struct sound_device *sd;
 697 {
 698   struct au_header *header = (struct au_header *) s->header;
 699
 700   sd->sample_size = 0;
 701   sd->sample_rate = header->sample_rate;
 702   sd->bps = 0;
 703   sd->channels = header->channels;
 704   sd->choose_format (sd, s);
 705   sd->configure (sd);
 706
 707   if (STRINGP (s->data))
 708     sd->write (sd, SDATA (s->data) + header->data_offset,
 709                SBYTES (s->data) - header->data_offset);
 710   else
 711     {
 712       int blksize = sd->period_size ? sd->period_size (sd) : 2048;
 713       char *buffer;
 714       int nbytes;
 715
 716       /* Seek */
 717       lseek (s->fd, header->data_offset, SEEK_SET);
 718
 719       /* Copy sound data to the device.  */
 720       buffer = (char *) alloca (blksize);
 721       while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
 722         sd->write (sd, buffer, nbytes);
 723
 724       if (nbytes < 0)
 725         sound_perror ("Error reading sound file");
 726     }
 727 }
 728
 729
 730 /***********************************************************************
 731                        Voxware Driver Interface
 732  ***********************************************************************/
 733
 734 /* This driver is available on GNU/Linux, and the free BSDs.  FreeBSD
 735    has a compatible own driver aka Luigi's driver.  */
 736
 737
 738 /* Open device SD.  If SD->file is non-null, open that device,
 739    otherwise use a default device name.  */
 740
 741 static void
 742 vox_open (sd)
 743      struct sound_device *sd;
 744 {
 745   char *file;
 746
 747   /* Open the sound device.  Default is /dev/dsp.  */
 748   if (sd->file)
 749     file = sd->file;
 750   else
 751     file = DEFAULT_SOUND_DEVICE;
 752
 753   sd->fd = emacs_open (file, O_WRONLY, 0);
 754   if (sd->fd < 0)
 755     sound_perror (file);
 756 }
 757
 758
 759 /* Configure device SD from parameters in it.  */
 760
 761 static void
 762 vox_configure (sd)
 763      struct sound_device *sd;
 764 {
 765   int val;
 766
 767   xassert (sd->fd >= 0);
 768
 769   /* On GNU/Linux, it seems that the device driver doesn't like to be
 770      interrupted by a signal.  Block the ones we know to cause
 771      troubles.  */
 772   turn_on_atimers (0);
 773 #ifdef SIGIO
 774   sigblock (sigmask (SIGIO));
 775 #endif
 776
 777   val = sd->format;
 778   if (ioctl (sd->fd, SNDCTL_DSP_SETFMT, &sd->format) < 0
 779       || val != sd->format)
 780     sound_perror ("Could not set sound format");
 781
 782   val = sd->channels != 1;
 783   if (ioctl (sd->fd, SNDCTL_DSP_STEREO, &val) < 0
 784       || val != (sd->channels != 1))
 785     sound_perror ("Could not set stereo/mono");
 786
 787   /* I think bps and sampling_rate are the same, but who knows.
 788      Check this. and use SND_DSP_SPEED for both.  */
 789   if (sd->sample_rate > 0)
 790     {
 791       val = sd->sample_rate;
 792       if (ioctl (sd->fd, SNDCTL_DSP_SPEED, &sd->sample_rate) < 0)
 793         sound_perror ("Could not set sound speed");
 794       else if (val != sd->sample_rate)
 795         sound_warning ("Could not set sample rate");
 796     }
 797
 798   if (sd->volume > 0)
 799     {
 800       int volume = sd->volume & 0xff;
 801       volume |= volume << 8;
 802       /* This may fail if there is no mixer.  Ignore the failure.  */
 803       ioctl (sd->fd, SOUND_MIXER_WRITE_PCM, &volume);
 804     }
 805
 806   turn_on_atimers (1);
 807 #ifdef SIGIO
 808   sigunblock (sigmask (SIGIO));
 809 #endif
 810 }
 811
 812
 813 /* Close device SD if it is open.  */
 814
 815 static void
 816 vox_close (sd)
 817      struct sound_device *sd;
 818 {
 819   if (sd->fd >= 0)
 820     {
 821       /* On GNU/Linux, it seems that the device driver doesn't like to
 822          be interrupted by a signal.  Block the ones we know to cause
 823          troubles.  */
 824 #ifdef SIGIO
 825       sigblock (sigmask (SIGIO));
 826 #endif
 827       turn_on_atimers (0);
 828
 829       /* Flush sound data, and reset the device.  */
 830       ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL);
 831
 832       turn_on_atimers (1);
 833 #ifdef SIGIO
 834       sigunblock (sigmask (SIGIO));
 835 #endif
 836
 837       /* Close the device.  */
 838       emacs_close (sd->fd);
 839       sd->fd = -1;
 840     }
 841 }
 842
 843
 844 /* Choose device-dependent format for device SD from sound file S.  */
 845
 846 static void
 847 vox_choose_format (sd, s)
 848      struct sound_device *sd;
 849      struct sound *s;
 850 {
 851   if (s->type == RIFF)
 852     {
 853       struct wav_header *h = (struct wav_header *) s->header;
 854       if (h->precision == 8)
 855         sd->format = AFMT_U8;
 856       else if (h->precision == 16)
 857         sd->format = AFMT_S16_LE;
 858       else
 859         error ("Unsupported WAV file format");
 860     }
 861   else if (s->type == SUN_AUDIO)
 862     {
 863       struct au_header *header = (struct au_header *) s->header;
 864       switch (header->encoding)
 865         {
 866         case AU_ENCODING_ULAW_8:
 867         case AU_ENCODING_IEEE32:
 868         case AU_ENCODING_IEEE64:
 869           sd->format = AFMT_MU_LAW;
 870           break;
 871
 872         case AU_ENCODING_8:
 873         case AU_ENCODING_16:
 874         case AU_ENCODING_24:
 875         case AU_ENCODING_32:
 876           sd->format = AFMT_S16_LE;
 877           break;
 878
 879         default:
 880           error ("Unsupported AU file format");
 881         }
 882     }
 883   else
 884     abort ();
 885 }
 886
 887
 888 /* Initialize device SD.  Set up the interface functions in the device
 889    structure.  */
 890
 891 static int
 892 vox_init (sd)
 893      struct sound_device *sd;
 894 {
 895   char *file;
 896   int fd;
 897
 898   /* Open the sound device.  Default is /dev/dsp.  */
 899   if (sd->file)
 900     file = sd->file;
 901   else
 902     file = DEFAULT_SOUND_DEVICE;
 903   fd = emacs_open (file, O_WRONLY, 0);
 904   if (fd >= 0)
 905     emacs_close (fd);
 906   else
 907     return 0;
 908
 909   sd->fd = -1;
 910   sd->open = vox_open;
 911   sd->close = vox_close;
 912   sd->configure = vox_configure;
 913   sd->choose_format = vox_choose_format;
 914   sd->write = vox_write;
 915   sd->period_size = NULL;
 916
 917   return 1;
 918 }
 919
 920 /* Write NBYTES bytes from BUFFER to device SD.  */
 921
 922 static void
 923 vox_write (sd, buffer, nbytes)
 924      struct sound_device *sd;
 925      const char *buffer;
 926      int nbytes;
 927 {
 928   int nwritten = emacs_write (sd->fd, buffer, nbytes);
 929   if (nwritten < 0)
 930     sound_perror ("Error writing to sound device");
 931 }
 932
 933 #ifdef HAVE_ALSA
 934 /***********************************************************************
 935                        ALSA Driver Interface
 936  ***********************************************************************/
 937
 938 /* This driver is available on GNU/Linux. */
 939
 940 static void
 941 alsa_sound_perror (msg, err)
 942      char *msg;
 943      int err;
 944 {
 945   error ("%s: %s", msg, snd_strerror (err));
 946 }
 947
 948 struct alsa_params
 949 {
 950   snd_pcm_t *handle;
 951   snd_pcm_hw_params_t *hwparams;
 952   snd_pcm_sw_params_t *swparams;
 953   snd_pcm_uframes_t period_size;
 954 };
 955
 956 /* Open device SD.  If SD->file is non-null, open that device,
 957    otherwise use a default device name.  */
 958
 959 static void
 960 alsa_open (sd)
 961      struct sound_device *sd;
 962 {
 963   char *file;
 964   struct alsa_params *p;
 965   int err;
 966
 967   /* Open the sound device.  Default is "default".  */
 968   if (sd->file)
 969     file = sd->file;
 970   else
 971     file = DEFAULT_ALSA_SOUND_DEVICE;
 972
 973   p = xmalloc (sizeof (*p));
 974   p->handle = NULL;
 975   p->hwparams = NULL;
 976   p->swparams = NULL;
 977
 978   sd->fd = -1;
 979   sd->data = p;
 980
 981
 982   err = snd_pcm_open (&p->handle, file, SND_PCM_STREAM_PLAYBACK, 0);
 983   if (err < 0)
 984     alsa_sound_perror (file, err);
 985 }
 986
 987 static int
 988 alsa_period_size (sd)
 989        struct sound_device *sd;
 990 {
 991   struct alsa_params *p = (struct alsa_params *) sd->data;
 992   int fact = snd_pcm_format_size (sd->format, 1) * sd->channels;
 993   return p->period_size * (fact > 0 ? fact : 1);
 994 }
 995
 996 static void
 997 alsa_configure (sd)
 998      struct sound_device *sd;
 999 {
1000   int val, err, dir;
1001   unsigned uval;
1002   struct alsa_params *p = (struct alsa_params *) sd->data;
1003   snd_pcm_uframes_t buffer_size;
1004
1005   xassert (p->handle != 0);
1006
1007   err = snd_pcm_hw_params_malloc (&p->hwparams);
1008   if (err < 0)
1009     alsa_sound_perror ("Could not allocate hardware parameter structure", err);
1010
1011   err = snd_pcm_sw_params_malloc (&p->swparams);
1012   if (err < 0)
1013     alsa_sound_perror ("Could not allocate software parameter structure", err);
1014
1015   err = snd_pcm_hw_params_any (p->handle, p->hwparams);
1016   if (err < 0)
1017     alsa_sound_perror ("Could not initialize hardware parameter structure", err);
1018
1019   err = snd_pcm_hw_params_set_access (p->handle, p->hwparams,
1020                                       SND_PCM_ACCESS_RW_INTERLEAVED);
1021   if (err < 0)
1022     alsa_sound_perror ("Could not set access type", err);
1023
1024   val = sd->format;
1025   err = snd_pcm_hw_params_set_format (p->handle, p->hwparams, val);
1026   if (err < 0)
1027     alsa_sound_perror ("Could not set sound format", err);
1028
1029   uval = sd->sample_rate;
1030   err = snd_pcm_hw_params_set_rate_near (p->handle, p->hwparams, &uval, 0);
1031   if (err < 0)
1032     alsa_sound_perror ("Could not set sample rate", err);
1033
1034   val = sd->channels;
1035   err = snd_pcm_hw_params_set_channels (p->handle, p->hwparams, val);
1036   if (err < 0)
1037     alsa_sound_perror ("Could not set channel count", err);
1038
1039   err = snd_pcm_hw_params (p->handle, p->hwparams);
1040   if (err < 0)
1041     alsa_sound_perror ("Could not set parameters", err);
1042
1043
1044   err = snd_pcm_hw_params_get_period_size (p->hwparams, &p->period_size, &dir);
1045   if (err < 0)
1046     alsa_sound_perror ("Unable to get period size for playback", err);
1047
1048   err = snd_pcm_hw_params_get_buffer_size (p->hwparams, &buffer_size);
1049   if (err < 0)
1050     alsa_sound_perror("Unable to get buffer size for playback", err);
1051
1052   err = snd_pcm_sw_params_current (p->handle, p->swparams);
1053   if (err < 0)
1054     alsa_sound_perror ("Unable to determine current swparams for playback",
1055                        err);
1056
1057   /* Start the transfer when the buffer is almost full */
1058   err = snd_pcm_sw_params_set_start_threshold (p->handle, p->swparams,
1059                                                (buffer_size / p->period_size)
1060                                                * p->period_size);
1061   if (err < 0)
1062     alsa_sound_perror ("Unable to set start threshold mode for playback", err);
1063
1064   /* Allow the transfer when at least period_size samples can be processed */
1065   err = snd_pcm_sw_params_set_avail_min (p->handle, p->swparams, p->period_size);
1066   if (err < 0)
1067     alsa_sound_perror ("Unable to set avail min for playback", err);
1068
1069   /* Align all transfers to 1 period */
1070   err = snd_pcm_sw_params_set_xfer_align (p->handle, p->swparams,
1071                                           p->period_size);
1072   if (err < 0)
1073     alsa_sound_perror ("Unable to set transfer align for playback", err);
1074
1075   err = snd_pcm_sw_params (p->handle, p->swparams);
1076   if (err < 0)
1077     alsa_sound_perror ("Unable to set sw params for playback\n", err);
1078
1079   snd_pcm_hw_params_free (p->hwparams);
1080   p->hwparams = NULL;
1081   snd_pcm_sw_params_free (p->swparams);
1082   p->swparams = NULL;
1083
1084   err = snd_pcm_prepare (p->handle);
1085   if (err < 0)
1086     alsa_sound_perror ("Could not prepare audio interface for use", err);
1087
1088   if (sd->volume > 0)
1089     {
1090       int chn;
1091       snd_mixer_t *handle;
1092       snd_mixer_elem_t *e;
1093       char *file = sd->file ? sd->file : DEFAULT_ALSA_SOUND_DEVICE;
1094
1095       if (snd_mixer_open (&handle, 0) >= 0)
1096         {
1097           if (snd_mixer_attach (handle, file) >= 0
1098               && snd_mixer_load (handle) >= 0
1099               && snd_mixer_selem_register (handle, NULL, NULL) >= 0)
1100             for (e = snd_mixer_first_elem (handle);
1101                  e;
1102                  e = snd_mixer_elem_next (e))
1103               {
1104                 if (snd_mixer_selem_has_playback_volume (e))
1105                   {
1106                     long pmin, pmax, vol;
1107                     snd_mixer_selem_get_playback_volume_range (e, &pmin, &pmax);
1108                     vol = pmin + (sd->volume * (pmax - pmin)) / 100;
1109
1110                     for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++)
1111                       snd_mixer_selem_set_playback_volume (e, chn, vol);
1112                   }
1113               }
1114           snd_mixer_close(handle);
1115         }
1116     }
1117 }
1118
1119
1120 /* Close device SD if it is open.  */
1121
1122 static void
1123 alsa_close (sd)
1124      struct sound_device *sd;
1125 {
1126   struct alsa_params *p = (struct alsa_params *) sd->data;
1127   if (p)
1128     {
1129       if (p->hwparams)
1130         snd_pcm_hw_params_free (p->hwparams);
1131       if (p->swparams)
1132         snd_pcm_sw_params_free (p->swparams);
1133       if (p->handle)
1134         {
1135           snd_pcm_drain (p->handle);
1136           snd_pcm_close (p->handle);
1137         }
1138       free (p);
1139     }
1140 }
1141
1142 /* Choose device-dependent format for device SD from sound file S.  */
1143
1144 static void
1145 alsa_choose_format (sd, s)
1146      struct sound_device *sd;
1147      struct sound *s;
1148 {
1149   struct alsa_params *p = (struct alsa_params *) sd->data;
1150   if (s->type == RIFF)
1151     {
1152       struct wav_header *h = (struct wav_header *) s->header;
1153       if (h->precision == 8)
1154         sd->format = SND_PCM_FORMAT_U8;
1155       else if (h->precision == 16)
1156           sd->format = SND_PCM_FORMAT_S16_LE;
1157       else
1158         error ("Unsupported WAV file format");
1159     }
1160   else if (s->type == SUN_AUDIO)
1161     {
1162       struct au_header *header = (struct au_header *) s->header;
1163       switch (header->encoding)
1164         {
1165         case AU_ENCODING_ULAW_8:
1166           sd->format = SND_PCM_FORMAT_MU_LAW;
1167           break;
1168         case AU_ENCODING_ALAW_8:
1169           sd->format = SND_PCM_FORMAT_A_LAW;
1170           break;
1171         case AU_ENCODING_IEEE32:
1172           sd->format = SND_PCM_FORMAT_FLOAT_BE;
1173           break;
1174         case AU_ENCODING_IEEE64:
1175           sd->format = SND_PCM_FORMAT_FLOAT64_BE;
1176           break;
1177         case AU_ENCODING_8:
1178           sd->format = SND_PCM_FORMAT_S8;
1179           break;
1180         case AU_ENCODING_16:
1181           sd->format = SND_PCM_FORMAT_S16_BE;
1182           break;
1183         case AU_ENCODING_24:
1184           sd->format = SND_PCM_FORMAT_S24_BE;
1185           break;
1186         case AU_ENCODING_32:
1187           sd->format = SND_PCM_FORMAT_S32_BE;
1188           break;
1189
1190         default:
1191           error ("Unsupported AU file format");
1192         }
1193     }
1194   else
1195     abort ();
1196 }
1197
1198
1199 /* Write NBYTES bytes from BUFFER to device SD.  */
1200
1201 static void
1202 alsa_write (sd, buffer, nbytes)
1203      struct sound_device *sd;
1204      const char *buffer;
1205      int nbytes;
1206 {
1207   struct alsa_params *p = (struct alsa_params *) sd->data;
1208
1209   /* The the third parameter to snd_pcm_writei is frames, not bytes. */
1210   int fact = snd_pcm_format_size (sd->format, 1) * sd->channels;
1211   int nwritten = 0;
1212   int err;
1213
1214   while (nwritten < nbytes)
1215     {
1216       snd_pcm_uframes_t frames = (nbytes - nwritten)/fact;
1217       if (frames == 0) break;
1218
1219       err = snd_pcm_writei (p->handle, buffer + nwritten, frames);
1220       if (err < 0)
1221         {
1222           if (err == -EPIPE)
1223             {   /* under-run */
1224               err = snd_pcm_prepare (p->handle);
1225               if (err < 0)
1226                 alsa_sound_perror ("Can't recover from underrun, prepare failed",
1227                                    err);
1228             }
1229           else if (err == -ESTRPIPE)
1230             {
1231               while ((err = snd_pcm_resume (p->handle)) == -EAGAIN)
1232                 sleep(1);       /* wait until the suspend flag is released */
1233               if (err < 0)
1234                 {
1235                   err = snd_pcm_prepare (p->handle);
1236                   if (err < 0)
1237                     alsa_sound_perror ("Can't recover from suspend, "
1238                                        "prepare failed",
1239                                        err);
1240                 }
1241             }
1242           else
1243             alsa_sound_perror ("Error writing to sound device", err);
1244
1245         }
1246       else
1247         nwritten += err * fact;
1248     }
1249 }
1250
1251 static void
1252 snd_error_quiet (file, line, function, err, fmt)
1253      const char *file;
1254      int line;
1255      const char *function;
1256      int err;
1257      const char *fmt;
1258 {
1259 }
1260
1261 /* Initialize device SD.  Set up the interface functions in the device
1262    structure.  */
1263
1264 static int
1265 alsa_init (sd)
1266      struct sound_device *sd;
1267 {
1268   char *file;
1269   snd_pcm_t *handle;
1270   int err;
1271
1272   /* Open the sound device.  Default is "default".  */
1273   if (sd->file)
1274     file = sd->file;
1275   else
1276     file = DEFAULT_ALSA_SOUND_DEVICE;
1277
1278   snd_lib_error_set_handler ((snd_lib_error_handler_t) snd_error_quiet);
1279   err = snd_pcm_open (&handle, file, SND_PCM_STREAM_PLAYBACK, 0);
1280   snd_lib_error_set_handler (NULL);
1281   if (err < 0)
1282       return 0;
1283   snd_pcm_close (handle);
1284
1285   sd->fd = -1;
1286   sd->open = alsa_open;
1287   sd->close = alsa_close;
1288   sd->configure = alsa_configure;
1289   sd->choose_format = alsa_choose_format;
1290   sd->write = alsa_write;
1291   sd->period_size = alsa_period_size;
1292
1293   return 1;
1294 }
1295
1296 #endif /* HAVE_ALSA */
1297
1298
1299 /* END: Non Windows functions */
1300 #else /* WINDOWSNT */
1301
1302 /* BEGIN: Windows specific functions */
1303
1304 #define SOUND_WARNING(fun, error, text)            \
1305   {                                                \
1306     char buf[1024];                                \
1307     char err_string[MAXERRORLENGTH];               \
1308     fun (error, err_string, sizeof (err_string));  \
1309     _snprintf (buf, sizeof (buf), "%s\nError: %s", \
1310                text, err_string);                  \
1311     sound_warning (buf);                           \
1312   }
1313
1314 static int
1315 do_play_sound (psz_file, ui_volume)
1316      const char *psz_file;
1317      unsigned long ui_volume;
1318 {
1319   int i_result = 0;
1320   MCIERROR mci_error = 0;
1321   char sz_cmd_buf[520] = {0};
1322   char sz_ret_buf[520] = {0};
1323   MMRESULT mm_result = MMSYSERR_NOERROR;
1324   unsigned long ui_volume_org = 0;
1325   BOOL b_reset_volume = FALSE;
1326
1327   memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1328   memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1329   sprintf (sz_cmd_buf,
1330            "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
1331            psz_file);
1332   mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1333   if (mci_error != 0)
1334     {
1335       SOUND_WARNING (mciGetErrorString, mci_error,
1336                      "The open mciSendString command failed to open "
1337                      "the specified sound file.");
1338       i_result = (int) mci_error;
1339       return i_result;
1340     }
1341   if ((ui_volume > 0) && (ui_volume != UINT_MAX))
1342     {
1343       mm_result = waveOutGetVolume ((HWAVEOUT) WAVE_MAPPER, &ui_volume_org);
1344       if (mm_result == MMSYSERR_NOERROR)
1345         {
1346           b_reset_volume = TRUE;
1347           mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume);
1348           if (mm_result != MMSYSERR_NOERROR)
1349             {
1350               SOUND_WARNING (waveOutGetErrorText, mm_result,
1351                              "waveOutSetVolume failed to set the volume level "
1352                              "of the WAVE_MAPPER device.\n"
1353                              "As a result, the user selected volume level will "
1354                              "not be used.");
1355             }
1356         }
1357       else
1358         {
1359           SOUND_WARNING (waveOutGetErrorText, mm_result,
1360                          "waveOutGetVolume failed to obtain the original "
1361                          "volume level of the WAVE_MAPPER device.\n"
1362                          "As a result, the user selected volume level will "
1363                          "not be used.");
1364         }
1365     }
1366   memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1367   memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1368   strcpy (sz_cmd_buf, "play GNUEmacs_PlaySound_Device wait");
1369   mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1370   if (mci_error != 0)
1371     {
1372       SOUND_WARNING (mciGetErrorString, mci_error,
1373                      "The play mciSendString command failed to play the "
1374                      "opened sound file.");
1375       i_result = (int) mci_error;
1376     }
1377   memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
1378   memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
1379   strcpy (sz_cmd_buf, "close GNUEmacs_PlaySound_Device wait");
1380   mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
1381   if (b_reset_volume == TRUE)
1382     {
1383       mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume_org);
1384       if (mm_result != MMSYSERR_NOERROR)
1385         {
1386           SOUND_WARNING (waveOutGetErrorText, mm_result,
1387                          "waveOutSetVolume failed to reset the original volume "
1388                          "level of the WAVE_MAPPER device.");
1389         }
1390     }
1391   return i_result;
1392 }
1393
1394 /* END: Windows specific functions */
1395
1396 #endif /* WINDOWSNT */
1397
1398 DEFUN ("play-sound-internal", Fplay_sound_internal, Splay_sound_internal, 1, 1, 0,
1399        doc: /* Play sound SOUND.
1400
1401 Internal use only, use `play-sound' instead.  */)
1402      (sound)
1403      Lisp_Object sound;
1404 {
1405   Lisp_Object attrs[SOUND_ATTR_SENTINEL];
1406   int count = SPECPDL_INDEX ();
1407
1408 #ifndef WINDOWSNT
1409   Lisp_Object file;
1410   struct gcpro gcpro1, gcpro2;
1411   Lisp_Object args[2];
1412 #else /* WINDOWSNT */
1413   int len = 0;
1414   Lisp_Object lo_file = {0};
1415   char * psz_file = NULL;
1416   unsigned long ui_volume_tmp = UINT_MAX;
1417   unsigned long ui_volume = UINT_MAX;
1418   int i_result = 0;
1419 #endif /* WINDOWSNT */
1420
1421   /* Parse the sound specification.  Give up if it is invalid.  */
1422   if (!parse_sound (sound, attrs))
1423     error ("Invalid sound specification");
1424
1425 #ifndef WINDOWSNT
1426   file = Qnil;
1427   GCPRO2 (sound, file);
1428   current_sound_device = (struct sound_device *) xmalloc (sizeof (struct sound_device));
1429   bzero (current_sound_device, sizeof (struct sound_device));
1430   current_sound = (struct sound *) xmalloc (sizeof (struct sound));
1431   bzero (current_sound, sizeof (struct sound));
1432   record_unwind_protect (sound_cleanup, Qnil);
1433   current_sound->header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
1434
1435   if (STRINGP (attrs[SOUND_FILE]))
1436     {
1437       /* Open the sound file.  */
1438       current_sound->fd = openp (Fcons (Vdata_directory, Qnil),
1439                                  attrs[SOUND_FILE], Qnil, &file, Qnil);
1440       if (current_sound->fd < 0)
1441         sound_perror ("Could not open sound file");
1442
1443       /* Read the first bytes from the file.  */
1444       current_sound->header_size
1445         = emacs_read (current_sound->fd, current_sound->header,
1446                       MAX_SOUND_HEADER_BYTES);
1447       if (current_sound->header_size < 0)
1448         sound_perror ("Invalid sound file header");
1449     }
1450   else
1451     {
1452       current_sound->data = attrs[SOUND_DATA];
1453       current_sound->header_size = min (MAX_SOUND_HEADER_BYTES, SBYTES (current_sound->data));
1454       bcopy (SDATA (current_sound->data), current_sound->header, current_sound->header_size);
1455     }
1456
1457   /* Find out the type of sound.  Give up if we can't tell.  */
1458   find_sound_type (current_sound);
1459
1460   /* Set up a device.  */
1461   if (STRINGP (attrs[SOUND_DEVICE]))
1462     {
1463       int len = SCHARS (attrs[SOUND_DEVICE]);
1464       current_sound_device->file = (char *) alloca (len + 1);
1465       strcpy (current_sound_device->file, SDATA (attrs[SOUND_DEVICE]));
1466     }
1467
1468   if (INTEGERP (attrs[SOUND_VOLUME]))
1469     current_sound_device->volume = XFASTINT (attrs[SOUND_VOLUME]);
1470   else if (FLOATP (attrs[SOUND_VOLUME]))
1471     current_sound_device->volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
1472
1473   args[0] = Qplay_sound_functions;
1474   args[1] = sound;
1475   Frun_hook_with_args (2, args);
1476
1477 #ifdef HAVE_ALSA
1478   if (!alsa_init (current_sound_device))
1479 #endif
1480     if (!vox_init (current_sound_device))
1481       error ("No usable sound device driver found");
1482
1483   /* Open the device.  */
1484   current_sound_device->open (current_sound_device);
1485
1486   /* Play the sound.  */
1487   current_sound->play (current_sound, current_sound_device);
1488
1489   /* Clean up.  */
1490   UNGCPRO;
1491
1492 #else /* WINDOWSNT */
1493
1494   lo_file = Fexpand_file_name (attrs[SOUND_FILE], Qnil);
1495   len = XSTRING (lo_file)->size;
1496   psz_file = (char *) alloca (len + 1);
1497   strcpy (psz_file, XSTRING (lo_file)->data);
1498   if (INTEGERP (attrs[SOUND_VOLUME]))
1499     {
1500       ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
1501     }
1502   else if (FLOATP (attrs[SOUND_VOLUME]))
1503     {
1504       ui_volume_tmp = (unsigned long) XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
1505     }
1506   /*
1507     Based on some experiments I have conducted, a value of 100 or less
1508     for the sound volume is much too low.  You cannot even hear it.
1509     A value of UINT_MAX indicates that you wish for the sound to played
1510     at the maximum possible volume.  A value of UINT_MAX/2 plays the
1511     sound at 50% maximum volume.  Therefore the value passed to do_play_sound
1512     (and thus to waveOutSetVolume) must be some fraction of UINT_MAX.
1513     The following code adjusts the user specified volume level appropriately.
1514   */
1515   if ((ui_volume_tmp > 0) && (ui_volume_tmp <= 100))
1516     {
1517       ui_volume = ui_volume_tmp * (UINT_MAX / 100);
1518     }
1519   i_result = do_play_sound (psz_file, ui_volume);
1520
1521 #endif /* WINDOWSNT */
1522
1523   unbind_to (count, Qnil);
1524   return Qnil;
1525 }
1526 \f
1527 /***********************************************************************
1528                             Initialization
1529  ***********************************************************************/
1530
1531 void
1532 syms_of_sound ()
1533 {
1534   QCdevice = intern (":device");
1535   staticpro (&QCdevice);
1536   QCvolume = intern (":volume");
1537   staticpro (&QCvolume);
1538   Qsound = intern ("sound");
1539   staticpro (&Qsound);
1540   Qplay_sound_functions = intern ("play-sound-functions");
1541   staticpro (&Qplay_sound_functions);
1542
1543   defsubr (&Splay_sound_internal);
1544 }
1545
1546
1547 void
1548 init_sound ()
1549 {
1550 }
1551
1552 #endif /* HAVE_SOUND */
1553
1554 /* arch-tag: dd850ad8-0433-4e2c-9cba-b7aeeccc0dbd
1555    (do not change this comment) */