include/ascii-chat/network/client.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
 
#include <ascii-chat/atomic.h>
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/network/packet/queue.h>
#include <ascii-chat/network/acip/transport.h>  // For acip_transport_t
#include <ascii-chat/network/connection_handle.h>
#include <ascii-chat/crypto/handshake/common.h> // For crypto_handshake_context_t (complete type needed for field)
#include <ascii-chat/ringbuffer.h>
#include <ascii-chat/video/rgba/video_frame.h>
#include <ascii-chat/platform/terminal.h>
#include <ascii-chat/platform/thread.h> // For thread_id_t
#include <ascii-chat/video/ascii/palette.h>
#include <ascii-chat/video/anim/digital_rain.h>
#include <ascii-chat/audio/audio.h>
 
typedef enum {
  PARTICIPANT_TYPE_NETWORK, // Remote participant via socket/transport
  PARTICIPANT_TYPE_MEMORY   // Local host participant (direct memory access)
} participant_type_t;
 
typedef struct client_info {
  participant_type_t participant_type; // Network (socket) or memory (direct injection)
  socket_t socket;
  bool is_tcp_client;                // True for TCP clients, false for WebRTC (for cleanup logic)
  acip_transport_t *transport;       // ACIP transport for protocol-agnostic packet sending
  asciichat_thread_t receive_thread; // Thread for receiving client data
  asciichat_thread_t send_thread;    // Thread for sending data to client
  thread_id_t send_thread_id;        // Thread ID of send thread (for self-join detection)
  thread_id_t receive_thread_id;     // Thread ID of receive thread (for self-join detection)
  void *server_ctx;                  // Pointer to server_context_t (avoid circular includes)
  char client_id[MAX_CLIENT_ID_LEN]; // String-based client ID: "noun.N (transport:port)"
  uint32_t session_client_id;        // Session host client ID (0 if not registered)
  char display_name[MAX_DISPLAY_NAME_LEN];
  char client_ip[INET_ADDRSTRLEN];
  int port;
 
  // Media capabilities
  bool can_send_video;
  bool can_send_audio;
  bool wants_stretch;           // Client wants stretched output (ignore aspect ratio)
  atomic_t is_sending_video; // Thread-safe video stream state
  atomic_t is_sending_audio; // Thread-safe audio stream state
 
  // Codec capabilities (from CLIENT_CAPABILITIES packet)
  uint32_t codec_capabilities_video; // VIDEO_CODEC_CAP_* bitmask
  uint32_t codec_capabilities_audio; // AUDIO_CODEC_CAP_* bitmask
 
  // Opus codec for audio compression/decompression
  void *opus_decoder; // opus_codec_t* - Opus decoder for this client's audio
 
  // H.265 decoder (persistent across frames for proper video decoding)
  void *h265_decoder_ctx; // AVCodecContext* - H.265 HEVC decoder for this client
  void *h265_decode_frame; // AVFrame* - Persistent frame for H.265 decoding
  void *h265_rgb_frame;    // AVFrame* - RGB frame for color space conversion
  void *h265_sws_ctx;      // SwsContext* - Color space converter for YUV->RGB
 
  // Terminal capabilities (for rendering appropriate ASCII frames)
  terminal_capabilities_t terminal_caps;
  bool has_terminal_caps; // Whether we've received terminal capabilities from this client
 
  // Per-client palette cache
  char client_palette_chars[256];     // Client's palette characters
  size_t client_palette_len;          // Length of client's palette
  char client_luminance_palette[256]; // Client's luminance-to-character mapping
  palette_type_t client_palette_type; // Client's palette type
  bool client_palette_initialized;    // Whether client's palette is set up
 
  // Per-client state for Matrix Rain post-processing of generated ASCII.
  digital_rain_t *digital_rain;
  double digital_rain_last_update_time;
 
  // Stream dimensions
  uint16_t width, height;
 
  // Statistics
  atomic_t active;
  atomic_t shutting_down;                 // Set when client is being removed
  atomic_t protocol_disconnect_requested; // Set when protocol violation requires disconnect
  time_t connected_at;
  uint64_t frames_sent;
  uint64_t frames_received;          // Track incoming frames from this client
  uint32_t frames_received_logged;   // Track for periodic logging (thread-safe via client_state_mutex)
  uint64_t video_receive_rate_window_ns;
  uint32_t video_receive_rate_window_frames;
  uint32_t last_received_frame_hash; // Hash of last frame received from this client
 
  // Buffers for incoming media (individual per client)
  video_frame_buffer_t *incoming_video_buffer; // Modern double-buffered video frame
  audio_ring_buffer_t *incoming_audio_buffer;  // Buffer for this client's audio
 
  // Professional double-buffer system for outgoing frames
  video_frame_buffer_t *outgoing_video_buffer; // Double buffer for ASCII frames to send
 
  // Packet queue for audio only (video uses double buffer now)
  packet_queue_t *audio_queue; // Queue for audio packets to send to this client
 
  // Async dispatch: queue for received packets (async processing)
  packet_queue_t *received_packet_queue; // Queue of complete received packets waiting for dispatch
  asciichat_thread_t dispatch_thread;    // Async dispatch thread processes queued packets
  atomic_t dispatch_thread_running;   // Flag to signal dispatch thread to exit
  cond_t dispatch_queue_cond;            // Condition variable to wake dispatch thread when packets arrive
 
  // Dedicated send thread for this client
  atomic_t send_thread_running;
 
  // Per-client grid tracking for CLEAR_CONSOLE logic
  atomic_t last_rendered_grid_sources; // Render thread: source count in buffered frame
  atomic_t last_sent_grid_sources;     // Send thread: source count in last sent frame
 
  // Frame statistics for debugging
  atomic_t frames_sent_count; // Total ASCII frames sent to this client
 
  // Pre-allocated buffers to avoid malloc/free in send thread (prevents buffer pool contention)
  void *send_buffer;
  size_t send_buffer_size;
  void *crypto_plaintext_buffer; // For encryption plaintext (frame + header)
  size_t crypto_plaintext_size;
  void *crypto_ciphertext_buffer; // For encryption ciphertext (encrypted result)
  size_t crypto_ciphertext_size;
 
  // Per-client rendering threads
  asciichat_thread_t video_render_thread;
  asciichat_thread_t audio_render_thread;
  atomic_t video_render_thread_running;
  atomic_t audio_render_thread_running;
 
  // Per-client synchronization
  mutex_t client_state_mutex;
  mutex_t send_mutex; // Protects socket writes (prevents concurrent send race)
 
  // Per-client crypto context for secure communication
  crypto_handshake_context_t crypto_handshake_ctx;
  bool crypto_initialized;
  bool transport_encrypted; 
  bool encrypt_data; // Whether payload encryption is enabled (false = auth-only mode)
 
  // Pending packet storage for --no-encrypt mode
  // When client uses --no-encrypt, the first packet (e.g., CLIENT_JOIN) arrives
  // during crypto handshake attempt. We store it here so the caller can process it.
  packet_type_t pending_packet_type;
  void *pending_packet_payload;
  size_t pending_packet_length;
 
  // uthash handle for hash table operations
  UT_hash_handle hh;
} client_info_t;
 
