Macros
#define	FFT_SIZE 1024
#define	FFT_CACHE_CELLS (MAX_TERMINAL_WIDTH * MAX_TERMINAL_HEIGHT * 2)
#define	FFT_REFRESH_NS (100 * NS_PER_MS_INT)

Functions
asciichat_error_t	audio_visualization_fft_init (void)
char *	audio_visualization_render_fft (unsigned int width, unsigned int height, audio_visualization_source_t source, bool use_color, int color_mode, bool flip_x, bool flip_y)

Variables
static_mutex_t	audio_fftw_planner_lock

Macro Definition Documentation

◆ FFT_CACHE_CELLS

#define FFT_CACHE_CELLS (MAX_TERMINAL_WIDTH * MAX_TERMINAL_HEIGHT * 2)

Definition at line 16 of file fft.c.

◆ FFT_REFRESH_NS

#define FFT_REFRESH_NS (100 * NS_PER_MS_INT)

Definition at line 17 of file fft.c.

Referenced by audio_visualization_render_fft().

◆ FFT_SIZE

#define FFT_SIZE 1024

Definition at line 15 of file fft.c.

Referenced by audio_visualization_fft_init(), and audio_visualization_render_fft().

Function Documentation

◆ audio_visualization_fft_init()

asciichat_error_t audio_visualization_fft_init ( void )

Create the shared FFTW visualization plan before rendering begins.

Definition at line 61 of file fft.c.

                                                     {
  (void)NAMED_REGISTER_MUTEX(&fft_cache_mutex, "audio.visualization.fft_cache", NULL);
  (void)NAMED_REGISTER_MUTEX(&fftw_mutex, "audio.visualization.fftw", NULL);
  (void)NAMED_REGISTER_MUTEX(&audio_fftw_planner_lock, "audio.fftw_planner", NULL);
  static_mutex_lock(&fftw_mutex);
  if (!fftw_forward) {
    static_mutex_lock(&audio_fftw_planner_lock);
    fftw_forward = fftw_plan_dft_r2c_1d(FFT_SIZE, fftw_input, fftw_output, FFTW_ESTIMATE);
    static_mutex_unlock(&audio_fftw_planner_lock);
  }
  bool ready = fftw_forward != NULL;
  static_mutex_unlock(&fftw_mutex);
  return ready ? ASCIICHAT_OK : SET_ERRNO(ERROR_MEMORY, "Cannot create FFTW visualization plan");
}

References ASCIICHAT_OK, audio_fftw_planner_lock, ERROR_MEMORY, FFT_SIZE, NAMED_REGISTER_MUTEX, and SET_ERRNO.

Referenced by mirror_init(), session_display_create(), and ui_session_key().

◆ audio_visualization_render_fft()

char * audio_visualization_render_fft	(	unsigned int	width,
		unsigned int	height,
		audio_visualization_source_t	source,
		bool	use_color,
		int	color_mode,
		bool	flip_x,
		bool	flip_y )

