Data Structures
struct	audio_processor
	For audio processor, this is the live record that ties config, spectral_left, spectral_right, compressor together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. More...

Functions
audio_processor_config_t	audio_processor_default_config (int sample_rate)
void	audio_processor_reset (audio_processor_t *p)
asciichat_error_t	audio_processor_create (const audio_processor_config_t c, audio_processor_t *out)
void	audio_processor_set_flags (audio_processor_t *p, audio_processor_flags_t flags)
asciichat_error_t	audio_processor_process (audio_processor_t p, const float input, float *output, size_t count)
void	audio_processor_destroy (audio_processor_t *p)

Function Documentation

◆ audio_processor_create()

asciichat_error_t audio_processor_create	(	const audio_processor_config_t *	c,
		audio_processor_t **	out )

Definition at line 71 of file processor.c.

                                                                                                     {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing audio processor output");
  *out = NULL;
  if (!c || c->channels < 0 || c->channels > 2 || c->sample_rate < 16000 || c->sample_rate > 192000 ||
      c->spectral.sample_rate != c->sample_rate || c->agc_level < 1 || c->agc_level > 32767 || c->agc_max_gain < 0 ||
      c->agc_max_gain > 36 || !isfinite(c->highpass_hz) || c->highpass_hz <= 0 ||
      c->highpass_hz >= c->sample_rate / 2.0f || !isfinite(c->lowpass_hz) || c->lowpass_hz <= 0 ||
      c->lowpass_hz > c->sample_rate / 2.0f || !isfinite(c->comp_ratio) || c->comp_ratio < 1 || c->comp_ratio > 20 ||
      !isfinite(c->comp_threshold_db) || !isfinite(c->comp_makeup_db) || !isfinite(c->gate_threshold) ||
      c->gate_threshold < 0 || c->gate_threshold > 1 || !isfinite(c->gate_hysteresis) || c->gate_hysteresis < 0 ||
      c->gate_hysteresis > 1)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid audio processor configuration");
  audio_processor_t *p = SAFE_CALLOC(1, sizeof(*p), audio_processor_t *);
  p->config = *c;
  if (p->config.channels == 0)
    p->config.channels = 1;
  if (p->config.channels == 2) {
    if (c->spectral_enabled && (c->spectral.auto_gain || c->spectral.compressor || c->spectral.noise_gate))
      log_warn_once("Stereo capture uses linked broadband dynamics; spectral AGC, multiband compression and spectral "
                    "gating options are unavailable");
    // Stereo dynamics share one detector after the independent channel filters.
    p->config.spectral.auto_gain = false;
    p->config.spectral.compressor = false;
    p->config.spectral.noise_gate = false;
  }
  p->max_gain = powf(10, c->agc_max_gain / 20.0f);
  p->gain_attack = 1 - powf(0.75f, 100.0f / c->sample_rate);
  p->gain_release = 1 - powf(0.95f, 100.0f / c->sample_rate);
  if (c->spectral_enabled) {
    asciichat_error_t result = spectral_create(&p->config.spectral, &p->spectral_left);
    if (result != ASCIICHAT_OK) {
      SAFE_FREE(p);
      return result;
    }
    if (p->config.channels == 2) {
      result = spectral_create(&p->config.spectral, &p->spectral_right);
      if (result != ASCIICHAT_OK) {
        spectral_destroy(p->spectral_left);
        SAFE_FREE(p);
        return result;
      }
    }
  }
  audio_processor_reset(p);
  *out = p;
  return ASCIICHAT_OK;
}

Referenced by client_audio_pipeline_create().

◆ audio_processor_default_config()

audio_processor_config_t audio_processor_default_config ( int sample_rate )

Microphone defaults shared by native and browser hosts; no global options.

Definition at line 29 of file processor.c.

                                                                         {
  return (audio_processor_config_t){
      .sample_rate = sample_rate,
      .flags = {.agc = true, .compressor = true, .highpass = true},
      .spectral_enabled = true,
      .spectral = spectral_default_config(sample_rate),
      .agc_level = 16000,
      .agc_max_gain = 35,
      .highpass_hz = 150,
      .lowpass_hz = 8000,
      .comp_threshold_db = -12,
      .comp_ratio = 3,
      .comp_makeup_db = 6,
      .comp_attack_ns = 5 * NS_PER_MS_INT,
      .comp_release_ns = 150 * NS_PER_MS_INT,
      .gate_threshold = 0.08f,
      .gate_hysteresis = 0.3f,
      .gate_attack_ns = 500 * NS_PER_US_INT,
      .gate_release_ns = 30 * NS_PER_MS_INT,
  };
}

