static void ALSA_PlayDevice(_THIS) { const Uint8 *sample_buf = (const Uint8 *) this->hidden->mixbuf; const int frame_size = (((int) SDL_AUDIO_BITSIZE(this->spec.format)) / 8) * this->spec.channels; snd_pcm_uframes_t frames_left = ((snd_pcm_uframes_t) this->spec.samples); swizzle_alsa_channels(this, this->hidden->mixbuf, frames_left); while ( frames_left > 0 && SDL_AtomicGet(&this->enabled) ) { int status; /* This wait is a work-around for a hang when USB devices are unplugged. Normally it should not result in any waiting, but in the case of a USB unplug, it serves as a way to join the playback thread after the timeout occurs */ status = ALSA_snd_pcm_wait(this->hidden->pcm_handle, 1000); if (status == 0) { /*fprintf(stderr, "ALSA timeout waiting for available buffer space\n");*/ SDL_OpenedAudioDeviceDisconnected(this); return; } status = ALSA_snd_pcm_writei(this->hidden->pcm_handle, sample_buf, frames_left); if (status < 0) { if (status == -EAGAIN) { /* Apparently snd_pcm_recover() doesn't handle this case - does it assume snd_pcm_wait() above? */ SDL_Delay(1); continue; } status = ALSA_snd_pcm_recover(this->hidden->pcm_handle, status, 0); if (status < 0) { /* Hmm, not much we can do - abort */ fprintf(stderr, "ALSA write failed (unrecoverable): %s\n", ALSA_snd_strerror(status)); SDL_OpenedAudioDeviceDisconnected(this); return; } continue; } sample_buf += status * frame_size; frames_left -= status; } }
static OSStatus device_unplugged(AudioObjectID devid, UInt32 num_addr, const AudioObjectPropertyAddress *addrs, void *data) { SDL_AudioDevice *this = (SDL_AudioDevice *) data; SDL_bool dead = SDL_FALSE; UInt32 isAlive = 1; UInt32 size = sizeof (isAlive); OSStatus error; if (!this->enabled) { return 0; /* already known to be dead. */ } error = AudioObjectGetPropertyData(this->hidden->deviceID, &alive_address, 0, NULL, &size, &isAlive); if (error == kAudioHardwareBadDeviceError) { dead = SDL_TRUE; /* device was unplugged. */ } else if ((error == kAudioHardwareNoError) && (!isAlive)) { dead = SDL_TRUE; /* device died in some other way. */ } if (dead) { SDL_OpenedAudioDeviceDisconnected(this); } return 0; }
/* This function waits until it is possible to write a full sound buffer */ static void ESD_WaitDevice(_THIS) { Sint32 ticks; /* Check to see if the thread-parent process is still alive */ { static int cnt = 0; /* Note that this only works with thread implementations that use a different process id for each thread. */ /* Check every 10 loops */ if (this->hidden->parent && (((++cnt) % 10) == 0)) { if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) { SDL_OpenedAudioDeviceDisconnected(this); } } } /* Use timer for general audio synchronization */ ticks = ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS; if (ticks > 0) { SDL_Delay(ticks); } }
static void PAUDIO_PlayDevice(_THIS) { 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(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 (this->hidden->frame_ticks) { this->hidden->next_frame += this->hidden->frame_ticks; } /* If we couldn't write, assume fatal error for now */ if (written < 0) { SDL_OpenedAudioDeviceDisconnected(this); } #ifdef DEBUG_AUDIO fprintf(stderr, "Wrote %d bytes of audio data\n", written); #endif }
static void PULSEAUDIO_PlayDevice(_THIS) { /* Write the audio data */ struct SDL_PrivateAudioData *h = this->hidden; if (SDL_AtomicGet(&this->enabled)) { if (PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf, h->mixlen, NULL, 0LL, PA_SEEK_RELATIVE) < 0) { SDL_OpenedAudioDeviceDisconnected(this); } } }
static void DSP_PlayDevice(_THIS) { struct SDL_PrivateAudioData *h = this->hidden; if (write(h->audio_fd, h->mixbuf, h->mixlen) == -1) { perror("Audio write"); SDL_OpenedAudioDeviceDisconnected(this); } #ifdef DEBUG_AUDIO fprintf(stderr, "Wrote %d bytes of audio data\n", h->mixlen); #endif }
static void SNDIO_PlayDevice(_THIS) { const int written = SNDIO_sio_write(this->hidden->dev, this->hidden->mixbuf, this->hidden->mixlen); /* If we couldn't write, assume fatal error for now */ if ( written == 0 ) { SDL_OpenedAudioDeviceDisconnected(this); } #ifdef DEBUG_AUDIO fprintf(stderr, "Wrote %d bytes of audio data\n", written); #endif }
static void SDL_FS_PlayDevice(_THIS) { DirectResult ret; ret = this->hidden->stream->Write(this->hidden->stream, this->hidden->mixbuf, this->hidden->mixsamples); /* If we couldn't write, assume fatal error for now */ if (ret) { SDL_OpenedAudioDeviceDisconnected(this); } #ifdef DEBUG_AUDIO fprintf(stderr, "Wrote %d bytes of audio data\n", this->hidden->mixlen); #endif }
/* This function waits until it is possible to write a full sound buffer */ static void BSDAUDIO_WaitDevice(_THIS) { #ifndef USE_BLOCKING_WRITES /* Not necessary when using blocking writes */ /* See if we need to use timed audio synchronization */ if (this->hidden->frame_ticks) { /* Use timer for general audio synchronization */ Sint32 ticks; ticks = ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS; if (ticks > 0) { SDL_Delay(ticks); } } else { /* Use select() for audio synchronization */ fd_set fdset; struct timeval timeout; FD_ZERO(&fdset); FD_SET(this->hidden->audio_fd, &fdset); timeout.tv_sec = 10; timeout.tv_usec = 0; #ifdef DEBUG_AUDIO fprintf(stderr, "Waiting for audio to get ready\n"); #endif 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\n", message); SDL_OpenedAudioDeviceDisconnected(this); /* Don't try to close - may hang */ this->hidden->audio_fd = -1; #ifdef DEBUG_AUDIO fprintf(stderr, "Done disabling audio\n"); #endif } #ifdef DEBUG_AUDIO fprintf(stderr, "Ready!\n"); #endif } #endif /* !USE_BLOCKING_WRITES */ }
static int PULSEAUDIO_CaptureFromDevice(_THIS, void *buffer, int buflen) { struct SDL_PrivateAudioData *h = this->hidden; const void *data = NULL; size_t nbytes = 0; while (SDL_AtomicGet(&this->enabled)) { if (h->capturebuf != NULL) { const int cpy = SDL_min(buflen, h->capturelen); SDL_memcpy(buffer, h->capturebuf, cpy); /*printf("PULSEAUDIO: fed %d captured bytes\n", cpy);*/ h->capturebuf += cpy; h->capturelen -= cpy; if (h->capturelen == 0) { h->capturebuf = NULL; PULSEAUDIO_pa_stream_drop(h->stream); /* done with this fragment. */ } return cpy; /* new data, return it. */ } if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY || PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY || PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) { SDL_OpenedAudioDeviceDisconnected(this); return -1; /* uhoh, pulse failed! */ } if (PULSEAUDIO_pa_stream_readable_size(h->stream) == 0) { continue; /* no data available yet. */ } /* a new fragment is available! */ PULSEAUDIO_pa_stream_peek(h->stream, &data, &nbytes); SDL_assert(nbytes > 0); if (data == NULL) { /* NULL==buffer had a hole. Ignore that. */ PULSEAUDIO_pa_stream_drop(h->stream); /* drop this fragment. */ } else { /* store this fragment's data, start feeding it to SDL. */ /*printf("PULSEAUDIO: captured %d new bytes\n", (int) nbytes);*/ h->capturebuf = (const Uint8 *) data; h->capturelen = nbytes; } } return -1; /* not enabled? */ }
/* This function waits until it is possible to write a full sound buffer */ static void PULSEAUDIO_WaitDevice(_THIS) { struct SDL_PrivateAudioData *h = this->hidden; while (SDL_AtomicGet(&this->enabled)) { if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY || PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY || PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) { SDL_OpenedAudioDeviceDisconnected(this); return; } if (PULSEAUDIO_pa_stream_writable_size(h->stream) >= h->mixlen) { return; } } }
static void ALSA_PlayDevice(_THIS) { int status; const Uint8 *sample_buf = (const Uint8 *) this->hidden->mixbuf; const int frame_size = (((int) (this->spec.format & 0xFF)) / 8) * this->spec.channels; snd_pcm_uframes_t frames_left = ((snd_pcm_uframes_t) this->spec.samples); swizzle_alsa_channels(this); while ( frames_left > 0 && this->enabled ) { /* !!! FIXME: This works, but needs more testing before going live */ /* ALSA_snd_pcm_wait(this->hidden->pcm_handle, -1); */ status = ALSA_snd_pcm_writei(this->hidden->pcm_handle, sample_buf, frames_left); if (status < 0) { if (status == -EAGAIN) { /* Apparently snd_pcm_recover() doesn't handle this case - does it assume snd_pcm_wait() above? */ SDL_Delay(1); continue; } status = ALSA_snd_pcm_recover(this->hidden->pcm_handle, status, 0); if (status < 0) { /* Hmm, not much we can do - abort */ fprintf(stderr, "ALSA write failed (unrecoverable): %s\n", ALSA_snd_strerror(status)); SDL_OpenedAudioDeviceDisconnected(this); return; } continue; } sample_buf += status * frame_size; frames_left -= status; } }
static void NETBSDAUDIO_PlayDevice(_THIS) { int written, p = 0; /* Write the audio data, checking for EAGAIN on broken audio drivers */ do { written = write(this->hidden->audio_fd, &this->hidden->mixbuf[p], this->hidden->mixlen - p); if (written > 0) p += written; if (written == -1 && errno != 0 && errno != EAGAIN && errno != EINTR) { /* Non recoverable error has occurred. It should be reported!!! */ perror("audio"); break; } #ifdef DEBUG_AUDIO fprintf(stderr, "Wrote %d bytes of audio data\n", written); #endif if (p < this->hidden->mixlen || ((written < 0) && ((errno == 0) || (errno == EAGAIN)))) { SDL_Delay(1); /* Let a little CPU time go by */ } } while (p < this->hidden->mixlen); /* If timer synchronization is enabled, set the next write frame */ if (this->hidden->frame_ticks) { this->hidden->next_frame += this->hidden->frame_ticks; } /* If we couldn't write, assume fatal error for now */ if (written < 0) { SDL_OpenedAudioDeviceDisconnected(this); } }
static void ESD_PlayDevice(_THIS) { int written = 0; /* Write the audio data, checking for EAGAIN on broken audio drivers */ do { written = write(this->hidden->audio_fd, this->hidden->mixbuf, this->hidden->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))); /* Set the next write frame */ this->hidden->next_frame += this->hidden->frame_ticks; /* If we couldn't write, assume fatal error for now */ if (written < 0) { SDL_OpenedAudioDeviceDisconnected(this); } }
static void XAUDIO2_PlayDevice(_THIS) { XAUDIO2_BUFFER buffer; Uint8 *mixbuf = this->hidden->mixbuf; Uint8 *nextbuf = this->hidden->nextbuf; const int mixlen = this->hidden->mixlen; IXAudio2SourceVoice *source = this->hidden->source; HRESULT result = S_OK; if (!this->enabled) { /* shutting down? */ return; } /* Submit the next filled buffer */ SDL_zero(buffer); buffer.AudioBytes = mixlen; buffer.pAudioData = nextbuf; buffer.pContext = this; if (nextbuf == mixbuf) { nextbuf += mixlen; } else { nextbuf = mixbuf; } this->hidden->nextbuf = nextbuf; result = IXAudio2SourceVoice_SubmitSourceBuffer(source, &buffer, NULL); if (result == XAUDIO2_E_DEVICE_INVALIDATED) { /* !!! FIXME: possibly disconnected or temporary lost. Recover? */ } if (result != S_OK) { /* uhoh, panic! */ IXAudio2SourceVoice_FlushSourceBuffers(source); SDL_OpenedAudioDeviceDisconnected(this); } }
static void STDMETHODCALLTYPE VoiceCBOnVoiceError(THIS_ void *data, HRESULT Error) { SDL_AudioDevice *this = (SDL_AudioDevice *) data; SDL_OpenedAudioDeviceDisconnected(this); }
/* This function waits until it is possible to write a full sound buffer */ static void PAUDIO_WaitDevice(_THIS) { fd_set fdset; /* See if we need to use timed audio synchronization */ if (this->hidden->frame_ticks) { /* Use timer for general audio synchronization */ Sint32 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(this->hidden->audio_fd, &fdset); 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; } else { long ms_in_buf = paud_bufinfo.write_buf_time; timeout.tv_sec = ms_in_buf / 1000; ms_in_buf = ms_in_buf - timeout.tv_sec * 1000; timeout.tv_usec = ms_in_buf * 1000; #ifdef DEBUG_AUDIO fprintf(stderr, "Waiting for write_buf_time=%ld,%ld\n", timeout.tv_sec, timeout.tv_usec); #endif } #ifdef DEBUG_AUDIO fprintf(stderr, "Waiting for audio to get ready\n"); #endif 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); SDL_OpenedAudioDeviceDisconnected(this); /* Don't try to close - may hang */ this->hidden->audio_fd = -1; #ifdef DEBUG_AUDIO fprintf(stderr, "Done disabling audio\n"); #endif } #ifdef DEBUG_AUDIO fprintf(stderr, "Ready!\n"); #endif } }
static void QSA_PlayDevice(_THIS) { snd_pcm_channel_status_t cstatus; int written; int status; int towrite; void *pcmbuffer; if ((!this->enabled) || (!this->hidden)) { return; } towrite = this->spec.size; pcmbuffer = this->hidden->pcm_buf; /* Write the audio data, checking for EAGAIN (buffer full) and underrun */ do { written = snd_pcm_plugin_write(this->hidden->audio_handle, pcmbuffer, towrite); if (written != towrite) { /* Check if samples playback got stuck somewhere in hardware or in */ /* the audio device driver */ if ((errno == EAGAIN) && (written == 0)) { if (this->hidden->timeout_on_wait != 0) { SDL_SetError("QSA: buffer playback timeout"); return; } } /* Check for errors or conditions */ if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* Let a little CPU time go by and try to write again */ SDL_Delay(1); /* if we wrote some data */ towrite -= written; pcmbuffer += written * this->spec.channels; continue; } else { if ((errno == EINVAL) || (errno == EIO)) { SDL_memset(&cstatus, 0, sizeof(cstatus)); if (!this->hidden->iscapture) { cstatus.channel = SND_PCM_CHANNEL_PLAYBACK; } else { cstatus.channel = SND_PCM_CHANNEL_CAPTURE; } status = snd_pcm_plugin_status(this->hidden->audio_handle, &cstatus); if (status < 0) { QSA_SetError("snd_pcm_plugin_status", status); return; } if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) || (cstatus.status == SND_PCM_STATUS_READY)) { if (!this->hidden->iscapture) { status = snd_pcm_plugin_prepare(this->hidden-> audio_handle, SND_PCM_CHANNEL_PLAYBACK); } else { status = snd_pcm_plugin_prepare(this->hidden-> audio_handle, SND_PCM_CHANNEL_CAPTURE); } if (status < 0) { QSA_SetError("snd_pcm_plugin_prepare", status); return; } } continue; } else { return; } } } else { /* we wrote all remaining data */ towrite -= written; pcmbuffer += written * this->spec.channels; } } while ((towrite > 0) && (this->enabled)); /* If we couldn't write, assume fatal error for now */ if (towrite != 0) { SDL_OpenedAudioDeviceDisconnected(this); } }
static void SUNAUDIO_PlayDevice(_THIS) { /* Write the audio data */ if (this->hidden->ulaw_only) { /* Assuming that this->spec.freq >= 8000 Hz */ int accum, incr, pos; Uint8 *aubuf; accum = 0; incr = this->spec.freq / 8; aubuf = this->hidden->ulaw_buf; switch (this->hidden->audio_fmt & 0xFF) { case 8: { Uint8 *sndbuf; sndbuf = this->hidden->mixbuf; for (pos = 0; pos < this->hidden->fragsize; ++pos) { *aubuf = snd2au((0x80 - *sndbuf) * 64); accum += incr; while (accum > 0) { accum -= 1000; sndbuf += 1; } aubuf += 1; } } break; case 16: { Sint16 *sndbuf; sndbuf = (Sint16 *) this->hidden->mixbuf; for (pos = 0; pos < this->hidden->fragsize; ++pos) { *aubuf = snd2au(*sndbuf / 4); accum += incr; while (accum > 0) { accum -= 1000; sndbuf += 1; } aubuf += 1; } } break; } #ifdef DEBUG_AUDIO CheckUnderflow(this); #endif if (write(this->hidden->audio_fd, this->hidden->ulaw_buf, this->hidden->fragsize) < 0) { /* Assume fatal error, for now */ SDL_OpenedAudioDeviceDisconnected(this); } this->hidden->written += this->hidden->fragsize; } else { #ifdef DEBUG_AUDIO CheckUnderflow(this); #endif if (write(this->hidden->audio_fd, this->hidden->mixbuf, this->spec.size) < 0) { /* Assume fatal error, for now */ SDL_OpenedAudioDeviceDisconnected(this); } this->hidden->written += this->hidden->fragsize; } }