sdl-ios-xcode: src/audio/paudio/SDL

comparison src/audio/paudio/SDL_paudio.c @ 2049:5f6550e5184f

Merged SDL-ryan-multiple-audio-device branch r2803:2871 into the trunk.

author	Ryan C. Gordon <icculus@icculus.org>
date	Tue, 17 Oct 2006 09:15:21 +0000
parents	3b4ce57c6215
children	866052b01ee5

comparison

equal deleted inserted replaced

-:6067c7f9a672
+:5f6550e5184f
 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/ioctl.h>
+#include <sys/types.h>
 #include <sys/stat.h>
 #include "SDL_timer.h"
 #include "SDL_audio.h"
+#include "SDL_stdinc.h"
 #include "../SDL_audiomem.h"
 #include "../SDL_audio_c.h"
-#include "../SDL_audiodev_c.h"
 #include "SDL_paudio.h"
-#define DEBUG_AUDIO 1
+#define DEBUG_AUDIO 0
 /* A conflict within AIX 4.3.3 <sys/> headers and probably others as well.
 * I guess nobody ever uses audio... Shame over AIX header files.  */
 #include <sys/machine.h>
 #undef BIG_ENDIAN
 #include <sys/audio.h>
 /* The tag name used by paud audio */
-#define Paud_DRIVER_NAME         "paud"
+#define PAUDIO_DRIVER_NAME         "paud"
 /* Open the audio device for playback, and don't block if busy */
 /* #define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK) */
 #define OPEN_FLAGS	O_WRONLY
-/* Audio driver functions */
+/* Get the name of the audio device we use for output */
-static int Paud_OpenAudio(_THIS, SDL_AudioSpec * spec);
-static void Paud_WaitAudio(_THIS);
+#ifndef _PATH_DEV_DSP
-static void Paud_PlayAudio(_THIS);
+#define _PATH_DEV_DSP	"/dev/%caud%c/%c"
-static Uint8 *Paud_GetAudioBuf(_THIS);
+#endif
-static void Paud_CloseAudio(_THIS);
+static char devsettings[][3] = {
-/* Audio driver bootstrap functions */
+{'p', '0', '1'}, {'p', '0', '2'}, {'p', '0', '3'}, {'p', '0', '4'},
+{'p', '1', '1'}, {'p', '1', '2'}, {'p', '1', '3'}, {'p', '1', '4'},
+{'p', '2', '1'}, {'p', '2', '2'}, {'p', '2', '3'}, {'p', '2', '4'},
+{'p', '3', '1'}, {'p', '3', '2'}, {'p', '3', '3'}, {'p', '3', '4'},
+{'b', '0', '1'}, {'b', '0', '2'}, {'b', '0', '3'}, {'b', '0', '4'},
+{'b', '1', '1'}, {'b', '1', '2'}, {'b', '1', '3'}, {'b', '1', '4'},
+{'b', '2', '1'}, {'b', '2', '2'}, {'b', '2', '3'}, {'b', '2', '4'},
+{'b', '3', '1'}, {'b', '3', '2'}, {'b', '3', '3'}, {'b', '3', '4'},
+{'\0', '\0', '\0'}
+};
 static int
-Audio_Available(void)
+OpenUserDefinedDevice(char *path, int maxlen, int flags)
 {
+const char *audiodev;
 int fd;
-int available;
+/* Figure out what our audio device is */
-available = 0;
+if ((audiodev = SDL_getenv("SDL_PATH_DSP")) == NULL) {
-fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+audiodev = SDL_getenv("AUDIODEV");
-if (fd >= 0) {
+}
-available = 1;
+if (audiodev == NULL) {
-close(fd);
+return -1;
 }
-return (available);
+fd = open(audiodev, flags, 0);
-}
+if (path != NULL) {
+SDL_strlcpy(path, audiodev, maxlen);
-static void
+path[maxlen - 1] = '\0';
-Audio_DeleteDevice(SDL_AudioDevice * device)
+}
-{
+return fd;
-SDL_free(device->hidden);
+}
-SDL_free(device);
-}
+static int
+OpenAudioPath(char *path, int maxlen, int flags, int classic)
-static SDL_AudioDevice *
+{
-Audio_CreateDevice(int devindex)
+struct stat sb;
-{
+int cycle = 0;
-SDL_AudioDevice *this;
+int fd = OpenUserDefinedDevice(path, maxlen, flags);
-/* Initialize all variables that we clean on shutdown */
+if (fd != -1) {
-this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
+return fd;
-if (this) {
+}
-SDL_memset(this, 0, (sizeof *this));
-this->hidden = (struct SDL_PrivateAudioData *)
+/* !!! FIXME: do we really need a table here? */
-SDL_malloc((sizeof *this->hidden));
+while (devsettings[cycle][0] != '\0') {
-}
+char audiopath[1024];
-if ((this == NULL) || (this->hidden == NULL)) {
+SDL_snprintf(audiopath, SDL_arraysize(audiopath),
-SDL_OutOfMemory();
+_PATH_DEV_DSP,
-if (this) {
+devsettings[cycle][0],
-SDL_free(this);
+devsettings[cycle][1], devsettings[cycle][2]);
-}
-return (0);
+if (stat(audiopath, &sb) == 0) {
-}
+fd = open(audiopath, flags, 0);
-SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+if (fd > 0) {
-audio_fd = -1;
+if (path != NULL) {
+SDL_strlcpy(path, audiopath, maxlen);
-/* Set the function pointers */
+}
-this->OpenAudio = Paud_OpenAudio;
+return fd;
-this->WaitAudio = Paud_WaitAudio;
+}
-this->PlayAudio = Paud_PlayAudio;
+}
-this->GetAudioBuf = Paud_GetAudioBuf;
+}
-this->CloseAudio = Paud_CloseAudio;
+return -1;
+}
-this->free = Audio_DeleteDevice;
-return this;
-}
-AudioBootStrap Paud_bootstrap = {
-Paud_DRIVER_NAME, "AIX Paudio",
-Audio_Available, Audio_CreateDevice
-};
 /* This function waits until it is possible to write a full sound buffer */
 static void