References NS_PER_MS_INT, NS_PER_US_INT, and spectral_default_config().

Referenced by client_audio_pipeline_default_config().

◆ audio_processor_destroy()

void audio_processor_destroy ( audio_processor_t * p )

Definition at line 229 of file processor.c.

                                                   {
  if (!p)
    return;
  spectral_destroy(p->spectral_left);
  spectral_destroy(p->spectral_right);
  p->spectral_left = NULL;
  SAFE_FREE(p);
}

References SAFE_FREE, spectral_destroy(), audio_processor::spectral_left, and audio_processor::spectral_right.

Referenced by client_audio_pipeline_destroy(), and AudioProcessorBinding::~AudioProcessorBinding().

◆ audio_processor_process()

asciichat_error_t audio_processor_process	(	audio_processor_t *	processor,
		const float *	input,
		float *	output,
		size_t	count )

Arbitrary block sizes, in-place buffers, and no allocations or locks. AEC precedes this operation.

Definition at line 125 of file processor.c.

                                                                                                                 {
  if (!p || (!input && count) || (!output && count))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid audio processor buffers");
  if (!count)
    return ASCIICHAT_OK;
  if (p->config.channels == 2) {
    if (count % 2)
      return SET_ERRNO(ERROR_INVALID_PARAM, "Incomplete stereo PCM frame");
    const audio_processor_config_t *c = &p->config;
    for (size_t base = 0; base < count;) {
      size_t frames = (count - base) / 2;
      if (frames > 480)
        frames = 480;
      float left[480], right[480];
      for (size_t i = 0; i < frames; i++) {
        left[i] = input[base + i * 2];
        right[i] = input[base + i * 2 + 1];
      }
      if (p->spectral_left) {
        asciichat_error_t result = spectral_process(p->spectral_left, left, left, frames);
        if (result == ASCIICHAT_OK)
          result = spectral_process(p->spectral_right, right, right, frames);
        if (result != ASCIICHAT_OK)
          return result;
      }
      for (size_t i = 0; i < frames; i++) {
        float l = isfinite(left[i]) ? left[i] : 0;
        float r = isfinite(right[i]) ? right[i] : 0;
        if (c->flags.highpass) {
          l = highpass_filter_process_sample(&p->highpass, l);
          r = highpass_filter_process_sample(&p->highpass_right, r);
        }
        if (c->flags.lowpass) {
          l = lowpass_filter_process_sample(&p->lowpass, l);
          r = lowpass_filter_process_sample(&p->lowpass_right, r);
        }
        float gain = 1;
        float peak = fmaxf(fabsf(l), fabsf(r));
        if (c->flags.agc) {
          p->energy += ((double)l * l + (double)r * r) * 0.5;
          if (++p->level_samples == (size_t)c->sample_rate / 100) {
            float rms = (float)sqrt(p->energy / p->level_samples);
            float target = fminf(0.5f, fmaxf(0.05f, c->agc_level / 32768.0f));
            p->target_gain = rms > 1e-5f ? fminf(p->max_gain, fmaxf(1, target / rms)) : 1;
            p->energy = 0;
            p->level_samples = 0;
          }
          float coefficient = p->target_gain < p->gain ? p->gain_attack : p->gain_release;
          p->gain += coefficient * (p->target_gain - p->gain);
          gain *= p->gain;
        }
        if (c->flags.noise_gate)
          gain *= noise_gate_process_sample(&p->gate, 1, peak * gain);
        if (c->flags.compressor)
          gain *= compressor_process_sample(&p->compressor, peak * gain);
        if (peak > 0)
          gain = fminf(gain, 1.0f / peak);
        output[base + i * 2] = l * gain;
        output[base + i * 2 + 1] = r * gain;
      }
      base += frames * 2;
    }
    return ASCIICHAT_OK;
  }
  if (p->spectral_left) {
    asciichat_error_t result = spectral_process(p->spectral_left, input, output, count);
    if (result != ASCIICHAT_OK)
      return result;
  } else if (input != output) {
    memcpy(output, input, count * sizeof(float));
  }
  const audio_processor_config_t *c = &p->config;
  // Accumulate levels on the sample clock, independent of host callback sizes.
  const size_t level_frame = (size_t)c->sample_rate / 100;
  for (size_t i = 0; i < count; ++i) {
    float sample = isfinite(output[i]) ? output[i] : 0;
    if (c->flags.agc && !(p->spectral_left && c->spectral.auto_gain)) {
      p->energy += (double)sample * sample;
      if (++p->level_samples == level_frame) {
        float rms = (float)sqrt(p->energy / level_frame);
        float target = fminf(0.5f, fmaxf(0.05f, c->agc_level / 32768.0f));
        p->target_gain = rms > 1e-5f ? fminf(p->max_gain, fmaxf(1, target / rms)) : 1;
        p->energy = 0;
        p->level_samples = 0;
      }
      float coefficient = p->target_gain < p->gain ? p->gain_attack : p->gain_release;
      p->gain += coefficient * (p->target_gain - p->gain);
      sample *= p->gain;
    }
    if (c->flags.highpass)
      sample = highpass_filter_process_sample(&p->highpass, sample);
    if (c->flags.lowpass)
      sample = lowpass_filter_process_sample(&p->lowpass, sample);
    if (c->flags.noise_gate)
      sample = noise_gate_process_sample(&p->gate, sample, fabsf(sample));
    if (c->flags.compressor && !(p->spectral_left && c->spectral.compressor)) {
      sample *= compressor_process_sample(&p->compressor, sample);
      sample = soft_clip(sample, 0.7f, 3);
    }
    output[i] = sample;
  }
  return ASCIICHAT_OK;
}

