participant.c File Reference

👤 Client-side session participation implementation More...

Go to the source code of this file.

Data Structures
struct	session_participant
	Internal session participant structure. More...

Typedefs
typedef struct session_participant	session_participant_t
	Internal session participant structure.

Functions
session_participant_t *	session_participant_create (const session_participant_config_t *config)
void	session_participant_destroy (session_participant_t *p)
asciichat_error_t	session_participant_connect (session_participant_t *p)
void	session_participant_disconnect (session_participant_t *p)
bool	session_participant_is_connected (session_participant_t *p)
uint32_t	session_participant_get_client_id (session_participant_t *p)
socket_t	session_participant_get_socket (session_participant_t *p)
asciichat_error_t	session_participant_start_video (session_participant_t *p)
void	session_participant_stop_video (session_participant_t *p)
bool	session_participant_is_video_active (session_participant_t *p)
asciichat_error_t	session_participant_start_audio (session_participant_t *p)
void	session_participant_stop_audio (session_participant_t *p)
bool	session_participant_is_audio_active (session_participant_t *p)
asciichat_error_t	session_participant_get_settings (session_participant_t *p, session_settings_t *settings)
asciichat_error_t	session_participant_request_settings (session_participant_t *p, const session_settings_t *settings)
asciichat_error_t	session_participant_start_video_capture (session_participant_t *p)
void	session_participant_stop_video_capture (session_participant_t *p)
asciichat_error_t	session_participant_start_audio_capture (session_participant_t *p)
void	session_participant_stop_audio_capture (session_participant_t *p)
asciichat_error_t	session_participant_set_transport (session_participant_t *p, acip_transport_t *transport)
acip_transport_t *	session_participant_get_transport (session_participant_t *p)
bool	session_participant_has_transport (session_participant_t *p)

Detailed Description

👤 Client-side session participation implementation

Implements the session participant abstraction for client-side connection management and media streaming.

NOTE: This is a stub implementation that provides the API structure. Full implementation will integrate with existing client code in a future phase.

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

January 2026

Definition in file participant.c.

Typedef Documentation

session_participant_t

typedef struct session_participant session_participant_t

Internal session participant structure.

Contains connection state, media stream state, and callback configuration.

Function Documentation

session_participant_connect()

asciichat_error_t session_participant_connect

(

session_participant_t *

p

)

Definition at line 272 of file participant.c.

                                                                        {
  log_debug("session_participant_connect: enter - p=%p", p);
 
  if (!p || !p->initialized) {
    log_debug("session_participant_connect: invalid param or not initialized");
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_connect: invalid participant");
  }
 
  log_debug("session_participant_connect: p->initialized=%d, p->connected=%d", p->initialized, p->connected);
 
  if (p->connected) {
    log_debug("session_participant_connect: already connected, returning OK");
    return ASCIICHAT_OK; // Already connected
  }
 
  // Create TCP connection to server
  log_debug("session_participant_connect: calling connect_to_server(%s, %d)", p->address, p->port);
  p->socket = connect_to_server(p->address, p->port);
  log_debug("session_participant_connect: connect_to_server returned socket=%d (INVALID=%d)", p->socket,
            INVALID_SOCKET_VALUE);
 
  if (p->socket == INVALID_SOCKET_VALUE) {
    log_error("Failed to connect to server at %s:%d", p->address, p->port);
    if (p->callbacks.on_error) {
      p->callbacks.on_error(p, ERROR_NETWORK_CONNECT, "Failed to connect to server", p->user_data);
    }
    return GET_ERRNO();
  }
 
  log_debug("session_participant_connect: setting p->connected=true");
  p->connected = true;
  p->client_id = 0; // Will be assigned by server
 
  log_info("Connected to server at %s:%d (socket=%d)", p->address, p->port, p->socket);
  log_debug("session_participant_connect: p->connected=%d after setting", p->connected);
 
  // Invoke callback
  if (p->callbacks.on_connected) {
    p->callbacks.on_connected(p, p->client_id, p->user_data);
  }
 
  log_debug("session_participant_connect: returning ASCIICHAT_OK");
  return ASCIICHAT_OK;
}

References session_participant::address, session_participant::callbacks, session_participant::client_id, session_participant::connected, session_participant::initialized, session_participant::port, session_participant::socket, and session_participant::user_data.

