mixer.h

Go to the documentation of this file.

#include <ascii-chat/common.h>
#pragma once

 
#include <stdbool.h>
#include <stdint.h>
 
// Include ringbuffer.h to get the audio_ring_buffer_t type
#include "../ringbuffer.h"
#include <libplatform/rwlock.h>
#include "../asciichat_errno.h"
 
#ifdef __cplusplus
extern "C" {
#endif


#define MIXER_MAX_SOURCES MAX_SESSION_PARTICIPANTS
#define MIXER_MASK_WORDS ((MIXER_MAX_SOURCES + 63) / 64)

#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;
  atomic_t active_sources;
  int max_sources;
  int sample_rate;
  unsigned channels;
  struct spectral_processor *spectral_left[MIXER_MAX_SOURCES + 1];
  struct spectral_processor *spectral_right[MIXER_MAX_SOURCES + 1];

  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[MIXER_MASK_WORDS];
  uint8_t source_id_to_index[256]; // One entry for each possible uint8_t source ID.
  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);
mixer_t *mixer_create_channels(int max_sources, int sample_rate, unsigned channels);
int mixer_source_count(const mixer_t *mixer);

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