/* ============================================================================
 * Client-Side Application State (replaces tcp_client_t mixed concerns)
 * ============================================================================ */
 
typedef struct {
  uint8_t data[4096];       
  size_t size;              
  uint16_t frame_sizes[48]; 
  int frame_count;          
} app_client_audio_packet_t;
 
#define APP_CLIENT_AUDIO_QUEUE_SIZE 256
 
typedef struct app_client {
  /* ========================================================================
   * Active Transport & Network Client
   * ======================================================================== */
 
  connection_handle_t connection;
 
  /* ========================================================================
   * Audio State
   * ======================================================================== */
 
  audio_context_t audio_ctx;
  app_client_audio_packet_t audio_send_queue[APP_CLIENT_AUDIO_QUEUE_SIZE];
  int audio_send_queue_head;
  int audio_send_queue_tail;
  mutex_t audio_send_queue_mutex;
  cond_t audio_send_queue_cond;
  bool audio_send_queue_initialized;
  atomic_t audio_sender_should_exit;
  asciichat_thread_t audio_capture_thread;
  asciichat_thread_t audio_sender_thread;
  bool audio_capture_thread_created;
  bool audio_sender_thread_created;
  atomic_t audio_capture_thread_exited;
 
  /* ========================================================================
   * Protocol State
   * ======================================================================== */
 
  asciichat_thread_t data_reception_thread;
  bool data_thread_created;
  atomic_t data_thread_exited;
  uint32_t last_active_count;
  bool server_state_initialized;
  bool should_clear_before_next_frame;
  uint32_t my_client_id;
  bool encryption_enabled;
 
  /* ========================================================================
   * Capture State
   * ======================================================================== */
 
  asciichat_thread_t capture_thread;
  bool capture_thread_created;
  atomic_t capture_thread_exited;
 
  /* ========================================================================
   * Keepalive State
   * ======================================================================== */
 
  asciichat_thread_t ping_thread;
  bool ping_thread_created;
  atomic_t ping_thread_exited;
 
  /* ========================================================================
   * Display State
   * ======================================================================== */
 
  bool has_tty;
  atomic_t is_first_frame_of_connection;
  tty_info_t tty_info;
 
  /* ========================================================================
   * Crypto State
   * ======================================================================== */
 
  crypto_handshake_context_t crypto_ctx;
  bool crypto_initialized;
 
} app_client_t;
 
app_client_t *app_client_create(void);
 
void app_client_destroy(app_client_t **client_ptr);