src/audio/dsp/SDL_dspaudio.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21
  22     Modified in Oct 2004 by Hannu Savolainen
  23     hannu@opensound.com
  24 */
  25 #include "SDL_config.h"
  26
  27 /* Allow access to a raw mixing buffer */
  28
  29 #include <stdio.h>      /* For perror() */
  30 #include <string.h>     /* For strerror() */
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <signal.h>
  35 #include <sys/time.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/stat.h>
  38
  39 #if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
  40 /* This is installed on some systems */
  41 #include <soundcard.h>
  42 #else
  43 /* This is recommended by OSS */
  44 #include <sys/soundcard.h>
  45 #endif
  46
  47 #include "SDL_timer.h"
  48 #include "SDL_audio.h"
  49 #include "../SDL_audiomem.h"
  50 #include "../SDL_audio_c.h"
  51 #include "../SDL_audiodev_c.h"
  52 #include "SDL_dspaudio.h"
  53
  54 /* The tag name used by DSP audio */
  55 #define DSP_DRIVER_NAME         "dsp"
  56
  57 /* Open the audio device for playback, and don't block if busy */
  58 #define OPEN_FLAGS      (O_WRONLY|O_NONBLOCK)
  59
  60 /* Audio driver functions */
  61 static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec);
  62 static void DSP_WaitAudio(_THIS);
  63 static void DSP_PlayAudio(_THIS);
  64 static Uint8 *DSP_GetAudioBuf(_THIS);
  65 static void DSP_CloseAudio(_THIS);
  66
  67 /* Audio driver bootstrap functions */
  68
  69 static int Audio_Available(void)
  70 {
  71         int fd;
  72         int available;
  73
  74         available = 0;
  75         fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
  76         if ( fd >= 0 ) {
  77                 available = 1;
  78                 close(fd);
  79         }
  80         return(available);
  81 }
  82
  83 static void Audio_DeleteDevice(SDL_AudioDevice *device)
  84 {
  85         SDL_free(device->hidden);
  86         SDL_free(device);
  87 }
  88
  89 static SDL_AudioDevice *Audio_CreateDevice(int devindex)
  90 {
  91         SDL_AudioDevice *this;
  92
  93         /* Initialize all variables that we clean on shutdown */
  94         this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
  95         if ( this ) {
  96                 SDL_memset(this, 0, (sizeof *this));
  97                 this->hidden = (struct SDL_PrivateAudioData *)
  98                                 SDL_malloc((sizeof *this->hidden));
  99         }
 100         if ( (this == NULL) || (this->hidden == NULL) ) {
 101                 SDL_OutOfMemory();
 102                 if ( this ) {
 103                         SDL_free(this);
 104                 }
 105                 return(0);
 106         }
 107         SDL_memset(this->hidden, 0, (sizeof *this->hidden));
 108         audio_fd = -1;
 109
 110         /* Set the function pointers */
 111         this->OpenAudio = DSP_OpenAudio;
 112         this->WaitAudio = DSP_WaitAudio;
 113         this->PlayAudio = DSP_PlayAudio;
 114         this->GetAudioBuf = DSP_GetAudioBuf;
 115         this->CloseAudio = DSP_CloseAudio;
 116
 117         this->free = Audio_DeleteDevice;
 118
 119         return this;
 120 }
 121
 122 AudioBootStrap DSP_bootstrap = {
 123         DSP_DRIVER_NAME, "OSS /dev/dsp standard audio",
 124         Audio_Available, Audio_CreateDevice
 125 };
 126
 127 /* This function waits until it is possible to write a full sound buffer */
 128 static void DSP_WaitAudio(_THIS)
 129 {
 130         /* Not needed at all since OSS handles waiting automagically */
 131 }
 132
 133 static void DSP_PlayAudio(_THIS)
 134 {
 135         if (write(audio_fd, mixbuf, mixlen)==-1)
 136         {
 137                 perror("Audio write");
 138                 this->enabled = 0;
 139         }
 140
 141 #ifdef DEBUG_AUDIO
 142         fprintf(stderr, "Wrote %d bytes of audio data\n", mixlen);
 143 #endif
 144 }
 145
 146 static Uint8 *DSP_GetAudioBuf(_THIS)
 147 {
 148         return(mixbuf);
 149 }
 150
 151 static void DSP_CloseAudio(_THIS)
 152 {
 153         if ( mixbuf != NULL ) {
 154                 SDL_FreeAudioMem(mixbuf);
 155                 mixbuf = NULL;
 156         }
 157         if ( audio_fd >= 0 ) {
 158                 close(audio_fd);
 159                 audio_fd = -1;
 160         }
 161 }
 162
 163 static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec)
 164 {
 165         char audiodev[1024];
 166         int format;
 167         int value;
 168         int frag_spec;
 169         Uint16 test_format;
 170
 171     /* Make sure fragment size stays a power of 2, or OSS fails. */
 172     /* I don't know which of these are actually legal values, though... */
 173     if (spec->channels > 8)
 174         spec->channels = 8;
 175     else if (spec->channels > 4)
 176         spec->channels = 4;
 177     else if (spec->channels > 2)
 178         spec->channels = 2;
 179
 180         /* Open the audio device */
 181         audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
 182         if ( audio_fd < 0 ) {
 183                 SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
 184                 return(-1);
 185         }
 186         mixbuf = NULL;
 187
 188         /* Make the file descriptor use blocking writes with fcntl() */
 189         { long flags;
 190                 flags = fcntl(audio_fd, F_GETFL);
 191                 flags &= ~O_NONBLOCK;
 192                 if ( fcntl(audio_fd, F_SETFL, flags) < 0 ) {
 193                         SDL_SetError("Couldn't set audio blocking mode");
 194                         DSP_CloseAudio(this);
 195                         return(-1);
 196                 }
 197         }
 198
 199         /* Get a list of supported hardware formats */
 200         if ( ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0 ) {
 201                 perror("SNDCTL_DSP_GETFMTS");
 202                 SDL_SetError("Couldn't get audio format list");
 203                 DSP_CloseAudio(this);
 204                 return(-1);
 205         }
 206
 207         /* Try for a closest match on audio format */
 208         format = 0;
 209         for ( test_format = SDL_FirstAudioFormat(spec->format);
 210                                                 ! format && test_format; ) {
 211 #ifdef DEBUG_AUDIO
 212                 fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 213 #endif
 214                 switch ( test_format ) {
 215                         case AUDIO_U8:
 216                                 if ( value & AFMT_U8 ) {
 217                                         format = AFMT_U8;
 218                                 }
 219                                 break;
 220                         case AUDIO_S16LSB:
 221                                 if ( value & AFMT_S16_LE ) {
 222                                         format = AFMT_S16_LE;
 223                                 }
 224                                 break;
 225                         case AUDIO_S16MSB:
 226                                 if ( value & AFMT_S16_BE ) {
 227                                         format = AFMT_S16_BE;
 228                                 }
 229                                 break;
 230 #if 0
 231 /*
 232  * These formats are not used by any real life systems so they are not
 233  * needed here.
 234  */
 235                         case AUDIO_S8:
 236                                 if ( value & AFMT_S8 ) {
 237                                         format = AFMT_S8;
 238                                 }
 239                                 break;
 240                         case AUDIO_U16LSB:
 241                                 if ( value & AFMT_U16_LE ) {
 242                                         format = AFMT_U16_LE;
 243                                 }
 244                                 break;
 245                         case AUDIO_U16MSB:
 246                                 if ( value & AFMT_U16_BE ) {
 247                                         format = AFMT_U16_BE;
 248                                 }
 249                                 break;
 250 #endif
 251                         default:
 252                                 format = 0;
 253                                 break;
 254                 }
 255                 if ( ! format ) {
 256                         test_format = SDL_NextAudioFormat();
 257                 }
 258         }
 259         if ( format == 0 ) {
 260                 SDL_SetError("Couldn't find any hardware audio formats");
 261                 DSP_CloseAudio(this);
 262                 return(-1);
 263         }
 264         spec->format = test_format;
 265
 266         /* Set the audio format */
 267         value = format;
 268         if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
 269                                                 (value != format) ) {
 270                 perror("SNDCTL_DSP_SETFMT");
 271                 SDL_SetError("Couldn't set audio format");
 272                 DSP_CloseAudio(this);
 273                 return(-1);
 274         }
 275
 276         /* Set the number of channels of output */
 277         value = spec->channels;
 278         if ( ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &value) < 0 ) {
 279                 perror("SNDCTL_DSP_CHANNELS");
 280                 SDL_SetError("Cannot set the number of channels");
 281                 DSP_CloseAudio(this);
 282                 return(-1);
 283         }
 284         spec->channels = value;
 285
 286         /* Set the DSP frequency */
 287         value = spec->freq;
 288         if ( ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0 ) {
 289                 perror("SNDCTL_DSP_SPEED");
 290                 SDL_SetError("Couldn't set audio frequency");
 291                 DSP_CloseAudio(this);
 292                 return(-1);
 293         }
 294         spec->freq = value;
 295
 296         /* Calculate the final parameters for this audio specification */
 297         SDL_CalculateAudioSpec(spec);
 298
 299         /* Determine the power of two of the fragment size */
 300         for ( frag_spec = 0; (0x01U<<frag_spec) < spec->size; ++frag_spec );
 301         if ( (0x01U<<frag_spec) != spec->size ) {
 302                 SDL_SetError("Fragment size must be a power of two");
 303                 DSP_CloseAudio(this);
 304                 return(-1);
 305         }
 306         frag_spec |= 0x00020000;        /* two fragments, for low latency */
 307
 308         /* Set the audio buffering parameters */
 309 #ifdef DEBUG_AUDIO
 310         fprintf(stderr, "Requesting %d fragments of size %d\n",
 311                 (frag_spec >> 16), 1<<(frag_spec&0xFFFF));
 312 #endif
 313         if ( ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0 ) {
 314                 perror("SNDCTL_DSP_SETFRAGMENT");
 315         }
 316 #ifdef DEBUG_AUDIO
 317         { audio_buf_info info;
 318           ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info);
 319           fprintf(stderr, "fragments = %d\n", info.fragments);
 320           fprintf(stderr, "fragstotal = %d\n", info.fragstotal);
 321           fprintf(stderr, "fragsize = %d\n", info.fragsize);
 322           fprintf(stderr, "bytes = %d\n", info.bytes);
 323         }
 324 #endif
 325
 326         /* Allocate mixing buffer */
 327         mixlen = spec->size;
 328         mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
 329         if ( mixbuf == NULL ) {
 330                 DSP_CloseAudio(this);
 331                 return(-1);
 332         }
 333         SDL_memset(mixbuf, spec->silence, spec->size);
 334
 335         /* Get the parent process id (we're the parent of the audio thread) */
 336         parent = getpid();
 337
 338         /* We're ready to rock and roll. :-) */
 339         return(0);
 340 }