Referenced by discovery_session_connect_to_future_host(), and discovery_session_process().

session_participant_create()

session_participant_t * session_participant_create

(

const session_participant_config_t *

config

)

Definition at line 121 of file participant.c.

                                                                                              {
  log_info("session_participant_create: START - config=%p", config);
 
  if (!config) {
    log_error("session_participant_create: config is NULL");
    SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_create: NULL config");
    return NULL;
  }
 
  // Allocate participant
  session_participant_t *p = SAFE_CALLOC(1, sizeof(session_participant_t), session_participant_t *);
  log_info("session_participant_create: allocated p=%p", p);
 
  // Copy configuration
  if (config->address) {
    SAFE_STRNCPY(p->address, config->address, sizeof(p->address));
  } else {
    SAFE_STRNCPY(p->address, "127.0.0.1", sizeof(p->address));
  }
 
  p->port = config->port > 0 ? config->port : OPT_PORT_INT_DEFAULT;
  p->encryption_enabled = config->encryption_enabled;
 
  log_info("session_participant_create: address=%s, port=%d", p->address, p->port);
 
  if (config->password) {
    SAFE_STRNCPY(p->password, config->password, sizeof(p->password));
  }
 
  if (config->server_key) {
    SAFE_STRNCPY(p->server_key, config->server_key, sizeof(p->server_key));
  }
 
  p->enable_audio = config->enable_audio;
  p->enable_video = config->enable_video;
  p->callbacks = config->callbacks;
  p->user_data = config->user_data;
 
  // Initialize socket to invalid
  p->socket = INVALID_SOCKET_VALUE;
  p->transport = NULL; // No alternative transport initially
  p->connected = false;
  p->client_id = 0;
  p->video_active = false;
  p->audio_active = false;
 
  // Initialize settings
  session_settings_init(&p->settings);
 
  p->initialized = true;
  log_info("session_participant_create: DONE - returning p=%p (initialized=%d, connected=%d)", p, p->initialized,
           p->connected);
  return p;
}

References session_participant::address, session_participant::audio_active, session_participant::callbacks, session_participant::client_id, session_participant::connected, session_participant::enable_audio, session_participant::enable_video, session_participant::encryption_enabled, session_participant::initialized, session_participant::password, session_participant::port, session_participant::server_key, session_settings_init(), session_participant::settings, session_participant::socket, session_participant::transport, session_participant::user_data, and session_participant::video_active.

Referenced by discovery_session_connect_to_future_host(), and discovery_session_process().

session_participant_destroy()

void session_participant_destroy

(

session_participant_t *

p

)

Definition at line 176 of file participant.c.

                                                           {
  if (!p) {
    return;
  }
 
  // Disconnect if connected
  if (p->connected) {
    session_participant_disconnect(p);
  }
 
  // Stop capture threads if running
  if (p->video_capture_running) {
    session_participant_stop_video_capture(p);
  }
  if (p->audio_capture_running) {
    session_participant_stop_audio_capture(p);
  }
 
  // Clean up media capture contexts
  if (p->video_capture) {
    session_capture_destroy(p->video_capture);
    p->video_capture = NULL;
  }
  if (p->audio_capture) {
    session_audio_destroy(p->audio_capture);
    p->audio_capture = NULL;
  }
  if (p->opus_encoder) {
    opus_codec_destroy(p->opus_encoder);
    p->opus_encoder = NULL;
  }
 
  // Close socket if open
  if (p->socket != INVALID_SOCKET_VALUE) {
    socket_close(p->socket);
    p->socket = INVALID_SOCKET_VALUE;
  }
 
  // Clear sensitive data
  memset(p->password, 0, sizeof(p->password));
  memset(p->server_key, 0, sizeof(p->server_key));
 
  p->initialized = false;
  SAFE_FREE(p);
}

References session_participant::audio_capture, session_participant::audio_capture_running, session_participant::connected, session_participant::initialized, opus_codec_destroy(), session_participant::opus_encoder, session_participant::password, session_participant::server_key, session_audio_destroy(), session_capture_destroy(), session_participant_disconnect(), session_participant_stop_audio_capture(), session_participant_stop_video_capture(), session_participant::socket, session_participant::video_capture, and session_participant::video_capture_running.

