client_pipeline.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
// C11 stdatomic.h conflicts with MSVC's C++ <atomic> header on Windows.
// When compiling C++ with MSVC runtime headers (even with Clang), we must not
// include stdatomic.h as the MSVC <atomic> header already provides the same
// functionality and the declarations conflict.
#if defined(__cplusplus) && defined(_WIN32)
// C++ mode on Windows: use <atomic> from MSVC runtime
#include <atomic>
#else
#include <ascii-chat/atomic.h>
#endif
 
#include "../audio/mixer.h"
#include "../platform/mutex.h"
 
// Forward declarations for SpeexDSP types
typedef struct SpeexPreprocessState_ SpeexPreprocessState;
typedef struct JitterBuffer_ JitterBuffer;
 
// Forward declarations for WebRTC types (opaque pointers for C compatibility)
typedef struct webrtc_EchoCanceller3 webrtc_EchoCanceller3;
 
// Forward declarations for Opus types
typedef struct OpusEncoder OpusEncoder;
typedef struct OpusDecoder OpusDecoder;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CLIENT_AUDIO_PIPELINE_SAMPLE_RATE 48000
 
#define CLIENT_AUDIO_PIPELINE_FRAME_MS 20
 
#define CLIENT_AUDIO_PIPELINE_FRAME_SIZE (CLIENT_AUDIO_PIPELINE_SAMPLE_RATE * CLIENT_AUDIO_PIPELINE_FRAME_MS / 1000)
 
#define CLIENT_AUDIO_PIPELINE_ECHO_REF_SIZE (CLIENT_AUDIO_PIPELINE_SAMPLE_RATE / 2)
 
#define CLIENT_AUDIO_PIPELINE_MAX_OPUS_PACKET 4000
 
typedef struct {
  bool echo_cancel;
  bool noise_suppress;
  bool agc;
  bool vad;
  bool jitter_buffer;
  bool compressor;
  bool noise_gate;
  bool highpass;
  bool lowpass;
} client_audio_pipeline_flags_t;
 
#define CLIENT_AUDIO_PIPELINE_FLAGS_ALL                                                                                \
  ((client_audio_pipeline_flags_t){                                                                                    \
      .echo_cancel = true,                                                                                             \
      .noise_suppress = true,                                                                                          \
      .agc = true,                                                                                                     \
      .vad = true,                                                                                                     \
      .jitter_buffer = true,                                                                                           \
      .compressor = true,                                                                                              \
      .noise_gate = true,                                                                                              \
      .highpass = true,                                                                                                \
      .lowpass = true,                                                                                                 \
  })
 
#define CLIENT_AUDIO_PIPELINE_FLAGS_MINIMAL                                                                            \
  ((client_audio_pipeline_flags_t){                                                                                    \
      .echo_cancel = false,                                                                                            \
      .noise_suppress = false,                                                                                         \
      .agc = false,                                                                                                    \
      .vad = false,                                                                                                    \
      .jitter_buffer = false,                                                                                          \
      .compressor = false,                                                                                             \
      .noise_gate = false,                                                                                             \
      .highpass = false,                                                                                               \
      .lowpass = false,                                                                                                \
  })
 
typedef struct {
  int sample_rate;
  uint64_t frame_size_ns;
  int opus_bitrate;
 
  uint64_t echo_filter_ns;
 
  int noise_suppress_db;
  int agc_level;
  int agc_max_gain;
 
  uint64_t jitter_margin_ns;
 
  float highpass_hz;
  float lowpass_hz;
 
  float comp_threshold_db;
  float comp_ratio;
  uint64_t comp_attack_ns;
  uint64_t comp_release_ns;
  float comp_makeup_db;
 
  float gate_threshold;
  uint64_t gate_attack_ns;
  uint64_t gate_release_ns;
  float gate_hysteresis;
 
  client_audio_pipeline_flags_t flags;
} client_audio_pipeline_config_t;
 
client_audio_pipeline_config_t client_audio_pipeline_default_config(void);
 
typedef struct {
  client_audio_pipeline_flags_t flags;
 
  void *echo_canceller;
  SpeexPreprocessState *preprocess;
 
  JitterBuffer *jitter;
  uint32_t jitter_timestamp;
  int jitter_frame_span;
 
  OpusEncoder *encoder;
  OpusDecoder *decoder;
 
  compressor_t compressor;
  noise_gate_t noise_gate;
  noise_gate_t playback_noise_gate;
  highpass_filter_t highpass;
  lowpass_filter_t lowpass;
 
  client_audio_pipeline_config_t config;
 
  float agc_current_gain;
 
  int frame_size;
 
  int16_t *work_i16;
  int16_t *echo_i16;
  float *work_float;
 
  // No mutex needed - full-duplex means single callback thread handles all AEC3
 
  bool initialized;
 
  int capture_fadein_remaining;
 
  void *debug_wav_aec3_in;  // Microphone input before AEC3
  void *debug_wav_aec3_out; // Microphone output after AEC3
 
  void *aec3_render_buffer;  // Persistent render AudioBuffer
  void *aec3_capture_buffer; // Persistent capture AudioBuffer
} client_audio_pipeline_t;
 
client_audio_pipeline_t *client_audio_pipeline_create(const client_audio_pipeline_config_t *config);
 
void client_audio_pipeline_destroy(client_audio_pipeline_t *pipeline);
 
void client_audio_pipeline_set_flags(client_audio_pipeline_t *pipeline, client_audio_pipeline_flags_t flags);
 
client_audio_pipeline_flags_t client_audio_pipeline_get_flags(client_audio_pipeline_t *pipeline);
 
int client_audio_pipeline_capture(client_audio_pipeline_t *pipeline, const float *input, int num_samples,
                                  uint8_t *opus_out, int opus_out_size);
 
int client_audio_pipeline_playback(client_audio_pipeline_t *pipeline, const uint8_t *opus_in, int opus_len,
                                   float *output, int max_samples);
 
int client_audio_pipeline_get_playback_frame(client_audio_pipeline_t *pipeline, float *output, int num_samples);
 
void client_audio_pipeline_process_duplex(client_audio_pipeline_t *pipeline, const float *render_samples,
                                          int render_count, const float *capture_samples, int capture_count,
                                          float *processed_output);
 
int client_audio_pipeline_jitter_margin(client_audio_pipeline_t *pipeline);
 
bool client_audio_pipeline_voice_detected(client_audio_pipeline_t *pipeline);
 
void client_audio_pipeline_reset(client_audio_pipeline_t *pipeline);
 
#ifdef __cplusplus
}
#endif