protocol_adapter.h File Reference

Go to the source code of this file.

Functions
asciichat_error_t	client_protocol_start (client_connection_t *connection)
bool	client_protocol_connection_lost (client_connection_t *connection)

Function Documentation

client_protocol_connection_lost()

bool client_protocol_connection_lost

(

client_connection_t *

connection

)

Definition at line 494 of file protocol_adapter.c.

                                                                      {
  return atomic_load_bool(&connection->data_thread_exited) || server_connection_is_lost(connection);
}

References client_connection::data_thread_exited, and server_connection_is_lost().

client_protocol_start()

asciichat_error_t client_protocol_start

(

client_connection_t *

connection

)

Definition at line 361 of file protocol_adapter.c.

                                                                         {
  log_warn("[FRAME_RECV_INIT] 🟢 PROTOCOL_START: Starting client protocol initialization");
 
  // The server can send Opus audio as soon as streaming starts. Initialize the
  // decoder before either transport's receive worker can dispatch those packets.
  asciichat_error_t audio_result = audio_connection_init(connection);
  if (audio_result != ASCIICHAT_OK)
    return audio_result;
  if (client_connection_checkpoint("audio-pipeline") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  acip_client_callbacks_t control = g_acip_client_callbacks;
  control.app_ctx = connection;
  session_protocol_init(&connection->protocol, server_connection_get_transport(connection),
                        (session_protocol_media_t){.terminal_output = true,
                                                   .on_frame = client_present_frame,
                                                   .on_samples = client_play_samples,
                                                   .decode_opus = client_decode_opus,
                                                   .on_audio_packet = client_track_audio,
                                                   .context = connection,
                                                   .frame_workspace = &connection->decoded_ascii_workspace},
                        control);
 
  // Reset display state for new connection
  display_reset_for_new_connection(connection);
 
  // Start receiving before the capability/settings exchange. The server may
  // reply to the initial settings packet immediately, and that reply must not
  // wait for the worker that dispatches it.
  atomic_store_bool(&connection->data_thread_exited, false);
  if (thread_pool_spawn(connection->client_worker_pool, data_reception_thread_func, connection, 1, "data_reception") !=
      ASCIICHAT_OK) {
    log_error("[FRAME_RECV_INIT] Failed to start data reception thread");
    LOG_ERRNO_IF_SET("Data reception thread creation failed");
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
  }
 
  if (client_connection_checkpoint("receive") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  // Send CLIENT_CAPABILITIES packet (after crypto is ready for both TCP and WS)
  // Server expects this as the first packet after crypto handshake
  log_debug("[FRAME_RECV_INIT] Sending CLIENT_CAPABILITIES (terminal size)");
  asciichat_error_t cap_result =
      threaded_send_terminal_size_with_auto_detect(connection, (int)terminal_get_effective_width(GET_OPTION(width), 80),
                                                   (int)terminal_get_effective_height(GET_OPTION(height), 24));
  if (cap_result != ASCIICHAT_OK) {
    log_error("[FRAME_RECV_INIT] Failed to send terminal size capabilities");
    return client_startup_peer_error(connection, cap_result);
  }
 
  // Capabilities establish the viewer geometry, but renderer preferences are
  // carried by SETTINGS_SYNC. Send them before STREAM_START so the server
  // cannot render the first frames from its zero-initialized (luminance)
  // fallback while the asynchronous settings update is still in flight.
  options_snapshot_t initial_settings;
  if (options_read_snapshot(&initial_settings) != ASCIICHAT_OK)
    return client_startup_peer_error(connection, ERROR_CONFIG);
  asciichat_error_t settings_result =
      acip_settings_send(server_connection_get_transport(connection), &initial_settings.values, 1, UINT32_MAX);
  if (settings_result != ASCIICHAT_OK) {
    log_error("[FRAME_RECV_INIT] Failed to send initial rendering settings");
    return client_startup_peer_error(connection, settings_result);
  }
 
  // Send STREAM_START packet with combined stream types
  uint32_t stream_types = STREAM_TYPE_VIDEO; // Always have video
  if (GET_OPTION(audio_enabled)) {
    stream_types |= STREAM_TYPE_AUDIO; // Add audio if enabled
  }
  log_debug("[FRAME_RECV_INIT] Sending STREAM_START: types=0x%x (video%s)", stream_types,
            (stream_types & STREAM_TYPE_AUDIO) ? "+audio" : "");
  asciichat_error_t stream_result = threaded_send_stream_start_packet(connection, stream_types);
  if (stream_result != ASCIICHAT_OK) {
    log_error("[FRAME_RECV_INIT] Failed to send stream start");
    return client_startup_peer_error(connection, stream_result);
  }
 
  // Start webcam capture thread
  log_debug("Starting webcam capture thread...");
  if (capture_start_thread(connection) != 0) {
    log_error("Failed to start webcam capture thread");
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
  }
  log_debug("Webcam capture thread started successfully");
  if (client_connection_checkpoint("capture") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  // Start local media audio only after the connection succeeds. Starting the
  // worker during client initialization would consume file audio while dialing.
  audio_context_t *audio_context = connection->audio_context;
  if (audio_context && audio_context->initialized) {
    session_capture_set_audio_context(connection->capture_context, audio_context);
    audio_context->capture_media_source = session_capture_get_media_source(connection->capture_context);
    if (audio_start_duplex(audio_context) != ASCIICHAT_OK) {
      log_error("Failed to start full-duplex audio");
      return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
    }
  }
 
  if (client_connection_checkpoint("audio-duplex") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  // Initialize audio sender thread BEFORE starting audio capture
  // This ensures sender is ready when capture thread starts queueing packets
  // Must happen after connection succeeds to prevent deadlock if connection fails
  if (audio_sender_init(connection) != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  // Start audio capture thread if audio is enabled
  log_debug("Starting audio capture thread...");
  if (audio_start_thread(connection) != 0) {
    log_error("Failed to start audio capture thread");
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
  }
  log_debug("Audio capture thread started successfully (or skipped if audio disabled)");
 
  if (client_connection_checkpoint("audio-capture") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
 
  // Start keepalive/ping thread to prevent server timeout
  log_debug("Starting keepalive/ping thread...");
  if (keepalive_start_thread(connection) != 0) {
    log_error("Failed to start keepalive/ping thread");
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
  }
  log_debug("Keepalive/ping thread started successfully");
 
  if (client_connection_checkpoint("keepalive") != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_THREAD, "Could not start client protocol workers");
  return ASCIICHAT_OK;
}

References acip_settings_send(), acip_client_callbacks_t::app_ctx, ASCIICHAT_OK, audio_connection_init(), client_connection::audio_context, audio_sender_init(), audio_start_duplex(), audio_start_thread(), client_connection::capture_context, audio_context_t::capture_media_source, capture_start_thread(), client_connection_checkpoint(), client_connection::client_worker_pool, client_connection::data_thread_exited, client_connection::decoded_ascii_workspace, display_reset_for_new_connection(), ERROR_CONFIG, ERROR_THREAD, GET_OPTION, height, audio_context_t::initialized, keepalive_start_thread(), log_debug, LOG_ERRNO_IF_SET, log_error, log_warn, options_read_snapshot(), client_connection::protocol, server_connection_get_transport(), session_capture_get_media_source(), session_capture_set_audio_context(), session_protocol_init(), SET_ERRNO, STREAM_TYPE_AUDIO, STREAM_TYPE_VIDEO, thread_pool_spawn(), threaded_send_stream_start_packet(), threaded_send_terminal_size_with_auto_detect(), options_snapshot_t::values, and width.

Referenced by client_connection_start().