From cfc8a0d17d4191f690764341b02026a92908a221 Mon Sep 17 00:00:00 2001 From: "Ryan C. Gordon" Date: Wed, 28 Jun 2023 10:13:34 -0400 Subject: [PATCH] pipewire: First shot at moving to the new SDL3 audio interfaces. This needs a little work still, but it mostly works. --- CMakeLists.txt | 1 - src/audio/SDL_audio.c | 21 ++- src/audio/SDL_sysaudio.h | 1 + src/audio/pipewire/SDL_pipewire.c | 291 +++++++++++++----------------- src/audio/pipewire/SDL_pipewire.h | 5 +- 5 files changed, 142 insertions(+), 177 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index de86f90c1..56646f9b7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -356,7 +356,6 @@ set(SDL_VENDOR_INFO "" CACHE STRING "Vendor name and/or version to add to SDL_RE set(SDL_OSS OFF) set(SDL_ALSA OFF) set(SDL_JACK OFF) -set(SDL_PIPEWIRE OFF) set(SDL_SNDIO OFF) cmake_dependent_option(SDL_SHARED "Build a shared version of the library" ${SDL_SHARED_DEFAULT} ${SDL_SHARED_AVAILABLE} OFF) diff --git a/src/audio/SDL_audio.c b/src/audio/SDL_audio.c index e5faeafce..2baa2660b 100644 --- a/src/audio/SDL_audio.c +++ b/src/audio/SDL_audio.c @@ -634,7 +634,16 @@ void SDL_QuitAudio(void) } - +void SDL_AudioThreadFinalize(SDL_AudioDevice *device) +{ + if (SDL_AtomicGet(&device->condemned)) { + if (device->thread) { + SDL_DetachThread(device->thread); // no one is waiting for us, just detach ourselves. + device->thread = NULL; + } + DestroyPhysicalAudioDevice(device); + } +} // Output device thread. This is split into chunks, so backends that need to control this directly can use the pieces they need without duplicating effort. @@ -719,11 +728,7 @@ void SDL_OutputAudioThreadShutdown(SDL_AudioDevice *device) // Wait for the audio to drain. !!! FIXME: don't bother waiting if device is lost. SDL_Delay(((samples * 1000) / device->spec.freq) * 2); current_audio.impl.ThreadDeinit(device); - if (SDL_AtomicGet(&device->condemned)) { - SDL_DetachThread(device->thread); // no one is waiting for us, just detach ourselves. - device->thread = NULL; - DestroyPhysicalAudioDevice(device); - } + SDL_AudioThreadFinalize(device); } static int SDLCALL OutputAudioThread(void *devicep) // thread entry point @@ -810,9 +815,7 @@ void SDL_CaptureAudioThreadShutdown(SDL_AudioDevice *device) SDL_assert(device->iscapture); current_audio.impl.FlushCapture(device); current_audio.impl.ThreadDeinit(device); - if (SDL_AtomicGet(&device->condemned)) { - DestroyPhysicalAudioDevice(device); - } + SDL_AudioThreadFinalize(device); } static int SDLCALL CaptureAudioThread(void *devicep) // thread entry point diff --git a/src/audio/SDL_sysaudio.h b/src/audio/SDL_sysaudio.h index c318f55ab..a72780549 100644 --- a/src/audio/SDL_sysaudio.h +++ b/src/audio/SDL_sysaudio.h @@ -99,6 +99,7 @@ extern void SDL_OutputAudioThreadShutdown(SDL_AudioDevice *device); extern void SDL_CaptureAudioThreadSetup(SDL_AudioDevice *device); extern SDL_bool SDL_CaptureAudioThreadIterate(SDL_AudioDevice *device); extern void SDL_CaptureAudioThreadShutdown(SDL_AudioDevice *device); +extern void SDL_AudioThreadFinalize(SDL_AudioDevice *device); typedef struct SDL_AudioDriverImpl { diff --git a/src/audio/pipewire/SDL_pipewire.c b/src/audio/pipewire/SDL_pipewire.c index 1d1b15625..5309e2131 100644 --- a/src/audio/pipewire/SDL_pipewire.c +++ b/src/audio/pipewire/SDL_pipewire.c @@ -327,7 +327,11 @@ static void io_list_remove(Uint32 id) spa_list_remove(&n->link); if (hotplug_events_enabled) { - SDL_RemoveAudioDevice(n->is_capture, PW_ID_TO_HANDLE(id)); + SDL_AudioDevice *device = SDL_ObtainPhysicalAudioDeviceByHandle(PW_ID_TO_HANDLE(id)); + if (device) { + SDL_UnlockMutex(device->lock); // AudioDeviceDisconnected will relock and verify it's still in the list, but in case this is destroyed, unlock now. + SDL_AudioDeviceDisconnected(device); + } } SDL_free(n); @@ -383,6 +387,7 @@ static struct io_node *io_list_get_by_id(Uint32 id) return NULL; } +#if 0 static struct io_node *io_list_get_by_path(char *path) { struct io_node *n, *temp; @@ -393,6 +398,7 @@ static struct io_node *io_list_get_by_path(char *path) } return NULL; } +#endif static void node_object_destroy(struct node_object *node) { @@ -833,7 +839,7 @@ static void hotplug_loop_destroy(void) } } -static void PIPEWIRE_DetectDevices(void) +static void PIPEWIRE_DetectDevices(SDL_AudioDevice **default_output, SDL_AudioDevice **default_capture) { struct io_node *io; @@ -848,7 +854,10 @@ static void PIPEWIRE_DetectDevices(void) io_list_sort(); spa_list_for_each (io, &hotplug_io_list, link) { - SDL_AddAudioDevice(io->is_capture, io->name, &io->spec, PW_ID_TO_HANDLE(io->id)); + SDL_AudioDevice *device = SDL_AddAudioDevice(io->is_capture, io->name, &io->spec, PW_ID_TO_HANDLE(io->id)); +// !!! FIXME: obviously no +if (!io->is_capture && !*default_output) { *default_output = device; } +if (io->is_capture && !*default_capture) { *default_capture = device; } } hotplug_events_enabled = SDL_TRUE; @@ -936,167 +945,115 @@ static void initialize_spa_info(const SDL_AudioSpec *spec, struct spa_audio_info } } -static void output_callback(void *data) +static Uint8 *PIPEWIRE_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size) { - struct pw_buffer *pw_buf; - struct spa_buffer *spa_buf; - Uint8 *dst; + // See if a buffer is available. If this returns NULL, SDL_OutputAudioThreadIterate will return SDL_FALSE, but since we own the thread, it won't kill playback. + // !!! FIXME: It's not clear to me if this ever returns NULL or if this was just defensive coding. - SDL_AudioDevice *_this = (SDL_AudioDevice *)data; - struct pw_stream *stream = _this->hidden->stream; - - /* Shutting down, don't do anything */ - if (SDL_AtomicGet(&_this->shutdown)) { - return; - } - - /* See if a buffer is available */ - pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream); + struct pw_stream *stream = device->hidden->stream; + struct pw_buffer *pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream); if (pw_buf == NULL) { - return; + return NULL; } - spa_buf = pw_buf->buffer; - + struct spa_buffer *spa_buf = pw_buf->buffer; if (spa_buf->datas[0].data == NULL) { - return; + PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + return NULL; } - /* - * If the device is disabled, write silence to the stream buffer - * and run the callback with the work buffer to keep the callback - * firing regularly in case the audio is being used as a timer. - */ - SDL_LockMutex(_this->mixer_lock); - if (!SDL_AtomicGet(&_this->paused)) { - if (SDL_AtomicGet(&_this->enabled)) { - dst = spa_buf->datas[0].data; - } else { - dst = _this->work_buffer; - SDL_memset(spa_buf->datas[0].data, _this->spec.silence, _this->spec.size); - } - - if (!_this->stream) { - _this->callbackspec.callback(_this->callbackspec.userdata, dst, _this->callbackspec.size); - } else { - int got; - - /* Fire the callback until we have enough to fill a buffer */ - while (SDL_GetAudioStreamAvailable(_this->stream) < _this->spec.size) { - _this->callbackspec.callback(_this->callbackspec.userdata, _this->work_buffer, _this->callbackspec.size); - SDL_PutAudioStreamData(_this->stream, _this->work_buffer, _this->callbackspec.size); - } - - got = SDL_GetAudioStreamData(_this->stream, dst, _this->spec.size); - SDL_assert(got == _this->spec.size); - } - } else { - SDL_memset(spa_buf->datas[0].data, _this->spec.silence, _this->spec.size); - } - SDL_UnlockMutex(_this->mixer_lock); + device->hidden->pw_buf = pw_buf; + return (Uint8 *) spa_buf->datas[0].data; +} +static void PIPEWIRE_PlayDevice(SDL_AudioDevice *device, int buffer_size) +{ + struct pw_stream *stream = device->hidden->stream; + struct pw_buffer *pw_buf = device->hidden->pw_buf; + struct spa_buffer *spa_buf = pw_buf->buffer; spa_buf->datas[0].chunk->offset = 0; - spa_buf->datas[0].chunk->stride = _this->hidden->stride; - spa_buf->datas[0].chunk->size = _this->spec.size; + spa_buf->datas[0].chunk->stride = device->hidden->stride; + spa_buf->datas[0].chunk->size = buffer_size; PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + device->hidden->pw_buf = NULL; +} + +static void output_callback(void *data) +{ + SDL_OutputAudioThreadIterate((SDL_AudioDevice *)data); +} + +static void PIPEWIRE_FlushCapture(SDL_AudioDevice *device) +{ + struct pw_stream *stream = device->hidden->stream; + struct pw_buffer *pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream); + if (pw_buf != NULL) { // just requeue it without any further thought. + PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + } +} + +static int PIPEWIRE_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, int buflen) +{ + struct pw_stream *stream = device->hidden->stream; + struct pw_buffer *pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream); + if (!pw_buf) { + return 0; + } + + struct spa_buffer *spa_buf = pw_buf->buffer; + if (!spa_buf) { + PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + return 0; + } + + const Uint8 *src = (const Uint8 *)spa_buf->datas[0].data; + const Uint32 offset = SPA_MIN(spa_buf->datas[0].chunk->offset, spa_buf->datas[0].maxsize); + const Uint32 size = SPA_MIN(spa_buf->datas[0].chunk->size, spa_buf->datas[0].maxsize - offset); + const int cpy = SDL_min(buflen, (int) size); + + SDL_assert(size <= buflen); // We'll have to reengineer some stuff if this turns out to not be true. + + SDL_memcpy(buffer, src + offset, cpy); + PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + + return cpy; } static void input_callback(void *data) { - struct pw_buffer *pw_buf; - struct spa_buffer *spa_buf; - Uint8 *src; - SDL_AudioDevice *_this = (SDL_AudioDevice *)data; - struct pw_stream *stream = _this->hidden->stream; - - /* Shutting down, don't do anything */ - if (SDL_AtomicGet(&_this->shutdown)) { - return; - } - - pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream); - if (pw_buf == NULL) { - return; - } - - spa_buf = pw_buf->buffer; - (src = (Uint8 *)spa_buf->datas[0].data); - if (src == NULL) { - return; - } - - if (!SDL_AtomicGet(&_this->paused)) { - /* Calculate the offset and data size */ - const Uint32 offset = SPA_MIN(spa_buf->datas[0].chunk->offset, spa_buf->datas[0].maxsize); - const Uint32 size = SPA_MIN(spa_buf->datas[0].chunk->size, spa_buf->datas[0].maxsize - offset); - - src += offset; - - /* Fill the buffer with silence if the stream is disabled. */ - if (!SDL_AtomicGet(&_this->enabled)) { - SDL_memset(src, _this->callbackspec.silence, size); - } - - /* Pipewire can vary the latency, so buffer all incoming data */ - SDL_WriteToDataQueue(_this->hidden->buffer, src, size); - - while (SDL_GetDataQueueSize(_this->hidden->buffer) >= _this->callbackspec.size) { - SDL_ReadFromDataQueue(_this->hidden->buffer, _this->work_buffer, _this->callbackspec.size); - - SDL_LockMutex(_this->mixer_lock); - _this->callbackspec.callback(_this->callbackspec.userdata, _this->work_buffer, _this->callbackspec.size); - SDL_UnlockMutex(_this->mixer_lock); - } - } else if (_this->hidden->buffer) { /* Flush the buffer when paused */ - if (SDL_GetDataQueueSize(_this->hidden->buffer) != 0) { - SDL_ClearDataQueue(_this->hidden->buffer, _this->hidden->input_buffer_packet_size); - } - } - - PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf); + SDL_CaptureAudioThreadIterate((SDL_AudioDevice *)data); } static void stream_add_buffer_callback(void *data, struct pw_buffer *buffer) { - SDL_AudioDevice *_this = data; + SDL_AudioDevice *device = (SDL_AudioDevice *) data; - if (_this->iscapture == SDL_FALSE) { - /* - * Clamp the output spec samples and size to the max size of the Pipewire buffer. - * If they exceed the maximum size of the Pipewire buffer, double buffering will be used. - */ - if (_this->spec.size > buffer->buffer->datas[0].maxsize) { - _this->spec.samples = buffer->buffer->datas[0].maxsize / _this->hidden->stride; - _this->spec.size = buffer->buffer->datas[0].maxsize; + if (device->iscapture == SDL_FALSE) { + /* Clamp the output spec samples and size to the max size of the Pipewire buffer. + If they exceed the maximum size of the Pipewire buffer, double buffering will be used. */ + if (device->buffer_size > buffer->buffer->datas[0].maxsize) { + SDL_LockMutex(device->lock); + device->sample_frames = buffer->buffer->datas[0].maxsize / device->hidden->stride; + device->buffer_size = buffer->buffer->datas[0].maxsize; + SDL_UnlockMutex(device->lock); } - } else if (_this->hidden->buffer == NULL) { - /* - * The latency of source nodes can change, so buffering is always required. - * - * Ensure that the intermediate input buffer is large enough to hold the requested - * application packet size or a full buffer of data from Pipewire, whichever is larger. - * - * A packet size of 2 periods should be more than is ever needed. - */ - _this->hidden->input_buffer_packet_size = SPA_MAX(_this->spec.size, buffer->buffer->datas[0].maxsize) * 2; - _this->hidden->buffer = SDL_CreateDataQueue(_this->hidden->input_buffer_packet_size, _this->hidden->input_buffer_packet_size); } - _this->hidden->stream_init_status |= PW_READY_FLAG_BUFFER_ADDED; - PIPEWIRE_pw_thread_loop_signal(_this->hidden->loop, false); + device->hidden->stream_init_status |= PW_READY_FLAG_BUFFER_ADDED; + PIPEWIRE_pw_thread_loop_signal(device->hidden->loop, false); } static void stream_state_changed_callback(void *data, enum pw_stream_state old, enum pw_stream_state state, const char *error) { - SDL_AudioDevice *_this = data; + SDL_AudioDevice *device = (SDL_AudioDevice *) data; if (state == PW_STREAM_STATE_STREAMING) { - _this->hidden->stream_init_status |= PW_READY_FLAG_STREAM_READY; + device->hidden->stream_init_status |= PW_READY_FLAG_STREAM_READY; } if (state == PW_STREAM_STATE_STREAMING || state == PW_STREAM_STATE_ERROR) { - PIPEWIRE_pw_thread_loop_signal(_this->hidden->loop, false); + PIPEWIRE_pw_thread_loop_signal(device->hidden->loop, false); } } @@ -1109,7 +1066,7 @@ static const struct pw_stream_events stream_input_events = { PW_VERSION_STREAM_E .add_buffer = stream_add_buffer_callback, .process = input_callback }; -static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) +static int PIPEWIRE_OpenDevice(SDL_AudioDevice *device) { /* * NOTE: The PW_STREAM_FLAG_RT_PROCESS flag can be set to call the stream @@ -1128,12 +1085,12 @@ static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) struct SDL_PrivateAudioData *priv; struct pw_properties *props; const char *app_name, *app_id, *stream_name, *stream_role, *error; - Uint32 node_id = _this->handle == NULL ? PW_ID_ANY : PW_HANDLE_TO_ID(_this->handle); - SDL_bool iscapture = _this->iscapture; + Uint32 node_id = device->handle == NULL ? PW_ID_ANY : PW_HANDLE_TO_ID(device->handle); + const SDL_bool iscapture = device->iscapture; int res; /* Clamp the period size to sane values */ - const int min_period = PW_MIN_SAMPLES * SPA_MAX(_this->spec.freq / PW_BASE_CLOCK_RATE, 1); + const int min_period = PW_MIN_SAMPLES * SPA_MAX(device->spec.freq / PW_BASE_CLOCK_RATE, 1); /* Get the hints for the application name, stream name and role */ app_name = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_APP_NAME); @@ -1162,27 +1119,28 @@ static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) } /* Initialize the Pipewire stream info from the SDL audio spec */ - initialize_spa_info(&_this->spec, &spa_info); + initialize_spa_info(&device->spec, &spa_info); params = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &spa_info); if (params == NULL) { return SDL_SetError("Pipewire: Failed to set audio format parameters"); } priv = SDL_calloc(1, sizeof(struct SDL_PrivateAudioData)); - _this->hidden = priv; + device->hidden = priv; if (priv == NULL) { return SDL_OutOfMemory(); } /* Size of a single audio frame in bytes */ - priv->stride = (SDL_AUDIO_BITSIZE(_this->spec.format) >> 3) * _this->spec.channels; + priv->stride = (SDL_AUDIO_BITSIZE(device->spec.format) / 8) * device->spec.channels; - if (_this->spec.samples < min_period) { - _this->spec.samples = min_period; - _this->spec.size = _this->spec.samples * priv->stride; + if (device->sample_frames < min_period) { + device->sample_frames = min_period; } - (void)SDL_snprintf(thread_name, sizeof(thread_name), "SDLAudio%c%ld", (iscapture) ? 'C' : 'P', (long)_this->handle); + SDL_UpdatedAudioDeviceFormat(device); + + (void)SDL_snprintf(thread_name, sizeof(thread_name), "SDLAudio%c%ld", (iscapture) ? 'C' : 'P', (long)device->handle); priv->loop = PIPEWIRE_pw_thread_loop_new(thread_name, NULL); if (priv->loop == NULL) { return SDL_SetError("Pipewire: Failed to create stream loop (%i)", errno); @@ -1213,8 +1171,8 @@ static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) } PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_NAME, stream_name); PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_DESCRIPTION, stream_name); - PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%i", _this->spec.samples, _this->spec.freq); - PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", _this->spec.freq); + PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%i", device->sample_frames, device->spec.freq); + PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", device->spec.freq); PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_ALWAYS_PROCESS, "true"); /* @@ -1240,7 +1198,7 @@ static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) /* Create the new stream */ priv->stream = PIPEWIRE_pw_stream_new_simple(PIPEWIRE_pw_thread_loop_get_loop(priv->loop), stream_name, props, - iscapture ? &stream_input_events : &stream_output_events, _this); + iscapture ? &stream_input_events : &stream_output_events, device); if (priv->stream == NULL) { return SDL_SetError("Pipewire: Failed to create stream (%i)", errno); } @@ -1268,39 +1226,38 @@ static int PIPEWIRE_OpenDevice(SDL_AudioDevice *_this, const char *devname) return SDL_SetError("Pipewire: Stream error: %s", error); } - /* If this is a capture stream, make sure the intermediate buffer was successfully allocated. */ - if (iscapture && priv->buffer == NULL) { - return SDL_SetError("Pipewire: Failed to allocate source buffer"); - } - return 0; } -static void PIPEWIRE_CloseDevice(SDL_AudioDevice *_this) +static void PIPEWIRE_CloseDevice(SDL_AudioDevice *device) { - if (_this->hidden->loop) { - PIPEWIRE_pw_thread_loop_stop(_this->hidden->loop); + if (!device->hidden) { + return; } - if (_this->hidden->stream) { - PIPEWIRE_pw_stream_destroy(_this->hidden->stream); + if (device->hidden->loop) { + PIPEWIRE_pw_thread_loop_stop(device->hidden->loop); } - if (_this->hidden->context) { - PIPEWIRE_pw_context_destroy(_this->hidden->context); + if (device->hidden->stream) { + PIPEWIRE_pw_stream_destroy(device->hidden->stream); } - if (_this->hidden->loop) { - PIPEWIRE_pw_thread_loop_destroy(_this->hidden->loop); + if (device->hidden->context) { + PIPEWIRE_pw_context_destroy(device->hidden->context); } - if (_this->hidden->buffer) { - SDL_DestroyDataQueue(_this->hidden->buffer); + if (device->hidden->loop) { + PIPEWIRE_pw_thread_loop_destroy(device->hidden->loop); } - SDL_free(_this->hidden); + SDL_free(device->hidden); + device->hidden = NULL; + + SDL_AudioThreadFinalize(device); } +#if 0 static int PIPEWIRE_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int iscapture) { struct io_node *node; @@ -1338,6 +1295,7 @@ failed: PIPEWIRE_pw_thread_loop_unlock(hotplug_loop); return ret; } +#endif static void PIPEWIRE_Deinitialize(void) { @@ -1366,13 +1324,16 @@ static SDL_bool PIPEWIRE_Init(SDL_AudioDriverImpl *impl) /* Set the function pointers */ impl->DetectDevices = PIPEWIRE_DetectDevices; impl->OpenDevice = PIPEWIRE_OpenDevice; - impl->CloseDevice = PIPEWIRE_CloseDevice; impl->Deinitialize = PIPEWIRE_Deinitialize; - impl->GetDefaultAudioInfo = PIPEWIRE_GetDefaultAudioInfo; + //impl->GetDefaultAudioInfo = PIPEWIRE_GetDefaultAudioInfo; + impl->PlayDevice = PIPEWIRE_PlayDevice; + impl->GetDeviceBuf = PIPEWIRE_GetDeviceBuf; + impl->CaptureFromDevice = PIPEWIRE_CaptureFromDevice; + impl->FlushCapture = PIPEWIRE_FlushCapture; + impl->CloseDevice = PIPEWIRE_CloseDevice; impl->HasCaptureSupport = SDL_TRUE; impl->ProvidesOwnCallbackThread = SDL_TRUE; - impl->SupportsNonPow2Samples = SDL_TRUE; return SDL_TRUE; } diff --git a/src/audio/pipewire/SDL_pipewire.h b/src/audio/pipewire/SDL_pipewire.h index 4ca3315b4..5a6772ab5 100644 --- a/src/audio/pipewire/SDL_pipewire.h +++ b/src/audio/pipewire/SDL_pipewire.h @@ -32,11 +32,12 @@ struct SDL_PrivateAudioData struct pw_thread_loop *loop; struct pw_stream *stream; struct pw_context *context; - struct SDL_DataQueue *buffer; - size_t input_buffer_packet_size; Sint32 stride; /* Bytes-per-frame */ int stream_init_status; + + // Set in GetDeviceBuf, filled in AudioThreadIterate, queued in PlayDevice + struct pw_buffer *pw_buf; }; #endif /* SDL_pipewire_h_ */