spectral.c File Reference

Go to the source code of this file.

Data Structures
struct	spectral_processor
	spectral processor keeps the values that move through the subsystem: config, forward, inverse, pitch_hz. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself. More...

Macros
#define	SPECTRAL_MAX_SIZE   2048
#define	SPECTRAL_MAX_BINS   (SPECTRAL_MAX_SIZE / 2 + 1)

Functions
spectral_config_t	spectral_default_config (int sample_rate)
void	spectral_reset (spectral_processor_t *p)
asciichat_error_t	spectral_create (const spectral_config_t *c, spectral_processor_t **out)
void	spectral_destroy (spectral_processor_t *p)
asciichat_error_t	spectral_process (spectral_processor_t *p, const float *input, float *output, size_t count)
const float *	spectral_spectrum (const spectral_processor_t *p, size_t *bins)
float	spectral_pitch_hz (const spectral_processor_t *p)

Variables
static_mutex_t	audio_fftw_planner_lock = STATIC_MUTEX_INIT

Macro Definition Documentation

SPECTRAL_MAX_BINS

#define SPECTRAL_MAX_BINS   (SPECTRAL_MAX_SIZE / 2 + 1)

Definition at line 10 of file spectral.c.

Referenced by spectral_reset().

SPECTRAL_MAX_SIZE

#define SPECTRAL_MAX_SIZE   2048

Definition at line 9 of file spectral.c.

Function Documentation

spectral_create()

asciichat_error_t spectral_create	(	const spectral_config_t *	c,
		spectral_processor_t **	out )