-Paud_WaitAudio(_THIS)
+PAUDIO_WaitDevice(_THIS)
 {
 fd_set fdset;
 /* See if we need to use timed audio synchronization */
-if (frame_ticks) {
+if (this->hidden->frame_ticks) {
 /* Use timer for general audio synchronization */
 Sint32 ticks;
-ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+ticks = ((Sint32)(this->hidden->next_frame-SDL_GetTicks()))-FUDGE_TICKS;
 if (ticks > 0) {
 SDL_Delay(ticks);
 }
 } else {
 audio_buffer paud_bufinfo;
 /* Use select() for audio synchronization */
 struct timeval timeout;
 FD_ZERO(&fdset);
-FD_SET(audio_fd, &fdset);
+FD_SET(this->hidden->audio_fd, &fdset);
-if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+if (ioctl(this->hidden->audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Couldn't get audio buffer information\n");
 #endif
 timeout.tv_sec = 10;
 timeout.tv_usec = 0;
 }
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Waiting for audio to get ready\n");
 #endif
-if (select(audio_fd + 1, NULL, &fdset, NULL, &timeout) <= 0) {
+if (select(this->hidden->audio_fd+1,NULL,&fdset,NULL,&timeout) <= 0) {
 const char *message =
 "Audio timeout - buggy audio driver? (disabled)";
 /*
 * In general we should never print to the screen,
 * but in this case we have no other way of letting
 * the user know what happened.
 */
 fprintf(stderr, "SDL: %s - %s\n", strerror(errno), message);
 this->enabled = 0;
 /* Don't try to close - may hang */
-audio_fd = -1;
+this->hidden->audio_fd = -1;
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Done disabling audio\n");
 #endif
 }
 #ifdef DEBUG_AUDIO
 #endif
 }
 }
 static void
-Paud_PlayAudio(_THIS)
+PAUDIO_PlayDevice(_THIS)
 {
-int written;
+int written = 0;
+const Uint8 *mixbuf = this->hidden->mixbuf;
+const size_t mixlen = this->hidden->mixlen;
 /* Write the audio data, checking for EAGAIN on broken audio drivers */
 do {
-written = write(audio_fd, mixbuf, mixlen);
+written = write(this->hidden->audio_fd, mixbuf, mixlen);
 if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
 SDL_Delay(1);       /* Let a little CPU time go by */
 }
 }
 while ((written < 0) &&
 ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
 /* If timer synchronization is enabled, set the next write frame */
-if (frame_ticks) {
+if (this->hidden->frame_ticks) {
-next_frame += frame_ticks;
+this->hidden->next_frame += this->hidden->frame_ticks;
 }
 /* If we couldn't write, assume fatal error for now */
 if (written < 0) {
 this->enabled = 0;
 fprintf(stderr, "Wrote %d bytes of audio data\n", written);
 #endif
 }
 static Uint8 *
-Paud_GetAudioBuf(_THIS)
+PAUDIO_GetDeviceBuf(_THIS)
 {
-return mixbuf;
+return this->hidden->mixbuf;
 }
 static void
-Paud_CloseAudio(_THIS)
+PAUDIO_CloseDevice(_THIS)
 {
-if (mixbuf != NULL) {
+if (this->hidden != NULL) {
-SDL_FreeAudioMem(mixbuf);
+if (this->hidden->mixbuf != NULL) {
-mixbuf = NULL;
+SDL_FreeAudioMem(this->hidden->mixbuf);
-}
+this->hidden->mixbuf = NULL;
-if (audio_fd >= 0) {
+}
-close(audio_fd);
+if (this->hidden->audio_fd >= 0) {
-audio_fd = -1;
+close(this->hidden->audio_fd);
+this->hidden->audio_fd = -1;
+}
+SDL_free(this->hidden);
+this->hidden = NULL;
 }
 }
 static int
-Paud_OpenAudio(_THIS, SDL_AudioSpec * spec)
+PAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
 {
+const char *workaround = SDL_getenv("SDL_DSP_NOSELECT");
 char audiodev[1024];
+const char *err = NULL;
 int format;
 int bytes_per_sample;
 SDL_AudioFormat test_format;
 audio_init paud_init;
 audio_buffer paud_bufinfo;
 audio_status paud_status;
 audio_control paud_control;
 audio_change paud_change;
+int fd = -1;
-/* Reset the timer synchronization flag */
-frame_ticks = 0.0;
+/* Initialize all variables that we clean on shutdown */
+this->hidden = (struct SDL_PrivateAudioData *)
+SDL_malloc((sizeof *this->hidden));
+if (this->hidden == NULL) {
+SDL_OutOfMemory();
+return 0;
+}
+SDL_memset(this->hidden, 0, (sizeof *this->hidden));
 /* Open the audio device */
-audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+fd = OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
-if (audio_fd < 0) {
+this->hidden->audio_fd = fd;
+if (fd < 0) {
+PAUDIO_CloseDevice(this);
 SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
-return -1;
+return 0;
 }
 /*
 * We can't set the buffer size - just ask the device for the maximum
 * that we can have.
 */
-if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+if (ioctl(fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+PAUDIO_CloseDevice(this);
 SDL_SetError("Couldn't get audio buffer information");
-return -1;
+return 0;
 }
-mixbuf = NULL;
+if (this->spec.channels > 1)
+this->spec.channels = 2;
-if (spec->channels > 1)
-spec->channels = 2;
 else
-spec->channels = 1;
+this->spec.channels = 1;
 /*
 * Fields in the audio_init structure:
 *
 * Ignored by us:
 *                       * CONFLICT        - conflict with open's flags
 *                       * OVERLOADED      - out of DSP MIPS or memory
 * paud.position_resolution; * smallest increment for position
 */
-paud_init.srate = spec->freq;
+paud_init.srate = this->spec.freq;
 paud_init.mode = PCM;
 paud_init.operation = PLAY;
-paud_init.channels = spec->channels;
+paud_init.channels = this->spec.channels;
 /* Try for a closest match on audio format */
 format = 0;
-for (test_format = SDL_FirstAudioFormat(spec->format);
+for (test_format = SDL_FirstAudioFormat(this->spec.format);
 !format && test_format;) {
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
 switch (test_format) {
 }
 if (format == 0) {
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Couldn't find any hardware audio formats\n");
 #endif
+PAUDIO_CloseDevice(this);
 SDL_SetError("Couldn't find any hardware audio formats");
-return -1;
+return 0;
 }
-spec->format = test_format;
+this->spec.format = test_format;
 /*
 * We know the buffer size and the max number of subsequent writes
-* that can be pending. If more than one can pend, allow the application
+*  that can be pending. If more than one can pend, allow the application
-* to do something like double buffering between our write buffer and
+*  to do something like double buffering between our write buffer and
-* the device's own buffer that we are filling with write() anyway.
+*  the device's own buffer that we are filling with write() anyway.
 *
-* We calculate spec->samples like this because SDL_CalculateAudioSpec()
+* We calculate this->spec.samples like this because
-* will give put paud_bufinfo.write_buf_cap (or paud_bufinfo.write_buf_cap/2)
+*  SDL_CalculateAudioSpec() will give put paud_bufinfo.write_buf_cap
-* into spec->size in return.
+*  (or paud_bufinfo.write_buf_cap/2) into this->spec.size in return.
 */
 if (paud_bufinfo.request_buf_cap == 1) {
-spec->samples = paud_bufinfo.write_buf_cap
+this->spec.samples = paud_bufinfo.write_buf_cap
-/ bytes_per_sample / spec->channels;
+/ bytes_per_sample / this->spec.channels;
 } else {
-spec->samples = paud_bufinfo.write_buf_cap
+this->spec.samples = paud_bufinfo.write_buf_cap
-/ bytes_per_sample / spec->channels / 2;
+/ bytes_per_sample / this->spec.channels / 2;
 }
-paud_init.bsize = bytes_per_sample * spec->channels;
+paud_init.bsize = bytes_per_sample * this->spec.channels;
-SDL_CalculateAudioSpec(spec);
+SDL_CalculateAudioSpec(&this->spec);
 /*
 * The AIX paud device init can't modify the values of the audio_init
 * structure that we pass to it. So we don't need any recalculation
 * of this stuff and no reinit call as in linux dsp and dma code.
 *
 * /dev/paud supports all of the encoding formats, so we don't need
 * to do anything like reopening the device, either.
 */
-if (ioctl(audio_fd, AUDIO_INIT, &paud_init) < 0) {
+if (ioctl(fd, AUDIO_INIT, &paud_init) < 0) {
 switch (paud_init.rc) {
 case 1:
-SDL_SetError
+err = "Couldn't set audio format: DSP can't do play requests";
-("Couldn't set audio format: DSP can't do play requests");
-return -1;
 break;
 case 2:
-SDL_SetError
+err = "Couldn't set audio format: DSP can't do record requests";
-("Couldn't set audio format: DSP can't do record requests");
-return -1;
 break;
 case 4:
-SDL_SetError("Couldn't set audio format: request was invalid");
+err = "Couldn't set audio format: request was invalid";
-return -1;
 break;
 case 5:
-SDL_SetError
+err = "Couldn't set audio format: conflict with open's flags";
-("Couldn't set audio format: conflict with open's flags");
-return -1;
 break;
 case 6:
-SDL_SetError
+err = "Couldn't set audio format: out of DSP MIPS or memory";
-("Couldn't set audio format: out of DSP MIPS or memory");
-return -1;
 break;
 default:
-SDL_SetError
+err = "Couldn't set audio format: not documented in sys/audio.h";
-("Couldn't set audio format: not documented in sys/audio.h");
+break;
-return -1;
+}
-break;
+}
-}
+if (err != NULL) {
+PAUDIO_CloseDevice(this);
+SDL_SetError("Paudio: %s", err);
+return 0;
 }
 /* Allocate mixing buffer */
-mixlen = spec->size;
+this->hidden->mixlen = this->spec.size;
-mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
+this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
-if (mixbuf == NULL) {
+if (this->hidden->mixbuf == NULL) {
-return -1;
+PAUDIO_CloseDevice(this);
-}
+SDL_OutOfMemory();
-SDL_memset(mixbuf, spec->silence, spec->size);
+return 0;
+}
+SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
 /*
 * Set some paramters: full volume, first speaker that we can find.
 * Ignore the other settings for now.
 */
 paud_change.bass = AUDIO_IGNORE;    /* the new bass state */
 paud_change.pitch = AUDIO_IGNORE;   /* the new pitch state */
 paud_control.ioctl_request = AUDIO_CHANGE;
 paud_control.request_info = (char *) &paud_change;
-if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
+if (ioctl(fd, AUDIO_CONTROL, &paud_control) < 0) {
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Can't change audio display settings\n");
 #endif
 }
 * Tell the device to expect data. Actual start will wait for
 * the first write() call.
 */
 paud_control.ioctl_request = AUDIO_START;
 paud_control.position = 0;
-if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
+if (ioctl(fd, AUDIO_CONTROL, &paud_control) < 0) {
+PAUDIO_CloseDevice(this);
 #ifdef DEBUG_AUDIO
 fprintf(stderr, "Can't start audio play\n");
 #endif
 SDL_SetError("Can't start audio play");
-return -1;
+return 0;
 }
 /* Check to see if we need to use select() workaround */
-{
+if (workaround != NULL) {
-char *workaround;
+this->hidden->frame_ticks = (float) (this->spec.samples * 1000) /
-workaround = SDL_getenv("SDL_DSP_NOSELECT");
+this->spec.freq;
-if (workaround) {
+this->hidden->next_frame = SDL_GetTicks() + this->hidden->frame_ticks;
-frame_ticks = (float) (spec->samples * 1000) / spec->freq;
+}
-next_frame = SDL_GetTicks() + frame_ticks;
-}
-}
-/* Get the parent process id (we're the parent of the audio thread) */
-parent = getpid();
 /* We're ready to rock and roll. :-) */
-return 0;
+return 1;
 }
+static int
+PAUDIO_Init(SDL_AudioDriverImpl *impl)
+{
+int fd = OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+if (fd < 0) {
+SDL_SetError("PAUDIO: Couldn't open audio device");
+return 0;
+}
+close(fd);
+/* Set the function pointers */
+impl->OpenDevice = DSP_OpenDevice;
+impl->PlayDevice = DSP_PlayDevice;
+impl->PlayDevice = DSP_WaitDevice;
+impl->GetDeviceBuf = DSP_GetDeviceBuf;
+impl->CloseDevice = DSP_CloseDevice;
+impl->OnlyHasDefaultOutputDevice = 1;  /* !!! FIXME: add device enum! */
+return 1;
+}
+AudioBootStrap PAUDIO_bootstrap = {
+PAUDIO_DRIVER_NAME, "AIX Paudio", PAUDIO_Init, 0
+};
 /* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/audio/paudio/SDL_paudio.c @ 2049:5f6550e5184f