Referenced by discovery_session_connect_to_future_host(), and discovery_session_destroy().

session_participant_disconnect()

void session_participant_disconnect

(

session_participant_t *

p

)

Definition at line 317 of file participant.c.

                                                              {
  if (!p || !p->initialized) {
    return;
  }
 
  if (!p->connected) {
    return;
  }
 
  // Stop media streams
  if (p->video_active) {
    session_participant_stop_video(p);
  }
  if (p->audio_active) {
    session_participant_stop_audio(p);
  }
 
  // Close socket
  if (p->socket != INVALID_SOCKET_VALUE) {
    socket_close(p->socket);
    p->socket = INVALID_SOCKET_VALUE;
  }
 
  p->connected = false;
  p->client_id = 0;
 
  // Invoke callback
  if (p->callbacks.on_disconnected) {
    p->callbacks.on_disconnected(p, p->user_data);
  }
}

References session_participant::audio_active, session_participant::callbacks, session_participant::client_id, session_participant::connected, session_participant::initialized, session_participant_stop_audio(), session_participant_stop_video(), session_participant::socket, session_participant::user_data, and session_participant::video_active.

Referenced by discovery_session_process(), and session_participant_destroy().

session_participant_get_client_id()

uint32_t session_participant_get_client_id

(

session_participant_t *

p

)

Definition at line 356 of file participant.c.

                                                                     {
  if (!p || !p->initialized || !p->connected) {
    return 0;
  }
  return p->client_id;
}

References session_participant::client_id, session_participant::connected, and session_participant::initialized.

session_participant_get_settings()

asciichat_error_t session_participant_get_settings	(	session_participant_t *	p,
		session_settings_t *	settings
	)

Definition at line 466 of file participant.c.

                                                                                                           {
  if (!p || !p->initialized || !settings) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_get_settings: invalid parameter");
  }
 
  memcpy(settings, &p->settings, sizeof(session_settings_t));
  return ASCIICHAT_OK;
}

References session_participant::initialized, and session_participant::settings.

session_participant_get_socket()

socket_t session_participant_get_socket

(

session_participant_t *

p

)

Definition at line 363 of file participant.c.

                                                                  {
  if (!p || !p->initialized) {
    return INVALID_SOCKET_VALUE;
  }
  return p->socket;
}

References session_participant::initialized, and session_participant::socket.

Referenced by discovery_session_check_host_alive(), and discovery_session_process().

session_participant_get_transport()

acip_transport_t * session_participant_get_transport

(

session_participant_t *

p

)

Definition at line 744 of file participant.c.

                                                                              {
  if (!p || !p->initialized) {
    return NULL;
  }
 
  return p->transport;
}

References session_participant::initialized, and session_participant::transport.

session_participant_has_transport()

bool session_participant_has_transport

(

session_participant_t *

p

)

Definition at line 752 of file participant.c.

                                                                 {
  if (!p) {
    return false;
  }
 
  return p->transport != NULL;
}

References session_participant::transport.

session_participant_is_audio_active()

bool session_participant_is_audio_active

(

session_participant_t *

p

)

Definition at line 455 of file participant.c.

                                                                   {
  if (!p || !p->initialized) {
    return false;
  }
  return p->audio_active;
}

References session_participant::audio_active, and session_participant::initialized.

session_participant_is_connected()

bool session_participant_is_connected

(

session_participant_t *

p

)

Definition at line 349 of file participant.c.

                                                                {
  if (!p || !p->initialized) {
    return false;
  }
  return p->connected;
}

References session_participant::connected, and session_participant::initialized.

Referenced by discovery_session_process().

session_participant_is_video_active()

bool session_participant_is_video_active

(

session_participant_t *

p

)

Definition at line 411 of file participant.c.

                                                                   {
  if (!p || !p->initialized) {
    return false;
  }
  return p->video_active;
}

References session_participant::initialized, and session_participant::video_active.

session_participant_request_settings()

asciichat_error_t session_participant_request_settings	(	session_participant_t *	p,
		const session_settings_t *	settings
	)

