git.chise.org Git - chise/xemacs-chise.git.1/blob - src/linuxplay.c

   1 /* linuxplay.c - play a sound file on the speaker
   2  **
   3  ** Copyright (C) 1995,96 by Markus Gutschke (gutschk@math.uni-muenster.de)
   4  ** This is version 1.3 of linuxplay.c, with platform-independent functions
   5  ** moved to a different file by Robert Bihlmeyer <robbe@orcus.priv.at>.
   6  **
   7  ** Parts of this code were inspired by sunplay.c, which is copyright 1989 by
   8  ** Jef Poskanzer and 1991,92 by Jamie Zawinski; c.f. sunplay.c for further
   9  ** information.
  10  **
  11  ** Permission to use, copy, modify, and distribute this software and its
  12  ** documentation for any purpose and without fee is hereby granted, provided
  13  ** that the above copyright notice appear in all copies and that both that
  14  ** copyright notice and this permission notice appear in supporting
  15  ** documentation.  This software is provided "as is" without express or
  16  ** implied warranty.
  17  **
  18  ** Changelog:
  19  **  1.0  --  first release; supports SunAudio, Wave and RAW file formats
  20  **           detects (and rejects) VOC file format
  21  **           tested with PC-Speaker driver only
  22  **  1.1  --  fixed bug with playback of stereo Wave files
  23  **           fixed VOC file detection
  24  **           fixed mono/8bit conversion
  25  **           cleaned up mixer programming (c.f. VoxWare-SDK)
  26  **           tested with PC-Speaker driver and with PAS16 soundcard
  27  **  1.2  --  first (incompatible) attempt at fixing reliable signal handling
  28  **  1.3  --  changed signal handling to use reliable signals; this is done
  29  **           by including "syssignal.h"; it fixes nasty program crashes
  30  **           when using native sound in TTY mode.
  31  **           added support for DEC audio file format (this is basically the
  32  **           same as Sun audio, but uses little endian format, instead).
  33  **           strip the header from Sun audio and DEC audio files in order to
  34  **           prevent noise at beginning of samples (thanks to Thomas Pundt
  35  **           <pundtt@math.uni-muenster.de> for pointing out this bug and
  36  **           providing information on the file format).
  37  **           added a few more conversion routines.
  38  **           made the code even more tolerant to the limits imposed by some
  39  **           soundcards and try to accept soundfiles even if they are not
  40  **           fully conformant to the standard.
  41  **  1.4  --  increased header size to 256; I hope there is no sample software
  42  **           that requires this much.
  43  **           added code for converting from signed to unsigned format as
  44  **           some soundcards cannot handle signed 8bit data.
  45  */
  46
  47 /* Synched up with: Not in FSF. */
  48
  49 /* XEmacs beta testers say:  undef this by default. */
  50 #undef NOVOLUMECTRLFORMULAW /* Changing the volume for uLaw-encoded
  51                                samples sounds very poor; possibly,
  52                                this is true only for the PC-Snd
  53                                driver, so undefine this symbol at your
  54                                discretion */
  55
  56 #ifdef HAVE_CONFIG_H
  57 #include <config.h>
  58 #endif
  59
  60 #include "miscplay.h"
  61 #include "nativesound.h"
  62
  63 #include <errno.h>
  64 #include <fcntl.h>
  65 #include SOUNDCARD_H_FILE /* Path computed by configure */
  66 #include <stdio.h>
  67 #include <stdlib.h>
  68 #include <string.h>
  69 #include <fcntl.h>
  70 #include <sys/file.h>
  71 #include <sys/ioctl.h>
  72 #include <sys/signal.h>
  73 #include <unistd.h>
  74
  75 #ifdef LINUXPLAYSTANDALONE
  76 #define perror(str) fprintf(stderr,"audio: %s %s\n",str,strerror(errno));
  77 #define warn(str)   fprintf(stderr,"audio: %s\n",str);
  78 #else
  79 #include "lisp.h"
  80 #include "syssignal.h"
  81 #include "sysfile.h"
  82 #define perror(str) message("audio: %s, %s ",str,strerror(errno))
  83 #define warn(str)   message("audio: %s ",GETTEXT(str))
  84 #endif
  85
  86 static  SIGTYPE (*sighup_handler) (int);
  87 static  SIGTYPE (*sigint_handler) (int);
  88
  89 static int           mix_fd;
  90 static int           audio_vol;
  91 static int           audio_fd;
  92 static char          *audio_dev = "/dev/dsp";
  93
  94 /* Intercept SIGINT and SIGHUP in order to close the audio and mixer
  95    devices before terminating sound output; this requires reliable
  96    signals as provided by "syssignal.h" */
  97 static SIGTYPE
  98 sighandler (int sig)
  99 {
 100   if (mix_fd > 0) {
 101     if (audio_vol >= 0) {
 102       ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
 103       audio_vol = -1; }
 104     if (mix_fd != audio_fd)
 105       close(mix_fd);
 106     mix_fd = -1; }
 107   if (audio_fd > 0) {
 108     ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
 109     ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
 110     close(audio_fd);
 111     audio_fd = -1; }
 112   if (sig == SIGHUP && sighup_handler)      sighup_handler(sig);
 113   else if (sig == SIGINT && sigint_handler) sigint_handler(sig);
 114   else exit(1);
 115 }
 116
 117 /* Initialize the soundcard and mixer device with the parameters that we
 118    found in the header of the sound file. If the soundcard is not capable of
 119    natively supporting the required parameters, then try to set up conversion
 120    routines.
 121    The difficulty with setting up the sound card is that the parameters are
 122    not fully orthogonal; changing one of them might affect some of the
 123    others, too. Thus we do quite a lot of double checking; actually most of
 124    this is not needed right now, but it will come in handy, if the kernel's
 125    sounddriver ever changes or if third-party sounddrivers are used. */
 126 static int audio_init(int mixx_fd, int auddio_fd, int fmt, int speed,
 127                       int tracks, int *volume,
 128                       size_t (**sndcnv) (void **, size_t *sz, void **))
 129 {
 130   int i,the_speed,the_stereo,the_fmt;
 131
 132   *sndcnv = sndcnvnop;
 133
 134   if (ioctl(auddio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
 135     perror("SNDCTL_DSP_SYNC");
 136     return(0); }
 137
 138   /* Initialize sound hardware with preferred parameters */
 139
 140   /* If the sound hardware cannot support 16 bit format or requires a
 141      different byte sex then try to drop to 8 bit format */
 142
 143   the_fmt = fmt;
 144   if(ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0) {
 145         perror("SNDCTL_DSP_SETFMT");
 146         return(0);
 147   }
 148
 149   if (fmt != the_fmt) {
 150     if (fmt == AFMT_S16_LE || fmt == AFMT_S16_BE) {
 151       *sndcnv = fmt == AFMT_S16_BE ? sndcnv2byteBE : sndcnv2byteLE;
 152       if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 153           fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
 154           fmt != the_fmt) {
 155         perror("SNDCTL_DSP_SETFMT");
 156         return(0); } }
 157     else if (fmt == AFMT_MU_LAW && the_fmt == AFMT_U8 ) {
 158       /* the kernel will convert for us */ }
 159     else {
 160       perror("SNDCTL_DSP_SETFMT");
 161       return(0); } }
 162   else if (fmt == AFMT_S8) {
 163     *sndcnv = sndcnv2unsigned;
 164     if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 165         fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
 166         fmt != the_fmt) {
 167       perror("SNDCTRL_DSP_SETFMT");
 168       return(0); } }
 169
 170   /* The PCSP driver does not support reading of the sampling rate via the
 171      SOUND_PCM_READ_RATE ioctl; determine "the_speed" here */
 172   the_speed = speed; ioctl(audio_fd,SNDCTL_DSP_SPEED,&the_speed);
 173   /* The PCSP driver does not support reading of the mono/stereo flag, thus
 174      we assume, that failure to change this mode means we are in mono mode  */
 175   if (((i = (the_stereo = tracks)-1),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0)
 176     the_stereo = 1;
 177
 178   /* Try to request stereo playback (if needed); if this cannot be supported
 179      by the hardware, then install conversion routines for mono playback */
 180
 181   /* This ioctl will fail if we use the PCSP driver; thus the value of
 182      "the_stereo" is still unchanged */
 183   ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
 184   if (tracks != the_stereo) {
 185     if (tracks == 2) {
 186       tracks = 1;
 187       *sndcnv = *sndcnv == sndcnv2byteLE   ? sndcnv2monobyteLE :
 188               *sndcnv == sndcnv2byteBE   ? sndcnv2monobyteBE :
 189               *sndcnv == sndcnv2unsigned ? sndcnv2monounsigned :
 190         the_fmt == AFMT_S16_LE ? sndcnv16_2monoLE :
 191         the_fmt == AFMT_S16_BE ? sndcnv16_2monoBE :
 192         the_fmt == AFMT_S8     ? sndcnv8S_2mono :
 193         the_fmt == AFMT_U8     ? sndcnv8U_2mono :
 194         the_fmt == AFMT_MU_LAW ? sndcnvULaw_2mono : NULL;
 195       if (*sndcnv == NULL) { /* this should not happen */
 196         perror("SNDCTL_DSP_STEREO");
 197         return(0); }
 198       /* Switch to mono mode */
 199       if (((i = 0),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0 || i) {
 200         perror("SNDCTL_DSP_STEREO");
 201         return(0); }
 202       /* Now double check that everything is set as expected */
 203       if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 204           (i != the_fmt &&
 205            (((i=the_fmt),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 206             i != the_fmt ||
 207             ((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 208             i != the_fmt)) ||
 209           (ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&i) >= 0 &&
 210            i != 1)) {
 211         /* There was no way that we could set the soundcard to a meaningful
 212            mode */
 213         perror("SNDCTL_DSP_SETFMT and SNDCTL_DSP_STEREO");
 214         return(0); } }
 215     else {
 216       /* Somebody set the soundcard to stereo even though we requested
 217          mono; this should not happen... */
 218       if (((i = the_stereo = tracks),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i))<0 ||
 219           i != the_stereo-1) {
 220         perror("SNDCTL_DSP_STEREO");
 221         return(0); }
 222       if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
 223           i != the_fmt) {
 224         perror("SNDCTL_DSP_SETFMT");
 225         return(0); } } }
 226
 227   /* Fail if deviations from desired sampling frequency are too big */
 228
 229   /* This ioctl will fail if we use the PCSP driver; thus the value of
 230      "the_speed" is still unchanged */
 231   ioctl(audio_fd,SOUND_PCM_READ_RATE,&the_speed);
 232   if (speed*14 < the_speed*10 || speed*6 > the_speed*10) {
 233     char buffer[256];
 234     sprintf(buffer,"SNDCTL_DSP_SPEED (req: %d, rtn: %d)",speed,the_speed);
 235     perror(buffer);
 236     return(0); }
 237
 238   /* Use the mixer device for setting the playback volume */
 239   if (mixx_fd > 0) {
 240     int vol = *volume & 0xFF;
 241     if (ioctl(mixx_fd,SOUND_MIXER_READ_PCM,volume) < 0)
 242       *volume = -1;
 243     if (vol < 0) vol = 0; else if (vol > 100) vol = 100;
 244 #ifdef NOVOLUMECTRLFORMULAW
 245     if (fmt == AFMT_MU_LAW)
 246       vol = 100;
 247 #endif
 248     vol |= 256*vol;
 249     /* Do not signal an error, if volume control is unavailable! */
 250     ioctl(mixx_fd,SOUND_MIXER_WRITE_PCM,&vol); }
 251
 252 #if defined(LINUXPLAYSTANDALONE) && 1
 253   /* Debugging output is displayed only when compiled as stand-alone version */
 254   {int the_volume;
 255   the_fmt = AFMT_QUERY;
 256   ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt);
 257   ioctl(auddio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
 258   ioctl(auddio_fd,SOUND_PCM_READ_RATE,&the_speed);
 259   ioctl(mixx_fd,SOUND_MIXER_READ_PCM,&the_volume);
 260   fprintf(stderr,"%s, %s, %dHz, L:%d/R:%d\n",
 261           the_fmt == AFMT_MU_LAW ? "AFMT_MU_LAW" :
 262           the_fmt == AFMT_A_LAW ? "AFMT_A_LAW" :
 263           the_fmt == AFMT_IMA_ADPCM ? "AFMT_IMA_ADPCM" :
 264           the_fmt == AFMT_U8 ? "AFMT_U8" :
 265           the_fmt == AFMT_S16_LE ? "AFMT_S16_LE" :
 266           the_fmt == AFMT_S16_BE ? "AFMT_S16_BE" :
 267           the_fmt == AFMT_S8 ? "AFMT_S8" :
 268           the_fmt == AFMT_U16_LE ? "AFMT_U16_LE" :
 269           the_fmt == AFMT_U16_BE ? "AFMT_U16_BE" :
 270           the_fmt == AFMT_MPEG ? "AFMT_MPEG" :
 271           "AFMT_???",
 272           the_stereo == 2 ? "stereo" : "mono",
 273           the_speed,
 274           the_volume / 256, the_volume % 256); }
 275 #endif
 276
 277   return(1);
 278 }
 279
 280 /* XEmacs requires code both for playback of pre-loaded data and for playback
 281    from a soundfile; we use one function for both cases.
 282
 283    Returns 1 on succes. 0 otherwise.
 284 */
 285 static int linux_play_data_or_file(int fd,unsigned char *data,
 286                                     int length,int volume)
 287 {
 288   size_t         (*parsesndfile)(void **dayta,size_t *sz,void **outbuf);
 289   size_t         (*sndcnv)(void **dayta,size_t *sz,void **);
 290   fmtType        ffmt;
 291   int            fmt,speed,tracks;
 292   unsigned char *pptr,*optr,*cptr,*sptr;
 293   int            wrtn,rrtn,crtn,prtn;
 294   unsigned char         sndbuf[SNDBUFSZ];
 295
 296   /* We need to read at least the header information before we can start
 297      doing anything */
 298   if (!data || length < HEADERSZ) {
 299     if (fd < 0) return 0;
 300     else {
 301       length = read(fd,sndbuf,SNDBUFSZ);
 302       if (length < HEADERSZ)
 303         return 0;
 304       data   = sndbuf;
 305       length = SNDBUFSZ; }
 306   }
 307
 308   ffmt = analyze_format(data,&fmt,&speed,&tracks,&parsesndfile);
 309
 310   if (ffmt != fmtRaw && ffmt != fmtSunAudio && ffmt != fmtWave) {
 311     warn("Unsupported file format (neither RAW, nor Sun/DECAudio, nor WAVE)");
 312       return 0; }
 313
 314   /* The VoxWare-SDK discourages opening /dev/audio; opening /dev/dsp and
 315      properly initializing it via ioctl() is preferred */
 316   if ((audio_fd=open(audio_dev, O_WRONLY | O_NONBLOCK, 0)) < 0) {
 317     /* JV. Much too verbose. In addition this can crash. See NOTE: in
 318        Fplay_sound
 319        perror(audio_dev); */
 320     if (mix_fd > 0 && mix_fd != audio_fd) { close(mix_fd); mix_fd = -1; }
 321     return 0; }
 322
 323   /* The VoxWare-SDK discourages direct manipulation of the mixer device as
 324      this could lead to problems, when multiple sound cards are installed */
 325   mix_fd = audio_fd;
 326
 327   sighup_handler = signal(SIGHUP, sighandler);
 328   sigint_handler = signal(SIGINT, sighandler);
 329
 330   if (!audio_init(mix_fd,audio_fd,fmt,speed,tracks,&volume,&sndcnv))
 331     goto END_OF_PLAY;
 332   audio_vol = volume;
 333
 334   reset_parsestate();
 335
 336   /* Mainloop: read a block of data, parse its contents, perform all
 337                the necessary conversions and output it to the sound
 338                device; repeat until all data has been processed */
 339   rrtn = length;
 340   do {
 341     for (pptr = data; (prtn = parsesndfile((void **)&pptr,(size_t *)&rrtn,
 342                                            (void **)&optr)) > 0; )
 343       for (cptr = optr; (crtn = sndcnv((void **)&cptr,(size_t *) &prtn,
 344                                        (void **)&sptr)) > 0; ) {
 345         for (;;) {
 346           if ((wrtn = write(audio_fd,sptr,crtn)) < 0) {
 347             perror("write"); goto END_OF_PLAY; }
 348           else if (wrtn) break;
 349           else if (ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
 350             perror("SNDCTL_DSP_SYNC"); goto END_OF_PLAY; } }
 351         if (wrtn != crtn) {
 352           char buf[255];
 353           sprintf(buf,"play: crtn = %d, wrtn = %d",crtn,wrtn);
 354           warn(buf);
 355           goto END_OF_PLAY; } }
 356     if (fd >= 0) {
 357       if ((rrtn = read(fd,sndbuf,SNDBUFSZ)) < 0) {
 358         perror("read"); goto END_OF_PLAY; } }
 359     else
 360       break;
 361   } while (rrtn > 0);
 362
 363   if (ffmt == fmtWave)
 364     parse_wave_complete();
 365
 366
 367 END_OF_PLAY:
 368   /* Now cleanup all used resources */
 369
 370   ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
 371   ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
 372
 373   signal(SIGHUP,sighup_handler);
 374   signal(SIGINT,sigint_handler);
 375
 376   if (mix_fd > 0) {
 377     if (audio_vol >= 0) {
 378       ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
 379       audio_vol = -1; }
 380     if (mix_fd != audio_fd)
 381       close(mix_fd);
 382     mix_fd = -1; }
 383
 384   close(audio_fd);
 385   audio_fd = -1;
 386
 387   return 1;
 388 }
 389
 390 /* Call "linux_play_data_or_file" with the appropriate parameters for
 391    playing a soundfile */
 392 void play_sound_file (char *sound_file, int volume)
 393 {
 394   int fd;
 395
 396   if ((fd=open(sound_file,O_RDONLY,0)) < 0) {
 397     perror(sound_file);
 398     return; }
 399   linux_play_data_or_file(fd,NULL,0,volume);
 400   close(fd);
 401   return;
 402 }
 403
 404 /* Call "linux_play_data_or_file" with the appropriate parameters for
 405    playing pre-loaded data */
 406 int play_sound_data (unsigned char *data, int length, int volume)
 407 {
 408   return linux_play_data_or_file(-1,data,length,volume);
 409 }