[client] windows: add WASAPI audio support

client/audiodevs/WASAPI/capture_queue.c

@@ -0,0 +1,145 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "capture_queue.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool wasapi_captureQueueInit(WasapiCaptureQueue * queue, size_t capacity,
+    size_t slotSize)
+{
+  if (!queue || !capacity || !slotSize || capacity == SIZE_MAX)
+    return false;
+
+  const size_t slotCount = capacity + 1;
+  if (slotCount > SIZE_MAX / sizeof(*queue->packets) ||
+      slotCount > SIZE_MAX / slotSize)
+    return false;
+
+  WasapiCapturePacket * packets = calloc(slotCount, sizeof(*packets));
+  uint8_t             * data    = malloc(slotCount * slotSize);
+  if (!packets || !data)
+  {
+    free(data);
+    free(packets);
+    return false;
+  }
+
+  for (size_t i = 0; i < slotCount; ++i)
+    packets[i].data = data + i * slotSize;
+
+  queue->packets   = packets;
+  queue->data      = data;
+  queue->slotSize  = slotSize;
+  queue->slotCount = slotCount;
+  atomic_init(&queue->head, 0);
+  atomic_init(&queue->tail, 0);
+  return true;
+}
+
+void wasapi_captureQueueFree(WasapiCaptureQueue * queue)
+{
+  if (!queue)
+    return;
+
+  free(queue->data);
+  free(queue->packets);
+  *queue = (WasapiCaptureQueue) { 0 };
+}
+
+void wasapi_captureQueueReset(WasapiCaptureQueue * queue)
+{
+  if (!queue)
+    return;
+
+  atomic_store_explicit(&queue->head, 0, memory_order_relaxed);
+  atomic_store_explicit(&queue->tail, 0, memory_order_relaxed);
+}
+
+bool wasapi_captureQueuePush(WasapiCaptureQueue * queue,
+    const uint8_t * data, size_t bytes, int frames,
+    const LG_AudioClock * clock)
+{
+  if (!data || frames < 0)
+    return false;
+
+  uint8_t * destination = wasapi_captureQueueBegin(queue, bytes);
+  if (!destination)
+    return false;
+
+  memcpy(destination, data, bytes);
+  wasapi_captureQueueCommit(queue, bytes, frames, clock);
+  return true;
+}
+
+uint8_t * wasapi_captureQueueBegin(WasapiCaptureQueue * queue, size_t bytes)
+{
+  if (!queue || !queue->packets || bytes > queue->slotSize)
+    return NULL;
+
+  const size_t head = atomic_load_explicit(
+      &queue->head, memory_order_relaxed);
+  const size_t next = (head + 1) % queue->slotCount;
+  if (next == atomic_load_explicit(&queue->tail, memory_order_acquire))
+    return NULL;
+
+  return queue->packets[head].data;
+}
+
+void wasapi_captureQueueCommit(WasapiCaptureQueue * queue, size_t bytes,
+    int frames, const LG_AudioClock * clock)
+{
+  const size_t head = atomic_load_explicit(
+      &queue->head, memory_order_relaxed);
+  WasapiCapturePacket * packet = &queue->packets[head];
+  packet->bytes      = bytes;
+  packet->frames     = frames;
+  packet->clockValid = clock != NULL;
+  packet->clock      = clock ? *clock : (LG_AudioClock) { 0 };
+  atomic_store_explicit(&queue->head,
+      (head + 1) % queue->slotCount, memory_order_release);
+}
+
+const WasapiCapturePacket * wasapi_captureQueueFront(
+    WasapiCaptureQueue * queue)
+{
+  if (!queue || !queue->packets)
+    return NULL;
+
+  const size_t tail = atomic_load_explicit(
+      &queue->tail, memory_order_relaxed);
+  if (tail == atomic_load_explicit(&queue->head, memory_order_acquire))
+    return NULL;
+
+  return &queue->packets[tail];
+}
+
+void wasapi_captureQueuePop(WasapiCaptureQueue * queue)
+{
+  if (!queue || !queue->packets)
+    return;
+
+  const size_t tail = atomic_load_explicit(
+      &queue->tail, memory_order_relaxed);
+  atomic_store_explicit(
+      &queue->tail, (tail + 1) % queue->slotCount, memory_order_release);
+}