Definition at line 475 of file participant.c.

                                                                                                                     {
  if (!p || !p->initialized || !settings) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_request_settings: invalid parameter");
  }
 
  if (!p->connected) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_request_settings: not connected");
  }
 
  // TODO: Send settings update request to server
 
  return SET_ERRNO(ERROR_NOT_SUPPORTED, "session_participant_request_settings: not implemented yet");
}

References session_participant::connected, and session_participant::initialized.

session_participant_set_transport()

asciichat_error_t session_participant_set_transport	(	session_participant_t *	p,
		acip_transport_t *	transport
	)

Definition at line 726 of file participant.c.

                                                                                                           {
  if (!p || !p->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Participant is NULL or not initialized");
  }
 
  log_info("session_participant_set_transport: Setting transport=%p (was=%p)", transport, p->transport);
 
  p->transport = transport;
 
  if (transport) {
    log_info("WebRTC transport now active for participant");
  } else {
    log_info("WebRTC transport cleared, reverting to socket");
  }
 
  return ASCIICHAT_OK;
}

References session_participant::initialized, and session_participant::transport.

session_participant_start_audio()

asciichat_error_t session_participant_start_audio

(

session_participant_t *

p

)

Definition at line 418 of file participant.c.

                                                                            {
  if (!p || !p->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_start_audio: invalid participant");
  }
 
  if (!p->connected) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_audio: not connected");
  }
 
  if (p->audio_active) {
    return ASCIICHAT_OK; // Already active
  }
 
  if (!p->enable_audio) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_audio: audio not enabled");
  }
 
  // TODO: Start audio using session_audio_ctx_t
 
  p->audio_active = true;
  return ASCIICHAT_OK;
}

References session_participant::audio_active, session_participant::connected, session_participant::enable_audio, and session_participant::initialized.

session_participant_start_audio_capture()

asciichat_error_t session_participant_start_audio_capture

(

session_participant_t *

p

)

Definition at line 647 of file participant.c.

                                                                                    {
  if (!p || !p->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_start_audio_capture: invalid participant");
  }
 
  if (!p->connected) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_audio_capture: not connected");
  }
 
  if (!p->enable_audio) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_audio_capture: audio not enabled");
  }
 
  if (p->audio_capture_running) {
    return ASCIICHAT_OK; // Already running
  }
 
  // Create audio capture context if not already created
  if (!p->audio_capture) {
    p->audio_capture = session_audio_create(false); // false = participant mode (no mixing)
    if (!p->audio_capture) {
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create audio capture context");
    }
  }
 
  // Start audio capture and playback
  asciichat_error_t err = session_audio_start_duplex(p->audio_capture);
  if (err != ASCIICHAT_OK) {
    return SET_ERRNO(err, "Failed to start audio duplex");
  }
 
  // Create Opus encoder for audio compression (48kHz, VOIP mode, 24 kbps)
  if (!p->opus_encoder) {
    p->opus_encoder = opus_codec_create_encoder(OPUS_APPLICATION_VOIP, 48000, 24000);
    if (!p->opus_encoder) {
      session_audio_stop(p->audio_capture);
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create Opus encoder");
    }
  }
 
  // Spawn audio capture thread
  p->audio_capture_running = true;
  if (asciichat_thread_create(&p->audio_capture_thread, participant_audio_capture_thread, p) != 0) {
    log_error("Failed to spawn audio capture thread");
    p->audio_capture_running = false;
    return SET_ERRNO(ERROR_THREAD, "Failed to spawn audio capture thread");
  }
 
  log_info("Audio capture started");
  return ASCIICHAT_OK;
}

References asciichat_thread_create(), session_participant::audio_capture, session_participant::audio_capture_running, session_participant::audio_capture_thread, session_participant::connected, session_participant::enable_audio, session_participant::initialized, opus_codec_create_encoder(), session_participant::opus_encoder, session_audio_create(), session_audio_start_duplex(), and session_audio_stop().

session_participant_start_video()

asciichat_error_t session_participant_start_video

(

session_participant_t *

p

)

Definition at line 374 of file participant.c.

                                                                            {
  if (!p || !p->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_start_video: invalid participant");
  }
 
  if (!p->connected) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_video: not connected");
  }
 
  if (p->video_active) {
    return ASCIICHAT_OK; // Already active
  }
 
  if (!p->enable_video) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_video: video not enabled");
  }
 
  // TODO: Start webcam capture thread using session_capture_ctx_t
 
  p->video_active = true;
  return ASCIICHAT_OK;
}

