audio mixer

Author: braindigitalis

include/audio.h

@@ -54,6 +54,9 @@ typedef uint32_t (*audio_length_t)(void);
 /** @brief Maximum length (including NUL) for an audio device’s display name. */
 #define MAX_AUDIO_DEVICE_NAME 32
 
+/** @brief Opaque channel handle. */
+typedef struct mixer_stream mixer_stream_t;
+
 /**
  * @brief Registered audio device descriptor.
  *
@@ -95,23 +98,93 @@ typedef struct audio_device_t {
  * @brief Register a new audio device.
  *
  * Inserts @p newdev into the global device list. The caller retains ownership
- * of the storage; the struct must remain valid for the lifetime of the device.
+ * of the storage; the struct must remain valid for the lifetime of the device
  *
- * @param newdev Pointer to the device descriptor to register (must not be NULL).
+ * @param newdev Pointer to the device descriptor to register (must not be NULL)
  * @return true on success, false on failure.
  */
 bool register_audio_device(audio_device_t *newdev);
 
 /**
- * @brief Find a registered audio device by name.
+ * @brief Find a registered audio device by name
  *
- * @param name NUL-terminated device name to search for.
- * @return Pointer to the matching device, or NULL if not found.
+ * @param name NUL-terminated device name to search for
+ * @return Pointer to the matching device, or NULL if not found
  */
 audio_device_t *find_audio_device(const char *name);
 
 /**
- * @brief Get the first registered audio device, if any.
- * @return Pointer to the first device in the list, or NULL if none.
+ * @brief Get the first registered audio device, if any
+ * @return Pointer to the first device in the list, or NULL if none
  */
 audio_device_t *find_first_audio_device(void);
+
+/**
+ * @brief Initialise the mixer and register the idle tick
+ *
+ * Consumes queued frames from all active channels, applies gain/mute,
+ * mixes them with 32-bit accumulation using SSE2, clips to 16-bit,
+ * and pushes the result to the first audio device until the desired
+ * latency is met. This is the sole hot path of the software mixer.
+ *
+ * @param dev               Audio device to attach the mixer to
+ * @param target_latency_ms Desired steady-state output latency in ms
+ * @param idle_period_ms    Foreground idle period in ms (mix cadence)
+ * @param max_channels      Maximum number of concurrently open channels
+ * @return true on success, false if no audio device or allocation failed
+ */
+bool mixer_init(audio_device_t* dev, uint32_t target_latency_ms, uint32_t idle_period_ms, uint32_t max_channels);
+
+/**
+ * @brief Open a channel slot for a producer
+ *
+ * Single producer per channel, the mixer is the sole consumer
+ * @return Channel handle or NULL if none available
+ */
+mixer_stream_t *mixer_create_stream(void);
+
+/**
+ * @brief Close a channel (drains remaining data then frees the slot)
+ */
+void mixer_free_stream(mixer_stream_t *ch);
+
+/**
+ * @brief Submit interleaved S16LE stereo frames to a channel (non-blocking)
+ *
+ * Identical signature and semantics to audio_push_t; returns frames accepted
+ */
+size_t mixer_push(mixer_stream_t *ch, const int16_t *frames, size_t total_frames);
+
+/**
+ * @brief Set per-channel gain (Q8.8; 256 == 1.0).
+ */
+void mixer_set_gain(mixer_stream_t *ch, uint16_t q8_8_gain);
+
+/**
+ * @brief Mute/unmute a channel; muted channels do not contribute to the mix.
+ */
+void mixer_set_mute(mixer_stream_t *ch, bool mute);
+
+/**
+ * @brief Query frames currently queued in a channel ring.
+ */
+uint32_t mixer_stream_queue_length(mixer_stream_t *ch);
+
+/**
+ * @brief Return the audio device used by the mixer (first device) or NULL.
+ */
+audio_device_t *mixer_device(void);
+
+/**
+ * @brief Foreground idle callback to drive the mixer.
+ *
+ * Called periodically by the process idle scheduler to top up the
+ * output device with freshly mixed audio. Consumes queued frames
+ * from all active mixer channels, applies gain/mute, and pushes
+ * the mixed stream to the first audio device until the desired
+ * latency is reached.
+ *
+ * This function is not intended to be called directly; it is
+ * registered with @ref proc_register_idle by @ref mixer_init.
+ */
+void mixer_idle(void);

modules/ac97/ac97.c

@@ -72,18 +72,18 @@ static bool ac97_start(pci_dev_t dev) {
 	return true;
 }
 
-static bool init_ac97(void) {
+static audio_device_t* init_ac97(void) {
 	pci_dev_t dev = pci_get_device(0, 0, 0x0401);
 	if (!dev.bits) {
 		dprintf("ac97: no devices (class 0x0401)\n");
-		return false;
+		return NULL;
 	}
 	if (ac97_start(dev)) {
 		kprintf("ac97: started\n");
 		ac97_stream_prepare(4096, 44100); /* 44.1khz stereo LE 16 bit */
 	} else {
 		dprintf("ac97: start failed\n");
-		return false;
+		return NULL;
 	}
 	proc_register_idle(ac97_idle, IDLE_FOREGROUND, 1);
 
@@ -97,9 +97,8 @@ static bool init_ac97(void) {
 	device->resume = ac97_resume;
 	device->stop = ac97_stop_clear;
 	device->queue_length = ac97_buffered_ms;
-	register_audio_device(device);
 
-	return true;
+	return register_audio_device(device) ? device : NULL;
 }
 
 static inline uint8_t ac97_po_civ(void) {
@@ -407,23 +406,15 @@ uint32_t ac97_get_hz() {
 	return rate;
 }
 
-void ac97_test_melody(void) {
-	if (!ac97.bdl || !ac97.buf || ac97.bdl_n != 32 || ac97.frag_frames == 0 || ac97.frag_bytes == 0) {
-		dprintf("ac97: test_melody: stream not prepared\n");
-		return;
-	}
-
-	fs_directory_entry_t* entry = fs_get_file_info("/system/webserver/test.raw");
-	int16_t* data = kmalloc(entry->size);
-	fs_read_file(entry, 0, entry->size, (unsigned char*)data);
-	push_all_s16le(data, entry->size / sizeof(int16_t) / 2);
-	kfree(data);
-}
-
 bool EXPORTED MOD_INIT_SYM(KMOD_ABI)(void) {
 	dprintf("ac97: module loaded\n");
-	if (init_ac97()) {
-		ac97_test_melody();
+	audio_device_t* dev;
+	if (!(dev = init_ac97())) {
+		return false;
+	}
+	if (!mixer_init(dev, 50, 25, 64)) {
+		dprintf("ac97: mixer init failed\n");
+		return false;
 	}
 	return true;
 }

modules/ac97/ac97.h

@@ -145,19 +145,6 @@ uint32_t ac97_buffered_ms(void);
  */
 uint32_t ac97_get_hz(void);
 
-/**
- * @brief  Test helper: load a RAW S16LE stereo file and enqueue it.
- *
- * Loads "/system/webserver/test.raw" (header-less, S16LE, stereo) into
- * memory and enqueues the entire file into the software FIFO using
- * push_all_s16le(). Playback proceeds asynchronously via ac97_idle().
- *
- * @note   The stream must already be prepared; the file’s sample rate must
- *         match the active DAC rate or it will play at the wrong speed.
- * @warning Reads the whole file into memory in one go (no streaming).
- */
-void ac97_test_melody(void);
-
 /**
  * @brief  Prepare AC’97 PCM Out stream buffers and descriptors.
  *