code.delx.au - gnu-emacs/blob - src/sound.c

   1 /* sound.c -- sound support.
   2    Copyright (C) 1998, 1999 Free Software Foundation.
   3
   4 This file is part of GNU Emacs.
   5
   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)
   9 any later version.
  10
  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.
  15
  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.  */
  20
  21 /* Written by Gerd Moellmann <gerd@gnu.org>.  Tested with Luigi's
  22    driver on FreeBSD 2.2.7 with a SoundBlaster 16.  */
  23
  24 #include <config.h>
  25
  26 #if defined HAVE_SOUND
  27
  28 #include <lisp.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <sys/types.h>
  32 #include <dispextern.h>
  33 #include <errno.h>
  34
  35 /* FreeBSD has machine/soundcard.h.  Voxware sound driver docs mention
  36    sys/soundcard.h.  So, let's try whatever's there.  */
  37
  38 #ifdef HAVE_MACHINE_SOUNDCARD_H
  39 #include <machine/soundcard.h>
  40 #endif
  41 #ifdef HAVE_SYS_SOUNDCARD_H
  42 #include <sys/soundcard.h>
  43 #endif
  44
  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))
  48
  49 /* Structure forward declarations.  */
  50
  51 struct sound;
  52 struct sound_device;
  53
  54 /* The file header of RIFF-WAVE files (*.wav).  Files are always in
  55    little-endian byte-order.  */
  56
  57 struct wav_header
  58 {
  59   u_int32_t magic;
  60   u_int32_t length;
  61   u_int32_t chunk_type;
  62   u_int32_t chunk_format;
  63   u_int32_t chunk_length;
  64   u_int16_t format;
  65   u_int16_t channels;
  66   u_int32_t sample_rate;
  67   u_int32_t bytes_per_second;
  68   u_int16_t sample_size;
  69   u_int16_t precision;
  70   u_int32_t chunk_data;
  71   u_int32_t data_length;
  72 };
  73
  74 /* The file header of Sun adio files (*.au).  Files are always in
  75    big-endian byte-order.  */
  76
  77 struct au_header
  78 {
  79   /* ASCII ".snd" */
  80   u_int32_t magic_number;
  81
  82   /* Offset of data part from start of file. Minimum value is 24.  */
  83   u_int32_t data_offset;
  84
  85   /* Size of data part, 0xffffffff if unknown.  */
  86   u_int32_t data_size;
  87
  88   /* Data encoding format.
  89      1  8-bit ISDN u-law
  90      2  8-bit linear PCM (REF-PCM)
  91      3  16-bit linear PCM
  92      4  24-bit linear PCM
  93      5  32-bit linear 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
  97      encoding scheme.  */
  98   u_int32_t encoding;
  99
 100   /* Number of samples per second.  */
 101   u_int32_t sample_rate;
 102
 103   /* Number of interleaved channels.  */
 104   u_int32_t channels;
 105 };
 106
 107 /* Maximum of all sound file headers sizes.  */
 108
 109 #define MAX_SOUND_HEADER_BYTES \
 110      max (sizeof (struct wav_header), sizeof (struct au_header))
 111
 112 /* Interface structure for sound devices.  */
 113
 114 struct sound_device
 115 {
 116   /* The name of the device or null meaning use a default device name.  */
 117   char *file;
 118
 119   /* File descriptor of the device.  */
 120   int fd;
 121
 122   /* Device-dependent format.  */
 123   int format;
 124
 125   /* Volume (0..100).  Zero means unspecified.  */
 126   int volume;
 127
 128   /* Sample size.  */
 129   int sample_size;
 130
 131   /* Sample rate.  */
 132   int sample_rate;
 133
 134   /* Bytes per second.  */
 135   int bps;
 136
 137   /* 1 = mono, 2 = stereo, 0 = don't set.  */
 138   int channels;
 139
 140   /* Open device SD.  */
 141   void (* open) P_ ((struct sound_device *sd));
 142
 143   /* Close device SD.  */
 144   void (* close) P_ ((struct sound_device *sd));
 145
 146   /* Configure SD accoring to device-dependent parameters.  */
 147   void (* configure) P_ ((struct sound_device *device));
 148
 149   /* Choose a device-dependent format for outputting sound S.  */
 150   void (* choose_format) P_ ((struct sound_device *sd,
 151                               struct sound *s));
 152
 153   /* Write NYBTES bytes from BUFFER to device SD.  */
 154   void (* write) P_ ((struct sound_device *sd, char *buffer, int nbytes));
 155
 156   /* A place for devices to store additional data.  */
 157   void *data;
 158 };
 159
 160 /* An enumerator for each supported sound file type.  */
 161
 162 enum sound_type
 163 {
 164   RIFF,
 165   SUN_AUDIO
 166 };
 167
 168 /* Interface structure for sound files.  */
 169
 170 struct sound
 171 {
 172   /* The type of the file.  */
 173   enum sound_type type;
 174
 175   /* File descriptor of a sound file.  */
 176   int fd;
 177
 178   /* Pointer to sound file header.  This contains header_size bytes
 179      read from the start of a sound file.  */
 180   char *header;
 181
 182   /* Number of bytes raed from sound file.  This is always <=
 183      MAX_SOUND_HEADER_BYTES.  */
 184   int header_size;
 185
 186   /* Sound data, if a string.  */
 187   Lisp_Object data;
 188
 189   /* Play sound file S on device SD.  */
 190   void (* play) P_ ((struct sound *s, struct sound_device *sd));
 191 };
 192
 193 /* Indices of attributes in a sound attributes vector.  */
 194
 195 enum sound_attr
 196 {
 197   SOUND_FILE,
 198   SOUND_DATA,
 199   SOUND_DEVICE,
 200   SOUND_VOLUME,
 201   SOUND_ATTR_SENTINEL
 202 };
 203
 204 /* Symbols.  */
 205
 206 extern Lisp_Object QCfile, QCdata;
 207 Lisp_Object QCvolume, QCdevice;
 208 Lisp_Object Qsound;
 209 Lisp_Object Qplay_sound_functions;
 210
 211 /* These are set during `play-sound' so that sound_cleanup has
 212    access to them.  */
 213
 214 struct sound_device *current_sound_device;
 215 struct sound *current_sound;
 216
 217 /* Function prototypes.  */
 218
 219 static void vox_open P_ ((struct sound_device *));
 220 static void vox_configure P_ ((struct sound_device *));
 221 static void vox_close P_ ((struct sound_device *sd));
 222 static void vox_choose_format P_ ((struct sound_device *, struct sound *));
 223 static void vox_init P_ ((struct sound_device *));
 224 static void vox_write P_ ((struct sound_device *, char *, int));
 225 static void sound_perror P_ ((char *));
 226 static int parse_sound P_ ((Lisp_Object, Lisp_Object *));
 227 static void find_sound_type P_ ((struct sound *));
 228 static u_int32_t le2hl P_ ((u_int32_t));
 229 static u_int16_t le2hs P_ ((u_int16_t));
 230 static u_int32_t be2hl P_ ((u_int32_t));
 231 static int wav_init P_ ((struct sound *));
 232 static void wav_play P_ ((struct sound *, struct sound_device *));
 233 static int au_init P_ ((struct sound *));
 234 static void au_play P_ ((struct sound *, struct sound_device *));
 235
 236 #if 0 /* Currently not used.  */
 237 static u_int16_t be2hs P_ ((u_int16_t));
 238 #endif
 239
 240
 241 \f
 242 /***********************************************************************
 243                                General
 244  ***********************************************************************/
 245
 246 /* Like perror, but signals an error.  */
 247
 248 static void
 249 sound_perror (msg)
 250      char *msg;
 251 {
 252   error ("%s: %s", msg, strerror (errno));
 253 }
 254
 255
 256 /* Parse sound specification SOUND, and fill ATTRS with what is
 257    found.  Value is non-zero if SOUND Is a valid sound specification.
 258    A valid sound specification is a list starting with the symbol
 259    `sound'.  The rest of the list is a property list which may
 260    contain the following key/value pairs:
 261
 262    - `:file FILE'
 263
 264    FILE is the sound file to play.  If it isn't an absolute name,
 265    it's searched under `data-directory'.
 266
 267    - `:data DATA'
 268
 269    DATA is a string containing sound data.  Either :file or :data
 270    may be present, but not both.
 271
 272    - `:device DEVICE'
 273
 274    DEVICE is the name of the device to play on, e.g. "/dev/dsp2".
 275    If not specified, a default device is used.
 276
 277    - `:volume VOL'
 278
 279    VOL must be an integer in the range [0, 100], or a float in the
 280    range [0, 1].  */
 281
 282 static int
 283 parse_sound (sound, attrs)
 284      Lisp_Object sound;
 285      Lisp_Object *attrs;
 286 {
 287   /* SOUND must be a list starting with the symbol `sound'.  */
 288   if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
 289     return 0;
 290
 291   sound = XCDR (sound);
 292   attrs[SOUND_FILE] = Fplist_get (sound, QCfile);
 293   attrs[SOUND_DATA] = Fplist_get (sound, QCdata);
 294   attrs[SOUND_DEVICE] = Fplist_get (sound, QCdevice);
 295   attrs[SOUND_VOLUME] = Fplist_get (sound, QCvolume);
 296
 297   /* File name or data must be specified.  */
 298   if (!STRINGP (attrs[SOUND_FILE])
 299       && !STRINGP (attrs[SOUND_DATA]))
 300     return 0;
 301
 302   /* Volume must be in the range 0..100 or unspecified.  */
 303   if (!NILP (attrs[SOUND_VOLUME]))
 304     {
 305       if (INTEGERP (attrs[SOUND_VOLUME]))
 306         {
 307           if (XINT (attrs[SOUND_VOLUME]) < 0
 308               || XINT (attrs[SOUND_VOLUME]) > 100)
 309             return 0;
 310         }
 311       else if (FLOATP (attrs[SOUND_VOLUME]))
 312         {
 313           if (XFLOAT_DATA (attrs[SOUND_VOLUME]) < 0
 314               || XFLOAT_DATA (attrs[SOUND_VOLUME]) > 1)
 315             return 0;
 316         }
 317       else
 318         return 0;
 319     }
 320
 321   /* Device must be a string or unspecified.  */
 322   if (!NILP (attrs[SOUND_DEVICE])
 323       && !STRINGP (attrs[SOUND_DEVICE]))
 324     return 0;
 325
 326   return 1;
 327 }
 328
 329
 330 /* Find out the type of the sound file whose file descriptor is FD.
 331    S is the sound file structure to fill in.  */
 332
 333 static void
 334 find_sound_type (s)
 335      struct sound *s;
 336 {
 337   if (!wav_init (s) && !au_init (s))
 338     error ("Unknown sound format");
 339 }
 340
 341
 342 /* Function installed by play-sound with record_unwind_protect.  */
 343
 344 static Lisp_Object
 345 sound_cleanup (arg)
 346      Lisp_Object arg;
 347 {
 348   if (current_sound_device)
 349     {
 350       if (current_sound_device->close)
 351         current_sound_device->close (current_sound_device);
 352       if (current_sound->fd > 0)
 353         emacs_close (current_sound->fd);
 354     }
 355 }
 356
 357
 358 DEFUN ("play-sound", Fplay_sound, Splay_sound, 1, 1, 0,
 359   "Play sound SOUND.\n\
 360 SOUND is a list of the form `(sound KEYWORD VALUE...)'.\n\
 361 The following keywords are recognized:\n\
 362 \n\
 363   :file FILE.- read sound data from FILE.  If FILE Isn't an\n\
 364 absolute file name, it is searched in `data-directory'.\n\
 365 \n\
 366   :data DATA - read sound data from string DATA.\n\
 367 \n\
 368 Exactly one of :file or :data must be present.\n\
 369 \n\
 370   :volume VOL - set volume to VOL.  VOL must an integer in the\n\
 371 range 0..100 or a float in the range 0..1.0.  If not specified,\n\
 372 don't change the volume setting of the sound device.\n\
 373 \n\
 374   :device DEVICE - play sound on DEVICE.  If not specified,\n\
 375 a system-dependent default device name is used.")
 376   (sound)
 377      Lisp_Object sound;
 378 {
 379   Lisp_Object attrs[SOUND_ATTR_SENTINEL];
 380   Lisp_Object file;
 381   struct gcpro gcpro1, gcpro2;
 382   struct sound_device sd;
 383   struct sound s;
 384   Lisp_Object args[2];
 385   int count = specpdl_ptr - specpdl;
 386
 387   file = Qnil;
 388   GCPRO2 (sound, file);
 389   bzero (&sd, sizeof sd);
 390   bzero (&s, sizeof s);
 391   current_sound_device = &sd;
 392   current_sound = &s;
 393   record_unwind_protect (sound_cleanup, Qnil);
 394   s.header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
 395
 396   /* Parse the sound specification.  Give up if it is invalid.  */
 397   if (!parse_sound (sound, attrs))
 398     error ("Invalid sound specification");
 399
 400   if (STRINGP (attrs[SOUND_FILE]))
 401     {
 402       /* Open the sound file.  */
 403       s.fd = openp (Fcons (Vdata_directory, Qnil),
 404                      attrs[SOUND_FILE], "", &file, 0);
 405       if (s.fd < 0)
 406         sound_perror ("Open sound file");
 407
 408       /* Read the first bytes from the file.  */
 409       s.header_size = emacs_read (s.fd, s.header, MAX_SOUND_HEADER_BYTES);
 410       if (s.header_size < 0)
 411         sound_perror ("Reading sound file header");
 412     }
 413   else
 414     {
 415       s.data = attrs[SOUND_DATA];
 416       bcopy (XSTRING (s.data)->data, s.header,
 417              min (MAX_SOUND_HEADER_BYTES, STRING_BYTES (XSTRING (s.data))));
 418     }
 419
 420   /* Find out the type of sound.  Give up if we can't tell.  */
 421   find_sound_type (&s);
 422
 423   /* Set up a device.  */
 424   if (STRINGP (attrs[SOUND_DEVICE]))
 425     {
 426       int len = XSTRING (attrs[SOUND_DEVICE])->size;
 427       sd.file = (char *) alloca (len + 1);
 428       strcpy (sd.file, XSTRING (attrs[SOUND_DEVICE])->data);
 429     }
 430
 431   if (INTEGERP (attrs[SOUND_VOLUME]))
 432     sd.volume = XFASTINT (attrs[SOUND_VOLUME]);
 433   else if (FLOATP (attrs[SOUND_VOLUME]))
 434     sd.volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
 435
 436   args[0] = Qplay_sound_functions;
 437   args[1] = sound;
 438   Frun_hook_with_args (2, args);
 439
 440   /* There is only one type of device we currently support, the VOX
 441      sound driver.  Set up the device interface functions for that
 442      device.  */
 443   vox_init (&sd);
 444
 445   /* Open the device.  */
 446   sd.open (&sd);
 447
 448   /* Play the sound.  */
 449   s.play (&s, &sd);
 450
 451   /* Close the input file, if any.  */
 452   if (!STRINGP (s.data))
 453     {
 454       emacs_close (s.fd);
 455       s.fd = -1;
 456     }
 457
 458   /* Close the device.  */
 459   sd.close (&sd);
 460
 461   /* Clean up.  */
 462   current_sound_device = NULL;
 463   current_sound = NULL;
 464   UNGCPRO;
 465   unbind_to (count, Qnil);
 466   return Qnil;
 467 }
 468
 469 \f
 470 /***********************************************************************
 471                         Byte-order Conversion
 472  ***********************************************************************/
 473
 474 /* Convert 32-bit value VALUE which is in little-endian byte-order
 475    to host byte-order.  */
 476
 477 static u_int32_t
 478 le2hl (value)
 479      u_int32_t value;
 480 {
 481 #ifdef WORDS_BIG_ENDIAN
 482   unsigned char *p = (unsigned char *) &value;
 483   value = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
 484 #endif
 485   return value;
 486 }
 487
 488
 489 /* Convert 16-bit value VALUE which is in little-endian byte-order
 490    to host byte-order.  */
 491
 492 static u_int16_t
 493 le2hs (value)
 494      u_int16_t value;
 495 {
 496 #ifdef WORDS_BIG_ENDIAN
 497   unsigned char *p = (unsigned char *) &value;
 498   value = p[0] + (p[1] << 8);
 499 #endif
 500   return value;
 501 }
 502
 503
 504 /* Convert 32-bit value VALUE which is in big-endian byte-order
 505    to host byte-order.  */
 506
 507 static u_int32_t
 508 be2hl (value)
 509      u_int32_t value;
 510 {
 511 #ifndef WORDS_BIG_ENDIAN
 512   unsigned char *p = (unsigned char *) &value;
 513   value = p[3] + (p[2] << 8) + (p[1] << 16) + (p[0] << 24);
 514 #endif
 515   return value;
 516 }
 517
 518
 519 #if 0 /* Currently not used.  */
 520
 521 /* Convert 16-bit value VALUE which is in big-endian byte-order
 522    to host byte-order.  */
 523
 524 static u_int16_t
 525 be2hs (value)
 526      u_int16_t value;
 527 {
 528 #ifndef WORDS_BIG_ENDIAN
 529   unsigned char *p = (unsigned char *) &value;
 530   value = p[1] + (p[0] << 8);
 531 #endif
 532   return value;
 533 }
 534
 535 #endif /* 0 */
 536
 537 \f
 538 /***********************************************************************
 539                           RIFF-WAVE (*.wav)
 540  ***********************************************************************/
 541
 542 /* Try to initialize sound file S from S->header.  S->header
 543    contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
 544    sound file.  If the file is a WAV-format file, set up interface
 545    functions in S and convert header fields to host byte-order.
 546    Value is non-zero if the file is a WAV file.  */
 547
 548 static int
 549 wav_init (s)
 550      struct sound *s;
 551 {
 552   struct wav_header *header = (struct wav_header *) s->header;
 553
 554   if (s->header_size < sizeof *header
 555       || bcmp (s->header, "RIFF", 4) != 0)
 556     return 0;
 557
 558   /* WAV files are in little-endian order.  Convert the header
 559      if on a big-endian machine.  */
 560   header->magic = le2hl (header->magic);
 561   header->length = le2hl (header->length);
 562   header->chunk_type = le2hl (header->chunk_type);
 563   header->chunk_format = le2hl (header->chunk_format);
 564   header->chunk_length = le2hl (header->chunk_length);
 565   header->format = le2hs (header->format);
 566   header->channels = le2hs (header->channels);
 567   header->sample_rate = le2hl (header->sample_rate);
 568   header->bytes_per_second = le2hl (header->bytes_per_second);
 569   header->sample_size = le2hs (header->sample_size);
 570   header->precision = le2hs (header->precision);
 571   header->chunk_data = le2hl (header->chunk_data);
 572   header->data_length = le2hl (header->data_length);
 573
 574   /* Set up the interface functions for WAV.  */
 575   s->type = RIFF;
 576   s->play = wav_play;
 577
 578   return 1;
 579 }
 580
 581
 582 /* Play RIFF-WAVE audio file S on sound device SD.  */
 583
 584 static void
 585 wav_play (s, sd)
 586      struct sound *s;
 587      struct sound_device *sd;
 588 {
 589   struct wav_header *header = (struct wav_header *) s->header;
 590
 591   /* Let the device choose a suitable device-dependent format
 592      for the file.  */
 593   sd->choose_format (sd, s);
 594
 595   /* Configure the device.  */
 596   sd->sample_size = header->sample_size;
 597   sd->sample_rate = header->sample_rate;
 598   sd->bps = header->bytes_per_second;
 599   sd->channels = header->channels;
 600   sd->configure (sd);
 601
 602   /* Copy sound data to the device.  The WAV file specification is
 603      actually more complex.  This simple scheme worked with all WAV
 604      files I found so far.  If someone feels inclined to implement the
 605      whole RIFF-WAVE spec, please do.  */
 606   if (STRINGP (s->data))
 607     sd->write (sd, XSTRING (s->data)->data + sizeof *header,
 608                STRING_BYTES (XSTRING (s->data)) - sizeof *header);
 609   else
 610     {
 611       char *buffer;
 612       int nbytes;
 613       int blksize = 2048;
 614
 615       buffer = (char *) alloca (blksize);
 616       lseek (s->fd, sizeof *header, SEEK_SET);
 617
 618       while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
 619         sd->write (sd, buffer, nbytes);
 620
 621       if (nbytes < 0)
 622         sound_perror ("Reading sound file");
 623     }
 624 }
 625
 626
 627 \f
 628 /***********************************************************************
 629                            Sun Audio (*.au)
 630  ***********************************************************************/
 631
 632 /* Sun audio file encodings.  */
 633
 634 enum au_encoding
 635 {
 636   AU_ENCODING_ULAW_8 = 1,
 637   AU_ENCODING_8,
 638   AU_ENCODING_16,
 639   AU_ENCODING_24,
 640   AU_ENCODING_32,
 641   AU_ENCODING_IEEE32,
 642   AU_ENCODING_IEEE64,
 643   AU_COMPRESSED = 23
 644 };
 645
 646
 647 /* Try to initialize sound file S from S->header.  S->header
 648    contains the first MAX_SOUND_HEADER_BYTES number of bytes from the
 649    sound file.  If the file is a AU-format file, set up interface
 650    functions in S and convert header fields to host byte-order.
 651    Value is non-zero if the file is an AU file.  */
 652
 653 static int
 654 au_init (s)
 655      struct sound *s;
 656 {
 657   struct au_header *header = (struct au_header *) s->header;
 658
 659   if (s->header_size < sizeof *header
 660       || bcmp (s->header, ".snd", 4) != 0)
 661     return 0;
 662
 663   header->magic_number = be2hl (header->magic_number);
 664   header->data_offset = be2hl (header->data_offset);
 665   header->data_size = be2hl (header->data_size);
 666   header->encoding = be2hl (header->encoding);
 667   header->sample_rate = be2hl (header->sample_rate);
 668   header->channels = be2hl (header->channels);
 669
 670   /* Set up the interface functions for AU.  */
 671   s->type = SUN_AUDIO;
 672   s->play = au_play;
 673
 674   return 1;
 675 }
 676
 677
 678 /* Play Sun audio file S on sound device SD.  */
 679
 680 static void
 681 au_play (s, sd)
 682      struct sound *s;
 683      struct sound_device *sd;
 684 {
 685   struct au_header *header = (struct au_header *) s->header;
 686
 687   sd->sample_size = 0;
 688   sd->sample_rate = header->sample_rate;
 689   sd->bps = 0;
 690   sd->channels = header->channels;
 691   sd->choose_format (sd, s);
 692   sd->configure (sd);
 693
 694   if (STRINGP (s->data))
 695     sd->write (sd, XSTRING (s->data)->data + header->data_offset,
 696                STRING_BYTES (XSTRING (s->data)) - header->data_offset);
 697   else
 698     {
 699       int blksize = 2048;
 700       char *buffer;
 701       int nbytes;
 702
 703       /* Seek */
 704       lseek (s->fd, header->data_offset, SEEK_SET);
 705
 706       /* Copy sound data to the device.  */
 707       buffer = (char *) alloca (blksize);
 708       while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
 709         sd->write (sd, buffer, nbytes);
 710
 711       if (nbytes < 0)
 712         sound_perror ("Reading sound file");
 713     }
 714 }
 715
 716
 717 \f
 718 /***********************************************************************
 719                        Voxware Driver Interface
 720  ***********************************************************************/
 721
 722 /* This driver is available on GNU/Linux, and the free BSDs.  FreeBSD
 723    has a compatible own driver aka Luigi's driver.  */
 724
 725
 726 /* Open device SD.  If SD->file is non-null, open that device,
 727    otherwise use a default device name.  */
 728
 729 static void
 730 vox_open (sd)
 731      struct sound_device *sd;
 732 {
 733   char *file;
 734
 735   /* Open the sound device.  Default is /dev/dsp.  */
 736   if (sd->file)
 737     file = sd->file;
 738   else
 739     file = "/dev/dsp";
 740
 741   sd->fd = emacs_open (file, O_WRONLY, 0);
 742   if (sd->fd < 0)
 743     sound_perror (file);
 744 }
 745
 746
 747 /* Configure device SD from parameters in it.  */
 748
 749 static void
 750 vox_configure (sd)
 751      struct sound_device *sd;
 752 {
 753   int requested;
 754
 755   xassert (sd->fd >= 0);
 756
 757   /* Device parameters apparently depend on each other in undocumented
 758      ways (not to imply that there is any real documentation).  Be
 759      careful when reordering the calls below.  */
 760   if (sd->sample_size > 0
 761       && ioctl (sd->fd, SNDCTL_DSP_SAMPLESIZE, &sd->sample_size) < 0)
 762     sound_perror ("Setting sample size");
 763
 764   if (sd->bps > 0
 765       && ioctl (sd->fd, SNDCTL_DSP_SPEED, &sd->bps) < 0)
 766     sound_perror ("Setting speed");
 767
 768   if (sd->sample_rate > 0
 769       && ioctl (sd->fd, SOUND_PCM_WRITE_RATE, &sd->sample_rate) < 0)
 770     sound_perror ("Setting sample rate");
 771
 772   requested = sd->format;
 773   if (ioctl (sd->fd, SNDCTL_DSP_SETFMT, &sd->format) < 0)
 774     sound_perror ("Setting format");
 775   else if (requested != sd->format)
 776     error ("Setting format");
 777
 778   if (sd->channels > 1
 779       && ioctl (sd->fd, SNDCTL_DSP_STEREO, &sd->channels) < 0)
 780     sound_perror ("Setting channels");
 781
 782   if (sd->volume > 0
 783       && ioctl (sd->fd, SOUND_MIXER_WRITE_PCM, &sd->volume) < 0)
 784     sound_perror ("Setting volume");
 785 }
 786
 787
 788 /* Close device SD if it is open.  */
 789
 790 static void
 791 vox_close (sd)
 792      struct sound_device *sd;
 793 {
 794   if (sd->fd >= 0)
 795     {
 796       /* Flush sound data, and reset the device.  */
 797       ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL);
 798       ioctl (sd->fd, SNDCTL_DSP_RESET, NULL);
 799
 800       /* Close the device.  */
 801       emacs_close (sd->fd);
 802       sd->fd = -1;
 803     }
 804 }
 805
 806
 807 /* Choose device-dependent format for device SD from sound file S.  */
 808
 809 static void
 810 vox_choose_format (sd, s)
 811      struct sound_device *sd;
 812      struct sound *s;
 813 {
 814   if (s->type == RIFF)
 815     {
 816       struct wav_header *h = (struct wav_header *) s->header;
 817       if (h->precision == 8)
 818         sd->format = AFMT_U8;
 819       else if (h->precision == 16)
 820         sd->format = AFMT_S16_LE;
 821       else
 822         error ("Unsupported WAV file format");
 823     }
 824   else if (s->type == SUN_AUDIO)
 825     {
 826       struct au_header *header = (struct au_header *) s->header;
 827       switch (header->encoding)
 828         {
 829         case AU_ENCODING_ULAW_8:
 830         case AU_ENCODING_IEEE32:
 831         case AU_ENCODING_IEEE64:
 832           sd->format = AFMT_MU_LAW;
 833           break;
 834
 835         case AU_ENCODING_8:
 836         case AU_ENCODING_16:
 837         case AU_ENCODING_24:
 838         case AU_ENCODING_32:
 839           sd->format = AFMT_S16_LE;
 840           break;
 841
 842         default:
 843           error ("Unsupported AU file format");
 844         }
 845     }
 846   else
 847     abort ();
 848 }
 849
 850
 851 /* Initialize device SD.  Set up the interface functions in the device
 852    structure.  */
 853
 854 static void
 855 vox_init (sd)
 856      struct sound_device *sd;
 857 {
 858   sd->fd = -1;
 859   sd->open = vox_open;
 860   sd->close = vox_close;
 861   sd->configure = vox_configure;
 862   sd->choose_format = vox_choose_format;
 863   sd->write = vox_write;
 864 }
 865
 866
 867 /* Write NBYTES bytes from BUFFER to device SD.  */
 868
 869 static void
 870 vox_write (sd, buffer, nbytes)
 871      struct sound_device *sd;
 872      char *buffer;
 873      int nbytes;
 874 {
 875   int nwritten = emacs_write (sd->fd, buffer, nbytes);
 876   if (nwritten < 0)
 877     sound_perror ("Writing to sound device");
 878 }
 879
 880
 881 \f
 882 /***********************************************************************
 883                             Initialization
 884  ***********************************************************************/
 885
 886 void
 887 syms_of_sound ()
 888 {
 889   QCdevice = intern (":device");
 890   staticpro (&QCdevice);
 891   QCvolume = intern (":volume");
 892   staticpro (&QCvolume);
 893   Qsound = intern ("sound");
 894   staticpro (&Qsound);
 895   Qplay_sound_functions = intern ("play-sound-functions");
 896   staticpro (&Qplay_sound_functions);
 897
 898   defsubr (&Splay_sound);
 899 }
 900
 901
 902 void
 903 init_sound ()
 904 {
 905 }
 906
 907 #endif /* HAVE_SOUND */