References audio_processor_flags_t::agc, audio_processor_config_t::agc_level, ASCIICHAT_OK, spectral_config_t::auto_gain, audio_processor_config_t::channels, audio_processor::compressor, audio_processor_flags_t::compressor, spectral_config_t::compressor, compressor_process_sample(), audio_processor::config, audio_processor::energy, ERROR_INVALID_PARAM, audio_processor_config_t::flags, audio_processor::gain, audio_processor::gain_attack, audio_processor::gain_release, audio_processor::gate, audio_processor::highpass, audio_processor_flags_t::highpass, highpass_filter_process_sample(), audio_processor::highpass_right, audio_processor::level_samples, audio_processor::lowpass, audio_processor_flags_t::lowpass, lowpass_filter_process_sample(), audio_processor::lowpass_right, audio_processor::max_gain, audio_processor_flags_t::noise_gate, noise_gate_process_sample(), audio_processor_config_t::sample_rate, SET_ERRNO, soft_clip(), audio_processor_config_t::spectral, audio_processor::spectral_left, spectral_process(), audio_processor::spectral_right, and audio_processor::target_gain.

Referenced by client_audio_pipeline_process_duplex(), and AudioProcessorBinding::process().

◆ audio_processor_reset()

void audio_processor_reset ( audio_processor_t * p )

Definition at line 51 of file processor.c.

                                                 {
  if (!p)
    return;
  spectral_reset(p->spectral_left);
  spectral_reset(p->spectral_right);
  const audio_processor_config_t *c = &p->config;
  compressor_init(&p->compressor, (float)c->sample_rate);
  compressor_set_params(&p->compressor, c->comp_threshold_db, c->comp_ratio, c->comp_attack_ns, c->comp_release_ns,
                        c->comp_makeup_db);
  noise_gate_init(&p->gate, (float)c->sample_rate);
  noise_gate_set_params(&p->gate, c->gate_threshold, c->gate_attack_ns, c->gate_release_ns, c->gate_hysteresis);
  highpass_filter_init(&p->highpass, c->highpass_hz, (float)c->sample_rate);
  lowpass_filter_init(&p->lowpass, c->lowpass_hz, (float)c->sample_rate);
  highpass_filter_init(&p->highpass_right, c->highpass_hz, (float)c->sample_rate);
  lowpass_filter_init(&p->lowpass_right, c->lowpass_hz, (float)c->sample_rate);
  p->energy = 0;
  p->level_samples = 0;
  p->gain = p->target_gain = 1;
}

Referenced by audio_processor_create(), and client_audio_pipeline_reset().

◆ audio_processor_set_flags()

void audio_processor_set_flags	(	audio_processor_t *	p,
		audio_processor_flags_t	flags )

Definition at line 120 of file processor.c.

                                                                                    {
  if (p)
    p->config.flags = flags;
}

References audio_processor::config, and audio_processor_config_t::flags.

Referenced by client_audio_pipeline_set_flags().

Data Structures