Mercurial > sdl-ios-xcode
annotate src/audio/dma/SDL_dmaaudio.c @ 4223:63fd67e17705 SDL-1.2
Fixed bug #727
Lorenzo Desole 2009-04-19 07:36:10 PDT
I am one of the developers of a multimedia application (My Media System MMS),
which uses SDL.
MMS is normally running in fullscreen mode but it switches it off before
launching external applications (mplayer, xine, etc.).
The problem with fullscreen is that when the latter is switched off either via
SDL_WM_ToggleFullScreen() or SDL_SetVideoMode(), SDL compares the current
screen sizes with the ones saved when the video system was initted, and if they
don't match, it calls XF86VidModeSwitchToMode() to switch to the old modeline.
This makes it impossible for external programs and for MMS itself to use RandR
to change the screen size, because next time fullscreen mode is turned off, it
bombs out with the following error:
X Error of failed request: BadValue (integer parameter out of range for
operation)
Major opcode of failed request: 136 (XFree86-VidModeExtension)
Minor opcode of failed request: 10 (XF86VidModeSwitchToMode)
[...]
Obviously this happens only if the new screen resolution is smaller than the
original one and XF86VidModeSwitchToMode() can't succeed.
I couldn't find any way to inform SDL that the screen resolution it uses as
reference is no longer valid.
This can be fixed by adding "save_mode(this)" to
./src/video/x11/SDL_x11modes.c, API X11_EnterFullScreen(_THIS), like this:
int X11_EnterFullScreen(_THIS)
{
int okay;
+ save_mode(this);
I can't rule out possible side effects, but I don't see any.
While I admit this is a minor issue for the general users, it is a major
showstopper for our program where the ability to change screen resolution and
refresh rate according to the movie being played, is very important.
Thanks in advance.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Mon, 21 Sep 2009 11:14:36 +0000 |
| parents | a1b03ba2fcd0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
| 4159 | 3 Copyright (C) 1997-2009 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 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 | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
960
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 18 |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
94
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
22 #include "SDL_config.h" |
| 0 | 23 |
| 24 /* Allow access to a raw mixing buffer */ | |
| 25 | |
| 26 #include <stdio.h> | |
|
1341
d02b552e5304
Configure dynamically generates SDL_config.h
Sam Lantinga <slouken@libsdl.org>
parents:
1338
diff
changeset
|
27 #include <string.h> /* For strerror() */ |
| 0 | 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> | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
37 |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
38 #if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H |
|
94
ae6e6b73333f
Cleaned up the OpenBSD port, thanks to Peter Valchev
Sam Lantinga <slouken@lokigames.com>
parents:
92
diff
changeset
|
39 /* This is installed on some systems */ |
|
ae6e6b73333f
Cleaned up the OpenBSD port, thanks to Peter Valchev
Sam Lantinga <slouken@lokigames.com>
parents:
92
diff
changeset
|
40 #include <soundcard.h> |
|
ae6e6b73333f
Cleaned up the OpenBSD port, thanks to Peter Valchev
Sam Lantinga <slouken@lokigames.com>
parents:
92
diff
changeset
|
41 #else |
|
ae6e6b73333f
Cleaned up the OpenBSD port, thanks to Peter Valchev
Sam Lantinga <slouken@lokigames.com>
parents:
92
diff
changeset
|
42 /* This is recommended by OSS */ |
| 0 | 43 #include <sys/soundcard.h> |
|
94
ae6e6b73333f
Cleaned up the OpenBSD port, thanks to Peter Valchev
Sam Lantinga <slouken@lokigames.com>
parents:
92
diff
changeset
|
44 #endif |
| 0 | 45 |
| 46 #ifndef MAP_FAILED | |
| 47 #define MAP_FAILED ((Uint8 *)-1) | |
| 48 #endif | |
| 49 | |
|
1358
c71e05b4dc2e
More header massaging... works great on Windows. ;-)
Sam Lantinga <slouken@libsdl.org>
parents:
1341
diff
changeset
|
50 #include "SDL_timer.h" |
| 0 | 51 #include "SDL_audio.h" |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
52 #include "../SDL_audio_c.h" |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
53 #include "../SDL_audiodev_c.h" |
| 0 | 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 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
95 SDL_free(device->hidden); |
|
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
96 SDL_free(device); |
| 0 | 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 */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
104 this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); |
| 0 | 105 if ( this ) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
106 SDL_memset(this, 0, (sizeof *this)); |
| 0 | 107 this->hidden = (struct SDL_PrivateAudioData *) |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
108 SDL_malloc((sizeof *this->hidden)); |
| 0 | 109 } |
| 110 if ( (this == NULL) || (this->hidden == NULL) ) { | |
| 111 SDL_OutOfMemory(); | |
| 112 if ( this ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
113 SDL_free(this); |
| 0 | 114 } |
| 115 return(0); | |
| 116 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
117 SDL_memset(this->hidden, 0, (sizeof *this->hidden)); |
| 0 | 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; | |
|
960
eec28a5278be
Date: Sat, 9 Oct 2004 02:46:18 +0300 (EEST)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
298 if ( ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0 ) { |
| 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: | |
|
354
30935e76acb5
Updated ALSA audio support for ALSA 0.9
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
374 format = 0; |
| 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 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
430 SDL_memset(dma_buf, spec->silence, dma_len); |
| 0 | 431 |
| 432 /* Check to see if we need to use select() workaround */ | |
| 433 { char *workaround; | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
434 workaround = SDL_getenv("SDL_DSP_NOSELECT"); |
| 0 | 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 } |