src/audio/dma/SDL_dmaaudio.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 #include "SDL_config.h"
  23
  24 /* Allow access to a raw mixing buffer */
  25
  26 #include <stdio.h>
  27 #include <string.h>     /* For strerror() */
  28 #include <errno.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <signal.h>
  32 #include <sys/types.h>
  33 #include <sys/time.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/stat.h>
  36 #include <sys/mman.h>
  37
  38 #if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
  39 /* This is installed on some systems */
  40 #include <soundcard.h>
  41 #else
  42 /* This is recommended by OSS */
  43 #include <sys/soundcard.h>
  44 #endif
  45
  46 #ifndef MAP_FAILED
  47 #define MAP_FAILED      ((Uint8 *)-1)
  48 #endif
  49
  50 #include "SDL_timer.h"
  51 #include "SDL_audio.h"
  52 #include "../SDL_audio_c.h"
  53 #include "../SDL_audiodev_c.h"
  54 #include "SDL_dmaaudio.h"
  55
  56 /* The tag name used by DMA audio */
  57 #define DMA_DRIVER_NAME         "dma"
  58
  59 /* Open the audio device for playback, and don't block if busy */
  60 #define OPEN_FLAGS      (O_RDWR|O_NONBLOCK)
  61
  62 /* Audio driver functions */
  63 static int DMA_OpenAudio(_THIS, SDL_AudioSpec *spec);
  64 static void DMA_WaitAudio(_THIS);
  65 static void DMA_PlayAudio(_THIS);
  66 static Uint8 *DMA_GetAudioBuf(_THIS);
  67 static void DMA_CloseAudio(_THIS);
  68
  69 /* Audio driver bootstrap functions */
  70
  71 static int Audio_Available(void)
  72 {
  73         int available;
  74         int fd;
  75
  76         available = 0;
  77
  78         fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
  79         if ( fd >= 0 ) {
  80                 int caps;
  81                 struct audio_buf_info info;
  82
  83                 if ( (ioctl(fd, SNDCTL_DSP_GETCAPS, &caps) == 0) &&
  84                      (caps & DSP_CAP_TRIGGER) && (caps & DSP_CAP_MMAP) &&
  85                      (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) == 0) ) {
  86                         available = 1;
  87                 }
  88                 close(fd);
  89         }
  90         return(available);
  91 }
  92
  93 static void Audio_DeleteDevice(SDL_AudioDevice *device)
  94 {
  95         SDL_free(device->hidden);
  96         SDL_free(device);
  97 }
  98
  99 static SDL_AudioDevice *Audio_CreateDevice(int devindex)
 100 {
 101         SDL_AudioDevice *this;
 102
 103         /* Initialize all variables that we clean on shutdown */
 104         this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
 105         if ( this ) {
 106                 SDL_memset(this, 0, (sizeof *this));
 107                 this->hidden = (struct SDL_PrivateAudioData *)
 108                                 SDL_malloc((sizeof *this->hidden));
 109         }
 110         if ( (this == NULL) || (this->hidden == NULL) ) {
 111                 SDL_OutOfMemory();
 112                 if ( this ) {
 113                         SDL_free(this);
 114                 }
 115                 return(0);
 116         }
 117         SDL_memset(this->hidden, 0, (sizeof *this->hidden));
 118         audio_fd = -1;
 119
 120         /* Set the function pointers */
 121         this->OpenAudio = DMA_OpenAudio;
 122         this->WaitAudio = DMA_WaitAudio;
 123         this->PlayAudio = DMA_PlayAudio;
 124         this->GetAudioBuf = DMA_GetAudioBuf;
 125         this->CloseAudio = DMA_CloseAudio;
 126
 127         this->free = Audio_DeleteDevice;
 128
 129         return this;
 130 }
 131
 132 AudioBootStrap DMA_bootstrap = {
 133         DMA_DRIVER_NAME, "OSS /dev/dsp DMA audio",
 134         Audio_Available, Audio_CreateDevice
 135 };
 136
 137 /* This function waits until it is possible to write a full sound buffer */
 138 static void DMA_WaitAudio(_THIS)
 139 {
 140         fd_set fdset;
 141
 142         /* Check to see if the thread-parent process is still alive */
 143         { static int cnt = 0;
 144                 /* Note that this only works with thread implementations
 145                    that use a different process id for each thread.
 146                 */
 147                 if (parent && (((++cnt)%10) == 0)) { /* Check every 10 loops */
 148                         if ( kill(parent, 0) < 0 ) {
 149                                 this->enabled = 0;
 150                         }
 151                 }
 152         }
 153
 154         /* See if we need to use timed audio synchronization */
 155         if ( frame_ticks ) {
 156                 /* Use timer for general audio synchronization */
 157                 Sint32 ticks;
 158
 159                 ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
 160                 if ( ticks > 0 ) {
 161                         SDL_Delay(ticks);
 162                 }
 163         } else {
 164                 /* Use select() for audio synchronization */
 165                 struct timeval timeout;
 166                 FD_ZERO(&fdset);
 167                 FD_SET(audio_fd, &fdset);
 168                 timeout.tv_sec = 10;
 169                 timeout.tv_usec = 0;
 170 #ifdef DEBUG_AUDIO
 171                 fprintf(stderr, "Waiting for audio to get ready\n");
 172 #endif
 173                 if ( select(audio_fd+1, NULL, &fdset, NULL, &timeout) <= 0 ) {
 174                         const char *message =
 175 #ifdef AUDIO_OSPACE_HACK
 176                         "Audio timeout - buggy audio driver? (trying ospace)";
 177 #else
 178                         "Audio timeout - buggy audio driver? (disabled)";
 179 #endif
 180                         /* In general we should never print to the screen,
 181                            but in this case we have no other way of letting
 182                            the user know what happened.
 183                         */
 184                         fprintf(stderr, "SDL: %s\n", message);
 185 #ifdef AUDIO_OSPACE_HACK
 186                         /* We may be able to use GET_OSPACE trick */
 187                         frame_ticks = (float)(this->spec->samples*1000) /
 188                                               this->spec->freq;
 189                         next_frame = SDL_GetTicks()+frame_ticks;
 190 #else
 191                         this->enabled = 0;
 192                         /* Don't try to close - may hang */
 193                         audio_fd = -1;
 194 #ifdef DEBUG_AUDIO
 195                         fprintf(stderr, "Done disabling audio\n");
 196 #endif
 197 #endif /* AUDIO_OSPACE_HACK */
 198                 }
 199 #ifdef DEBUG_AUDIO
 200                 fprintf(stderr, "Ready!\n");
 201 #endif
 202         }
 203 }
 204
 205 static void DMA_PlayAudio(_THIS)
 206 {
 207         /* If timer synchronization is enabled, set the next write frame */
 208         if ( frame_ticks ) {
 209                 next_frame += frame_ticks;
 210         }
 211         return;
 212 }
 213
 214 static Uint8 *DMA_GetAudioBuf(_THIS)
 215 {
 216         count_info info;
 217         int playing;
 218         int filling;
 219
 220         /* Get number of blocks, looping if we're not using select() */
 221         do {
 222                 if ( ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &info) < 0 ) {
 223                         /* Uh oh... */
 224                         this->enabled = 0;
 225                         return(NULL);
 226                 }
 227         } while ( frame_ticks && (info.blocks < 1) );
 228 #ifdef DEBUG_AUDIO
 229         if ( info.blocks > 1 ) {
 230                 printf("Warning: audio underflow (%d frags)\n", info.blocks-1);
 231         }
 232 #endif
 233         playing = info.ptr / this->spec.size;
 234         filling = (playing + 1)%num_buffers;
 235         return (dma_buf + (filling * this->spec.size));
 236 }
 237
 238 static void DMA_CloseAudio(_THIS)
 239 {
 240         if ( dma_buf != NULL ) {
 241                 munmap(dma_buf, dma_len);
 242                 dma_buf = NULL;
 243         }
 244         if ( audio_fd >= 0 ) {
 245                 close(audio_fd);
 246                 audio_fd = -1;
 247         }
 248 }
 249
 250 static int DMA_ReopenAudio(_THIS, const char *audiodev, int format, int stereo,
 251                                                         SDL_AudioSpec *spec)
 252 {
 253         int frag_spec;
 254         int value;
 255
 256         /* Close and then reopen the audio device */
 257         close(audio_fd);
 258         audio_fd = open(audiodev, O_RDWR, 0);
 259         if ( audio_fd < 0 ) {
 260                 SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
 261                 return(-1);
 262         }
 263
 264         /* Calculate the final parameters for this audio specification */
 265         SDL_CalculateAudioSpec(spec);
 266
 267         /* Determine the power of two of the fragment size */
 268         for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
 269         if ( (0x01<<frag_spec) != spec->size ) {
 270                 SDL_SetError("Fragment size must be a power of two");
 271                 return(-1);
 272         }
 273
 274         /* Set the audio buffering parameters */
 275         if ( ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0 ) {
 276                 SDL_SetError("Couldn't set audio fragment spec");
 277                 return(-1);
 278         }
 279
 280         /* Set the audio format */
 281         value = format;
 282         if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
 283                                                 (value != format) ) {
 284                 SDL_SetError("Couldn't set audio format");
 285                 return(-1);
 286         }
 287
 288         /* Set mono or stereo audio */
 289         value = (spec->channels > 1);
 290         if ( (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo) < 0) ||
 291                                                 (value != stereo) ) {
 292                 SDL_SetError("Couldn't set audio channels");
 293                 return(-1);
 294         }
 295
 296         /* Set the DSP frequency */
 297         value = spec->freq;
 298         if ( ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0 ) {
 299                 SDL_SetError("Couldn't set audio frequency");
 300                 return(-1);
 301         }
 302         spec->freq = value;
 303
 304         /* We successfully re-opened the audio */
 305         return(0);
 306 }
 307
 308 static int DMA_OpenAudio(_THIS, SDL_AudioSpec *spec)
 309 {
 310         char audiodev[1024];
 311         int format;
 312         int stereo;
 313         int value;
 314         Uint16 test_format;
 315         struct audio_buf_info info;
 316
 317         /* Reset the timer synchronization flag */
 318         frame_ticks = 0.0;
 319
 320         /* Open the audio device */
 321         audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
 322         if ( audio_fd < 0 ) {
 323                 SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
 324                 return(-1);
 325         }
 326         dma_buf = NULL;
 327         ioctl(audio_fd, SNDCTL_DSP_RESET, 0);
 328
 329         /* Get a list of supported hardware formats */
 330         if ( ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0 ) {
 331                 SDL_SetError("Couldn't get audio format list");
 332                 return(-1);
 333         }
 334
 335         /* Try for a closest match on audio format */
 336         format = 0;
 337         for ( test_format = SDL_FirstAudioFormat(spec->format);
 338                                                 ! format && test_format; ) {
 339 #ifdef DEBUG_AUDIO
 340                 fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 341 #endif
 342                 switch ( test_format ) {
 343                         case AUDIO_U8:
 344                                 if ( value & AFMT_U8 ) {
 345                                         format = AFMT_U8;
 346                                 }
 347                                 break;
 348                         case AUDIO_S8:
 349                                 if ( value & AFMT_S8 ) {
 350                                         format = AFMT_S8;
 351                                 }
 352                                 break;
 353                         case AUDIO_S16LSB:
 354                                 if ( value & AFMT_S16_LE ) {
 355                                         format = AFMT_S16_LE;
 356                                 }
 357                                 break;
 358                         case AUDIO_S16MSB:
 359                                 if ( value & AFMT_S16_BE ) {
 360                                         format = AFMT_S16_BE;
 361                                 }
 362                                 break;
 363                         case AUDIO_U16LSB:
 364                                 if ( value & AFMT_U16_LE ) {
 365                                         format = AFMT_U16_LE;
 366                                 }
 367                                 break;
 368                         case AUDIO_U16MSB:
 369                                 if ( value & AFMT_U16_BE ) {
 370                                         format = AFMT_U16_BE;
 371                                 }
 372                                 break;
 373                         default:
 374                                 format = 0;
 375                                 break;
 376                 }
 377                 if ( ! format ) {
 378                         test_format = SDL_NextAudioFormat();
 379                 }
 380         }
 381         if ( format == 0 ) {
 382                 SDL_SetError("Couldn't find any hardware audio formats");
 383                 return(-1);
 384         }
 385         spec->format = test_format;
 386
 387         /* Set the audio format */
 388         value = format;
 389         if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
 390                                                 (value != format) ) {
 391                 SDL_SetError("Couldn't set audio format");
 392                 return(-1);
 393         }
 394
 395         /* Set mono or stereo audio (currently only two channels supported) */
 396         stereo = (spec->channels > 1);
 397         ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo);
 398         if ( stereo ) {
 399                 spec->channels = 2;
 400         } else {
 401                 spec->channels = 1;
 402         }
 403
 404         /* Because some drivers don't allow setting the buffer size
 405            after setting the format, we must re-open the audio device
 406            once we know what format and channels are supported
 407          */
 408         if ( DMA_ReopenAudio(this, audiodev, format, stereo, spec) < 0 ) {
 409                 /* Error is set by DMA_ReopenAudio() */
 410                 return(-1);
 411         }
 412
 413         /* Memory map the audio buffer */
 414         if ( ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) < 0 ) {
 415                 SDL_SetError("Couldn't get OSPACE parameters");
 416                 return(-1);
 417         }
 418         spec->size = info.fragsize;
 419         spec->samples = spec->size / ((spec->format & 0xFF) / 8);
 420         spec->samples /= spec->channels;
 421         num_buffers = info.fragstotal;
 422         dma_len = num_buffers*spec->size;
 423         dma_buf = (Uint8 *)mmap(NULL, dma_len, PROT_WRITE, MAP_SHARED,
 424                                                         audio_fd, 0);
 425         if ( dma_buf == MAP_FAILED ) {
 426                 SDL_SetError("DMA memory map failed");
 427                 dma_buf = NULL;
 428                 return(-1);
 429         }
 430         SDL_memset(dma_buf, spec->silence, dma_len);
 431
 432         /* Check to see if we need to use select() workaround */
 433         { char *workaround;
 434                 workaround = SDL_getenv("SDL_DSP_NOSELECT");
 435                 if ( workaround ) {
 436                         frame_ticks = (float)(spec->samples*1000)/spec->freq;
 437                         next_frame = SDL_GetTicks()+frame_ticks;
 438                 }
 439         }
 440
 441         /* Trigger audio playback */
 442         value = 0;
 443         ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value);
 444         value = PCM_ENABLE_OUTPUT;
 445         if ( ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value) < 0 ) {
 446                 SDL_SetError("Couldn't trigger audio output");
 447                 return(-1);
 448         }
 449
 450         /* Get the parent process id (we're the parent of the audio thread) */
 451         parent = getpid();
 452
 453         /* We're ready to rock and roll. :-) */
 454         return(0);
 455 }