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;
  float attack_ms;
  float release_ms;
  float makeup_dB;
 
  float sample_rate;
  float envelope;
  float gain_lin;
  float attack_coeff;
  float release_coeff;
} compressor_t;
 
typedef struct {
  float threshold;
  float attack_ms;
  float release_ms;
  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;
  float attack_ms;
  float release_ms;
 
  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;
  uint32_t *source_ids;
  bool *source_active;
 
  uint64_t active_sources_mask;
  uint8_t source_id_to_index[256];
  uint32_t 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, uint32_t client_id, audio_ring_buffer_t *buffer);
 
void mixer_remove_source(mixer_t *mixer, uint32_t client_id);
 
void mixer_set_source_active(mixer_t *mixer, uint32_t client_id, bool active);
 
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, float attack_ms, float release_ms,
                           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_free(ducking_t *duck);
 
void ducking_set_params(ducking_t *duck, float threshold_dB, float leader_margin_dB, float atten_dB, float attack_ms,
                        float release_ms);
 
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, float attack_ms, float release_ms, 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