Definition at line 68 of file spectral.c.

                                                                                          {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing spectral output pointer");
  *out = NULL;
  if (!c || c->sample_rate < 16000 || c->sample_rate > 192000 ||
      (c->fft_size != 512 && c->fft_size != 1024 && c->fft_size != 2048) || !isfinite(c->reduction_db) ||
      c->reduction_db < 0 || c->reduction_db > 60)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid spectral configuration");
  for (int b = 0; b < 4; ++b) {
    if (!isfinite(c->ratios[b]) || c->ratios[b] < 1 || c->ratios[b] > 20 || !isfinite(c->thresholds_db[b]) ||
        c->thresholds_db[b] > 0 || c->thresholds_db[b] < -90)
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid spectral compressor band");
    if (b < 3 && (!isfinite(c->crossovers[b]) || c->crossovers[b] <= 0 || c->crossovers[b] > c->sample_rate / 2.0f ||
                  (b && c->crossovers[b] <= c->crossovers[b - 1])))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid spectral crossover");
  }
  spectral_processor_t *p = SAFE_CALLOC(1, sizeof(*p), spectral_processor_t *);
  if (!p)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate spectral processor");
  p->config = *c;
  (void)NAMED_REGISTER_MUTEX(&audio_fftw_planner_lock, "audio.fftw_planner", NULL);
  static_mutex_lock(&audio_fftw_planner_lock);
  p->forward = fftw_plan_dft_r2c_1d(c->fft_size, p->time, p->frequency, FFTW_ESTIMATE);
  p->inverse = fftw_plan_dft_c2r_1d(c->fft_size, p->frequency, p->restored, FFTW_ESTIMATE);
  static_mutex_unlock(&audio_fftw_planner_lock);
  if (!p->forward || !p->inverse) {
    spectral_destroy(p);
    return SET_ERRNO(ERROR_MEMORY, "Cannot create FFTW plans");
  }
  for (int i = 0; i < c->fft_size; ++i)
    p->window[i] = (float)(0.5 - 0.5 * cos(6.283185307179586 * i / c->fft_size));
  spectral_reset(p);
  *out = p;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, audio_fftw_planner_lock, spectral_processor::config, spectral_config_t::crossovers, ERROR_INVALID_PARAM, ERROR_MEMORY, spectral_config_t::fft_size, spectral_processor::forward, spectral_processor::frequency, spectral_processor::inverse, NAMED_REGISTER_MUTEX, out, spectral_config_t::ratios, spectral_config_t::reduction_db, spectral_processor::restored, SAFE_CALLOC, spectral_config_t::sample_rate, SET_ERRNO, spectral_destroy(), spectral_reset(), spectral_config_t::thresholds_db, spectral_processor::time, and spectral_processor::window.

Referenced by audio_processor_create(), and mixer_create_channels().

spectral_default_config()

spectral_config_t spectral_default_config

(

int

sample_rate

)

Definition at line 36 of file spectral.c.

                                                           {
  return (spectral_config_t){.sample_rate = sample_rate,
                             .fft_size = 1024,
                             .noise_gate = true,
                             .reduction_db = 18.0f,
                             .crossovers = {250, 2000, 8000},
                             .thresholds_db = {-18, -18, -18, -18},
                             .ratios = {2, 3, 3, 2}};
}

Referenced by audio_processor_default_config(), and mixer_create_channels().

spectral_destroy()

void spectral_destroy

(

spectral_processor_t *

p

)

Definition at line 104 of file spectral.c.

                                               {
  if (!p)
    return;
  static_mutex_lock(&audio_fftw_planner_lock);
  if (p->forward)
    fftw_destroy_plan(p->forward);
  if (p->inverse)
    fftw_destroy_plan(p->inverse);
  static_mutex_unlock(&audio_fftw_planner_lock);
  SAFE_FREE(p);
}

References audio_fftw_planner_lock, spectral_processor::forward, spectral_processor::inverse, and SAFE_FREE.

Referenced by audio_processor_create(), audio_processor_destroy(), mixer_destroy(), and spectral_create().

spectral_pitch_hz()

float spectral_pitch_hz

(

const spectral_processor_t *

processor

)

Latest input spectrum, normalized to sinusoidal peak amplitude; owner thread only.

Definition at line 301 of file spectral.c.

                                                       {
  return p ? p->pitch_hz : 0;
}

References spectral_processor::pitch_hz.

spectral_process()

asciichat_error_t spectral_process	(	spectral_processor_t *	processor,
		const float *	input,
		float *	output,
		size_t	count )

Arbitrary block sizes and in-place operation; no allocation or locks.

Definition at line 279 of file spectral.c.

                                                                                                             {
  if (!p || (!input && count) || (!output && count))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid spectral buffer");
  int n = p->config.fft_size, hop = n / 4;
  for (size_t i = 0; i < count; ++i) {
    float sample = input[i];
    output[i] = p->ready[p->cursor++];
    p->input[n - hop + p->pending++] = isfinite(sample) ? sample : 0;
    if (p->pending == hop) {
      process_frame(p);
      p->pending = p->cursor = 0;
    }
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, spectral_processor::config, spectral_processor::cursor, ERROR_INVALID_PARAM, spectral_config_t::fft_size, spectral_processor::input, spectral_processor::pending, spectral_processor::ready, and SET_ERRNO.

Referenced by audio_processor_process().

spectral_reset()

void spectral_reset

(

spectral_processor_t *

p

)

Definition at line 46 of file spectral.c.

                                             {
  if (!p)
    return;
  memset(p->input, 0, sizeof(p->input));
  memset(p->overlap, 0, sizeof(p->overlap));
  memset(p->ready, 0, sizeof(p->ready));
  memset(p->noise, 0, sizeof(p->noise));
  memset(p->smoothed, 0, sizeof(p->smoothed));
  memset(p->magnitude, 0, sizeof(p->magnitude));
  memset(p->band_average, 0, sizeof(p->band_average));
  for (int i = 0; i < SPECTRAL_MAX_BINS; ++i)
    p->gains[i] = 1;
  for (int i = 0; i < 4; ++i)
    p->band_gain[i] = p->eq_gain[i] = 1;
  p->pending = p->cursor = 0;
  memset(p->previous_phase, 0, sizeof(p->previous_phase));
  memset(p->synthesis_phase, 0, sizeof(p->synthesis_phase));
  p->pitch_hz = 0;
  p->auto_gain = 1;
  p->frames = 0;
}

References spectral_processor::auto_gain, spectral_processor::band_average, spectral_processor::band_gain, spectral_processor::cursor, spectral_processor::eq_gain, spectral_processor::frames, spectral_processor::gains, spectral_processor::input, spectral_processor::magnitude, spectral_processor::noise, spectral_processor::overlap, spectral_processor::pending, spectral_processor::pitch_hz, spectral_processor::previous_phase, spectral_processor::ready, spectral_processor::smoothed, SPECTRAL_MAX_BINS, and spectral_processor::synthesis_phase.

Referenced by audio_processor_reset(), mixer_remove_source(), and spectral_create().

spectral_spectrum()

const float * spectral_spectrum	(	const spectral_processor_t *	p,
		size_t *	bins )

Definition at line 295 of file spectral.c.

                                                                            {
  if (bins)
    *bins = p ? (size_t)p->config.fft_size / 2 + 1 : 0;
  return p ? p->magnitude : NULL;
}

References spectral_processor::config, spectral_config_t::fft_size, and spectral_processor::magnitude.

Variable Documentation

audio_fftw_planner_lock

static_mutex_t audio_fftw_planner_lock = STATIC_MUTEX_INIT

Definition at line 34 of file spectral.c.

Referenced by audio_visualization_fft_init(), spectral_create(), and spectral_destroy().