Definition at line 91 of file fft.c.

                                                                                               {
  if (width < 16 || height < 6 || width > MAX_TERMINAL_WIDTH || height > MAX_TERMINAL_HEIGHT ||
      source < AUDIO_VISUALIZATION_SOURCE_MIC || source > AUDIO_VISUALIZATION_SOURCE_MIX)
    return NULL;
 
  if (GET_OPTION(render_mode) == RENDER_MODE_HALF_BLOCK)
    height *= 2;
  static_mutex_lock(&fft_cache_mutex);
  uint64_t now = time_get_ns();
  if (fft_cache.valid && fft_cache.width == width && fft_cache.height == height && fft_cache.source == source &&
      fft_cache.color_mode == color_mode && now >= fft_cache.updated_ns &&
      now - fft_cache.updated_ns < FFT_REFRESH_NS) {
    char *frame =
        visualization_encode(fft_cache.cells, fft_cache.colors, false, width, height, use_color, flip_x, flip_y);
    static_mutex_unlock(&fft_cache_mutex);
    return frame;
  }
  float *samples = SAFE_MALLOC(VISUALIZATION_HISTORY * sizeof(float), float *);
  if (!samples) {
    static_mutex_unlock(&fft_cache_mutex);
    return NULL;
  }
  audio_visualization_read(source, samples, VISUALIZATION_HISTORY);
  size_t cell_count = (size_t)width * height;
  char *cells = fft_cache.cells;
  unsigned char *colors = fft_cache.colors;
  memset(cells, ' ', cell_count);
  memset(colors, 0, cell_count * 3);
 
  /* Each column is a 21 ms Hann-windowed spectrum; adjacent columns overlap heavily. */
  float windowed[FFT_SIZE], magnitude[FFT_SIZE / 2 + 1];
  fft_scale_t scale;
  if (!parse_fft_scale_value(GET_OPTION(fft_scale), &scale))
    scale = (fft_scale_t){.mode = FFT_SCALE_DB, .min_db = -62.0f, .max_db = -6.0f};
  static const char levels[] = " .:-=+*#%@";
  const unsigned int spectrum_height = height;
  for (unsigned int x = 0; x < width; x++) {
    size_t center = (size_t)x * (VISUALIZATION_HISTORY - 1) / (width - 1);
    size_t start = center > FFT_SIZE / 2 ? center - FFT_SIZE / 2 : 0;
    if (start + FFT_SIZE > VISUALIZATION_HISTORY)
      start = VISUALIZATION_HISTORY - FFT_SIZE;
    for (size_t i = 0; i < FFT_SIZE; i++) {
      float window = 0.5f - 0.5f * cosf(6.28318530718f * (float)i / (float)(FFT_SIZE - 1));
      windowed[i] = samples[start + i] * window;
    }
    if (!visualization_fft(windowed, magnitude)) {
      SAFE_FREE(samples);
      static_mutex_unlock(&fft_cache_mutex);
      return NULL;
    }
 
    for (unsigned int row = 0; row < spectrum_height; row++) {
      float top_fraction = (float)(spectrum_height - row - 1) / (float)spectrum_height;
      float bottom_fraction = (float)(spectrum_height - row) / (float)spectrum_height;
      float low_hz = 35.0f * powf(18000.0f / 35.0f, top_fraction);
      float high_hz = 35.0f * powf(18000.0f / 35.0f, bottom_fraction);
      size_t low_bin = (size_t)fmaxf(1.0f, floorf(low_hz * FFT_SIZE / AUDIO_VISUALIZATION_SAMPLE_RATE));
      size_t high_bin =
          (size_t)fmaxf((float)(low_bin + 1), ceilf(high_hz * FFT_SIZE / AUDIO_VISUALIZATION_SAMPLE_RATE));
      if (high_bin > FFT_SIZE / 2)
        high_bin = FFT_SIZE / 2;
      float power = 0.0f;
      size_t bins = 0;
      for (size_t bin = low_bin; bin < high_bin; bin++) {
        power += magnitude[bin] * magnitude[bin];
        bins++;
      }
      /* The default dB range leaves room for quiet speech while keeping loud music detailed. */
      float amplitude = bins ? sqrtf(power / (float)bins) : 0.0f;
      float intensity;
      if (scale.mode == FFT_SCALE_LINEAR)
        intensity = fminf(1.0f, amplitude * 4.0f);
      else if (scale.mode == FFT_SCALE_LOG)
        intensity = fminf(1.0f, log1pf(amplitude * 31.0f) / log1pf(31.0f));
      else {
        float db = 20.0f * log10f(fmaxf(amplitude, 0.00001f));
        intensity = fmaxf(0.0f, fminf(1.0f, (db - scale.min_db) / (scale.max_db - scale.min_db)));
      }
      int level = (int)lrintf(intensity * (float)(sizeof(levels) - 2));
      size_t cell = (size_t)row * width + x;
      cells[cell] = levels[level];
      float band_hz = sqrtf(low_hz * high_hz);
      visualization_color_for_level(band_hz, intensity, color_mode, &colors[cell * 3], &colors[cell * 3 + 1],
                                    &colors[cell * 3 + 2]);
    }
  }
 
  fft_cache.width = width;
  fft_cache.height = height;
  fft_cache.source = source;
  fft_cache.color_mode = color_mode;
  fft_cache.updated_ns = time_get_ns();
  fft_cache.valid = true;
  char *frame = visualization_encode(cells, colors, false, width, height, use_color, flip_x, flip_y);
  SAFE_FREE(samples);
  static_mutex_unlock(&fft_cache_mutex);
  return frame;
}