client_pipeline.h

Go to the documentation of this file.

 
#pragma once
 
#include <ascii-chat/audio/limits.h>
#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 <libplatform/atomic.h>
#endif
 
#include "../audio/mixer.h"
#include "../audio/processor.h"
#include <libplatform/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

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 channels;         
  int encoder_channels; 
  int sample_rate;
  uint64_t frame_duration_ms;
  int opus_bitrate;
  int opus_application;

  uint64_t echo_filter_ms;

  audio_processor_config_t processor;

  uint64_t jitter_margin_ms;

  client_audio_pipeline_flags_t flags;
} client_audio_pipeline_config_t;

client_audio_pipeline_config_t client_audio_pipeline_default_config(void);

client_audio_pipeline_config_t client_audio_pipeline_config_for_source(bool has_media_audio);

typedef struct {
  client_audio_pipeline_flags_t flags;

  void *echo_canceller;
  audio_processor_t *processor;
  SpeexPreprocessState *preprocess;

  JitterBuffer *jitter;
  uint32_t jitter_timestamp;
  int jitter_frame_span;

  OpusEncoder *encoder;
  OpusDecoder *decoder;

  client_audio_pipeline_config_t config;

  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