References session_participant::connected, session_participant::enable_video, session_participant::initialized, and session_participant::video_active.

session_participant_start_video_capture()

asciichat_error_t session_participant_start_video_capture

(

session_participant_t *

p

)

Definition at line 586 of file participant.c.

                                                                                    {
  if (!p || !p->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_participant_start_video_capture: invalid participant");
  }
 
  if (!p->connected) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_video_capture: not connected");
  }
 
  if (!p->enable_video) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_participant_start_video_capture: video not enabled");
  }
 
  if (p->video_capture_running) {
    return ASCIICHAT_OK; // Already running
  }
 
  // Create video capture context if not already created
  if (!p->video_capture) {
    session_capture_config_t config = {
        .type = MEDIA_SOURCE_WEBCAM,
        .path = "0", // Default device
        .target_fps = 60,
        .resize_for_network = true, // Optimize for bandwidth
    };
    p->video_capture = session_capture_create(&config);
    if (!p->video_capture) {
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create video capture context");
    }
  }
 
  // Spawn video capture thread (media source is ready in ctx)
  p->video_capture_running = true;
  if (asciichat_thread_create(&p->video_capture_thread, participant_video_capture_thread, p) != 0) {
    log_error("Failed to spawn video capture thread");
    p->video_capture_running = false;
    return SET_ERRNO(ERROR_THREAD, "Failed to spawn video capture thread");
  }
 
  log_info("Video capture started");
  return ASCIICHAT_OK;
}

References asciichat_thread_create(), session_participant::connected, session_participant::enable_video, session_participant::initialized, session_capture_create(), session_participant::video_capture, session_participant::video_capture_running, and session_participant::video_capture_thread.

session_participant_stop_audio()

void session_participant_stop_audio

(

session_participant_t *

p

)

Definition at line 441 of file participant.c.

                                                              {
  if (!p || !p->initialized) {
    return;
  }
 
  if (!p->audio_active) {
    return;
  }
 
  // TODO: Stop audio
 
  p->audio_active = false;
}

References session_participant::audio_active, and session_participant::initialized.

Referenced by session_participant_disconnect().

session_participant_stop_audio_capture()

void session_participant_stop_audio_capture

(

session_participant_t *

p

)

Definition at line 699 of file participant.c.

                                                                      {
  if (!p || !p->initialized) {
    return;
  }
 
  if (!p->audio_capture_running) {
    return;
  }
 
  // Signal thread to stop
  p->audio_capture_running = false;
 
  // Wait for thread to complete
  asciichat_thread_join(&p->audio_capture_thread, NULL);
 
  // Stop audio streams
  if (p->audio_capture) {
    session_audio_stop(p->audio_capture);
  }
 
  log_info("Audio capture stopped");
}

References asciichat_thread_join(), session_participant::audio_capture, session_participant::audio_capture_running, session_participant::audio_capture_thread, session_participant::initialized, and session_audio_stop().

Referenced by session_participant_destroy().

session_participant_stop_video()

void session_participant_stop_video

(

session_participant_t *

p

)

Definition at line 397 of file participant.c.

                                                              {
  if (!p || !p->initialized) {
    return;
  }
 
  if (!p->video_active) {
    return;
  }
 
  // TODO: Stop webcam capture thread
 
  p->video_active = false;
}

References session_participant::initialized, and session_participant::video_active.

Referenced by session_participant_disconnect().

session_participant_stop_video_capture()

void session_participant_stop_video_capture

(

session_participant_t *

p

)

Definition at line 629 of file participant.c.

                                                                      {
  if (!p || !p->initialized) {
    return;
  }
 
  if (!p->video_capture_running) {
    return;
  }
 
  // Signal thread to stop
  p->video_capture_running = false;
 
  // Wait for thread to complete
  asciichat_thread_join(&p->video_capture_thread, NULL);
 
  log_info("Video capture stopped");
}

References asciichat_thread_join(), session_participant::initialized, session_participant::video_capture_running, and session_participant::video_capture_thread.

Referenced by session_participant_destroy().