mixer.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
// Include ringbuffer.h to get the audio_ring_buffer_t type
#include "../ringbuffer.h"
#include "../platform/rwlock.h"
#include "../asciichat_errno.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MIXER_MAX_SOURCES 32 // Increased to match MAX_CLIENTS
 
#define MIXER_FRAME_SIZE 256
 
typedef struct {
  float threshold_dB;
  float knee_dB;
  float ratio;
  uint64_t attack_ns;
  uint64_t release_ns;
  float makeup_dB;
 
  float sample_rate;
  float envelope;
  float gain_lin;
  float attack_coeff;
  float release_coeff;
} compressor_t;
 
typedef struct {
  float threshold;
  uint64_t attack_ns;
  uint64_t release_ns;
  float hysteresis;
 
  float sample_rate;
  float envelope;
  float attack_coeff;
  float release_coeff;
  bool gate_open;
} noise_gate_t;
 
typedef struct {
  float cutoff_hz;
  float sample_rate;
 
  float alpha;
  float prev_input;
  float prev_output;
} highpass_filter_t;
 
typedef struct {
  float cutoff_hz;
  float sample_rate;
 
  float alpha;
  float prev_output;
} lowpass_filter_t;
 
typedef struct {
  float threshold_dB;
  float leader_margin_dB;
  float atten_dB;
  uint64_t attack_ns;
  uint64_t release_ns;
 
  float attack_coeff;
  float release_coeff;
  float *envelope;
  float *gain;
} ducking_t;
 
typedef struct {
  int num_sources;
  int max_sources;
  int sample_rate;
 
  audio_ring_buffer_t **source_buffers;
  // Each listener owns its unread samples from each remote source.
  struct mixer_listener_buffer *listener_buffers[MIXER_MAX_SOURCES][MIXER_MAX_SOURCES];
  const char **source_ids;
  bool *source_active;
 
  uint64_t active_sources_mask;
  uint8_t source_id_to_index[256];
  const char *source_id_at_hash[256];
 
  rwlock_t source_lock;
 
  float crowd_alpha;
  float base_gain;
 
  ducking_t ducking;
  compressor_t compressor;
 
  float *mix_buffer;
} mixer_t;
 
mixer_t *mixer_create(int max_sources, int sample_rate);
 
void mixer_destroy(mixer_t *mixer);
 
int mixer_add_source(mixer_t *mixer, const char *client_id, audio_ring_buffer_t *buffer);
 
void mixer_remove_source(mixer_t *mixer, const char *client_id);
 
void mixer_set_source_active(mixer_t *mixer, const char *client_id, bool active);
 
/* ============================================================================
 * Mixer Hash Table Helpers (Internal API)
 * ============================================================================ */
 
#define MIXER_HASH_INVALID 0xFF
 
static inline uint8_t mixer_hash_client_id(uint32_t client_id) {
  return (uint8_t)(client_id & 0xFF);
}
 
static inline void mixer_hash_mark_invalid(mixer_t *mixer, uint32_t client_id) {
  if (mixer) {
    mixer->source_id_to_index[mixer_hash_client_id(client_id)] = MIXER_HASH_INVALID;
  }
}
 
static inline void mixer_hash_set_slot(mixer_t *mixer, uint32_t client_id, uint8_t slot) {
  if (mixer) {
    mixer->source_id_to_index[mixer_hash_client_id(client_id)] = slot;
  }
}
 
static inline bool mixer_hash_is_invalid(mixer_t *mixer, uint32_t client_id) {
  if (!mixer)
    return true;
  return mixer->source_id_to_index[mixer_hash_client_id(client_id)] == MIXER_HASH_INVALID;
}
 
static inline uint8_t mixer_hash_get_slot(mixer_t *mixer, uint32_t client_id) {
  if (!mixer)
    return MIXER_HASH_INVALID;
  return mixer->source_id_to_index[mixer_hash_client_id(client_id)];
}
 
int mixer_process(mixer_t *mixer, float *output, int num_samples);
 
int mixer_process_excluding_source(mixer_t *mixer, float *output, int num_samples, uint32_t exclude_client_id);
 
float db_to_linear(float db);
 
float linear_to_db(float linear);
 
float clamp_float(float value, float min, float max);
 
void compressor_init(compressor_t *comp, float sample_rate);
 
void compressor_set_params(compressor_t *comp, float threshold_dB, float ratio, uint64_t attack_ns, uint64_t release_ns,
                           float makeup_dB);
 
float compressor_process_sample(compressor_t *comp, float sidechain);
 
int ducking_init(ducking_t *duck, int num_sources, float sample_rate);
 
void ducking_destroy(ducking_t *duck);
 
void ducking_set_params(ducking_t *duck, float threshold_dB, float leader_margin_dB, float atten_dB, uint64_t attack_ns,
                        uint64_t release_ns);
 
void ducking_process_frame(ducking_t *duck, float *envelopes, float *gains, int num_sources);
 
void noise_gate_init(noise_gate_t *gate, float sample_rate);
 
void noise_gate_set_params(noise_gate_t *gate, float threshold, uint64_t attack_ns, uint64_t release_ns,
                           float hysteresis);
 
float noise_gate_process_sample(noise_gate_t *gate, float input, float peak_amplitude);
 
void noise_gate_process_buffer(noise_gate_t *gate, float *buffer, int num_samples);
 
bool noise_gate_is_open(const noise_gate_t *gate);
 
void highpass_filter_init(highpass_filter_t *filter, float cutoff_hz, float sample_rate);
 
void highpass_filter_reset(highpass_filter_t *filter);
 
float highpass_filter_process_sample(highpass_filter_t *filter, float input);
 
void highpass_filter_process_buffer(highpass_filter_t *filter, float *buffer, int num_samples);
 
void lowpass_filter_init(lowpass_filter_t *filter, float cutoff_hz, float sample_rate);
 
void lowpass_filter_reset(lowpass_filter_t *filter);
 
float lowpass_filter_process_sample(lowpass_filter_t *filter, float input);
 
void lowpass_filter_process_buffer(lowpass_filter_t *filter, float *buffer, int num_samples);
 
float smoothstep(float t);
 
int16_t float_to_int16(float sample);
 
float int16_to_float(int16_t sample);
 
void buffer_float_to_int16(const float *src, int16_t *dst, int count);
 
void buffer_int16_to_float(const int16_t *src, float *dst, int count);
 
float buffer_peak(const float *buffer, int count);
 
void apply_gain_buffer(float *buffer, int count, float gain);
 
void fade_buffer(float *buffer, int count, float start_gain, float end_gain);
 
void fade_buffer_smooth(float *buffer, int count, bool fade_in);
 
void copy_buffer_with_gain(const float *src, float *dst, int count, float gain);
 
float soft_clip(float sample, float threshold, float steepness);
 
void soft_clip_buffer(float *buffer, int num_samples, float threshold, float steepness);
 
#ifdef __cplusplus
}
#endif