include/ascii-chat/audio/audio.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <ascii-chat/atomic.h>
#include <portaudio.h>
#ifdef __linux__
#include <sched.h>
#include <sys/resource.h>
#elif defined(__APPLE__)
#include <mach/mach.h>
#include <mach/thread_policy.h>
#include <mach/kern_return.h>
#endif
 
#include "../common.h"
#include "../platform/thread.h"
#include "../platform/mutex.h"
#include "../platform/cond.h"
#include "../ringbuffer.h"
#include "../options/options.h"
 
/* ============================================================================
 * Audio Configuration Constants
 * ============================================================================
 */
 
#define AUDIO_SAMPLE_RATE 48000
#define AUDIO_FRAMES_PER_BUFFER 480
#define AUDIO_CHANNELS 1
#define AUDIO_BUFFER_SIZE (AUDIO_FRAMES_PER_BUFFER * AUDIO_CHANNELS)
 
/* ============================================================================
 * Data Structures
 * ============================================================================
 */
 
typedef struct {
  // PortAudio streams
  PaStream *duplex_stream; 
  PaStream *input_stream;  
  PaStream *output_stream; 
 
  // New architecture: 5 ring buffers for lock-free callback → worker → network
  audio_ring_buffer_t *raw_capture_rb;        
  audio_ring_buffer_t *raw_render_rb;         
  audio_ring_buffer_t *processed_playback_rb; 
 
  // Legacy ring buffers (will be migrated to new architecture)
  audio_ring_buffer_t *capture_buffer;  
  audio_ring_buffer_t *playback_buffer; 
  audio_ring_buffer_t *render_buffer;   
 
  // Worker thread for heavy processing (AEC3, filters)
  asciichat_thread_t worker_thread; 
  mutex_t worker_mutex;             
  cond_t worker_cond;               
  bool worker_running;              
  atomic_t worker_should_stop;      
 
  // Pre-allocated worker buffers (avoid malloc in worker loop)
  float *worker_capture_batch;  
  float *worker_render_batch;   
  float *worker_playback_batch; 
 
  // State flags
  bool initialized;       
  bool running;           
  bool separate_streams;  
  bool playback_only;     
  atomic_t shutting_down; 
  mutex_t state_mutex;    
 
  // Audio pipeline and device info
  void *audio_pipeline;       
  bool monitor_local_media;   
  void *capture_media_source; 
  double sample_rate;         
  double input_device_rate;   
  double output_device_rate;  
  double input_resample_phase; 
  float input_resample_previous; 
  bool input_resample_has_previous; 
  double output_resample_phase; 
  float output_resample_previous; 
  bool output_resample_has_previous; 
} audio_context_t;
 
/* ============================================================================
 * Audio Context Lifecycle
 * @{
 */
 
asciichat_error_t audio_init(audio_context_t *ctx);
 
void audio_destroy(audio_context_t *ctx);
 
void audio_terminate_portaudio_final(void);
 
void audio_set_pipeline(audio_context_t *ctx, void *pipeline);
 
/* ============================================================================
 * Full-Duplex Audio Control
 * @{
 */
 
asciichat_error_t audio_start_duplex(audio_context_t *ctx);
 
asciichat_error_t audio_stop_duplex(audio_context_t *ctx);
 
/* ============================================================================
 * Audio I/O Operations
 * @{
 */
 
asciichat_error_t audio_read_samples(audio_context_t *ctx, float *buffer, int num_samples);
 
asciichat_error_t audio_write_samples(audio_context_t *ctx, const float *buffer, int num_samples);
 
/* ============================================================================
 * Real-Time Priority Scheduling
 * @{
 */
 
asciichat_error_t audio_set_realtime_priority(void);
 
/* ============================================================================
 * Audio Device Enumeration
 * @{
 */
 
#define AUDIO_DEVICE_NAME_MAX 256
 
typedef struct {
  int index;                        
  char name[AUDIO_DEVICE_NAME_MAX]; 
  int max_input_channels;           
  int max_output_channels;          
  double default_sample_rate;       
  bool is_default_input;            
  bool is_default_output;           
} audio_device_info_t;
 
asciichat_error_t audio_list_input_devices(audio_device_info_t **out_devices, unsigned int *out_count);
 
asciichat_error_t audio_list_output_devices(audio_device_info_t **out_devices, unsigned int *out_count);
 
void audio_free_device_list(audio_device_info_t *devices);
 
/* ============================================================================
 * Protocol Helper Functions - Audio Format Conversion
 * @{
 */
 
asciichat_error_t audio_dequantize_samples(const uint8_t *samples_ptr, uint32_t total_samples, float *out_samples);
 
/* ============================================================================
 * Audio Ring Buffer Management
 * @{
 */
 
audio_ring_buffer_t *audio_ring_buffer_create(void);
 
audio_ring_buffer_t *audio_ring_buffer_create_for_capture(void);
 
void audio_ring_buffer_destroy(audio_ring_buffer_t *rb);
 
void audio_ring_buffer_register_atomics(audio_ring_buffer_t *rb, const char *context_name);
 
void audio_ring_buffer_unregister_atomics(audio_ring_buffer_t *rb);
 
void audio_ring_buffer_clear(audio_ring_buffer_t *rb);
ASCIICHAT_API void audio_ring_buffer_discard_pending(audio_ring_buffer_t *rb);
 
asciichat_error_t audio_ring_buffer_write(audio_ring_buffer_t *rb, const float *data, int samples);
 
size_t audio_ring_buffer_read(audio_ring_buffer_t *rb, float *data, size_t samples);
 
size_t audio_ring_buffer_peek(audio_ring_buffer_t *rb, float *data, size_t samples);
 
size_t audio_ring_buffer_available_read(audio_ring_buffer_t *rb);
 
size_t audio_ring_buffer_available_write(audio_ring_buffer_t *rb);
 
/* ============================================================================
 * Audio Resampling Utilities
 * @{
 */
 
void resample_linear(const float *src, size_t src_samples, float *dst, size_t dst_samples, double src_rate,
                     double dst_rate);
 
/* ============================================================================
 * Audio Batch Packet Format
 * @{
 */
 
typedef struct {
  uint32_t batch_count;   
  uint32_t total_samples; 
  uint32_t sample_rate;   
  uint32_t channels;      
} audio_batch_info_t;
 
asciichat_error_t audio_parse_batch_header(const void *data, size_t len, audio_batch_info_t *out_batch);
 
asciichat_error_t audio_validate_batch_params(const audio_batch_info_t *batch);
 
bool audio_is_supported_sample_rate(uint32_t sample_rate);
 
void audio_flush_playback_buffers(audio_context_t *ctx);
 
bool audio_should_enable_microphone(audio_capture_source_t source, bool has_media_audio);