host.h File Reference

🏠 Server-side session hosting abstraction More...

Go to the source code of this file.

Data Structures
struct	session_host_client_info_t
	Snapshot of the address, identity, activity, and connection time for one host client. More...
struct	session_host_callbacks_t
	Snapshot of the address, identity, activity, and connection time for one host client. More...
struct	session_host_config_t
	Host-side event hooks for joins, departures, media, and errors. More...
struct	session_host_render_config_t
	When code needs to work with session host render config, it keeps caps, palette, width, height here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. More...
struct	session_host_render_target_t
	session host render target is intentionally a small, concrete record. Fields such as client_id, context give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. Callbacks execute under the host client lock and must not call host APIs. More...

Typedefs
typedef struct acip_transport	acip_transport_t
	Forward declaration of ACIP transport.

Functions
session_host_t *	session_host_create (const session_host_config_t *config)
	Create a new session host.
asciichat_error_t	session_host_destroy (session_host_t *host)
	Destroy session host and free resources.
asciichat_error_t	session_host_start (session_host_t *host)
	Start accepting client connections.
asciichat_error_t	session_host_stop (session_host_t *host)
	Stop accepting connections and disconnect all clients.
bool	session_host_is_running (session_host_t *host)
	Check if host is running.
uint32_t	session_host_add_client (session_host_t *host, acip_transport_t *transport, acip_transport_ownership_t ownership, const char *ip, int port)
uint32_t	session_host_add_memory_participant (session_host_t *host)
	Add a memory participant (host's own media).
asciichat_error_t	session_host_inject_frame (session_host_t *host, uint32_t participant_id, const image_t *frame)
	Inject a video frame from memory participant.
asciichat_error_t	session_host_inject_audio (session_host_t *host, uint32_t participant_id, const float *samples, size_t count)
	Inject audio samples from memory participant.
asciichat_error_t	session_host_remove_client (session_host_t *host, uint32_t client_id)
	Remove a client by ID.
asciichat_error_t	session_host_find_client (session_host_t *host, uint32_t client_id, session_host_client_info_t *info)
	Find a client by ID.
int	session_host_get_client_count (session_host_t *host)
	Get number of connected clients.
int	session_host_get_client_ids (session_host_t *host, uint32_t *ids, int max_ids)
	Get list of all connected client IDs.
asciichat_error_t	session_host_broadcast_frame (session_host_t *host, const char *frame)
	Broadcast ASCII frame to all clients.
asciichat_error_t	session_host_send_frame (session_host_t *host, uint32_t client_id, const char *frame)
	Send ASCII frame to a specific client.
asciichat_error_t	session_host_set_display (session_host_t *host, struct session_display_ctx *display)
	Set a native terminal display context for local frame rendering.
asciichat_error_t	session_host_set_render_target (session_host_t *host, const session_host_render_target_t *target)
asciichat_error_t	session_host_start_render (session_host_t *host)
	Start media rendering thread (video mixing and audio distribution).
void	session_host_stop_render (session_host_t *host)
	Stop media rendering thread.
asciichat_error_t	session_host_set_client_transport (session_host_t *host, uint32_t client_id, acip_transport_t *transport, acip_transport_ownership_t ownership)
	Select a transport for a specific client in the host.
acip_transport_t *	session_host_get_client_transport (session_host_t *host, uint32_t client_id)
	Get the current transport for a specific client in the host.
bool	session_host_client_has_transport (session_host_t *host, uint32_t client_id)
	Check if a specific client has an active ACIP transport.
asciichat_error_t	session_host_receive_packet (session_host_t *host, uint32_t client_id, packet_type_t type, const void *data, size_t len)
asciichat_error_t	session_host_render_video (session_host_t *host)
asciichat_error_t	session_host_accept_peer (session_host_t *, acip_transport_t *)
asciichat_error_t	session_host_render_audio (session_host_t *host)

Detailed Description

🏠 Server-side session hosting abstraction

Definition in file host.h.

Function Documentation

session_host_accept_peer()

asciichat_error_t session_host_accept_peer	(	session_host_t *	host,
		acip_transport_t *	transport )

Definition at line 1106 of file host.c.

                                                                                              {
#ifndef __EMSCRIPTEN__
  if (!host || !host->network_server)
    return SET_ERRNO(ERROR_INVALID_STATE, "Host network is not running");
  return network_server_adopt(host->network_server, transport, "peer", true);
#else
  (void)host;
  (void)transport;
  return SET_ERRNO(ERROR_NOT_SUPPORTED, "Browser peers use the browser host bridge");
#endif
}

References ERROR_INVALID_STATE, ERROR_NOT_SUPPORTED, network_server_adopt(), and SET_ERRNO.

session_host_add_client()

uint32_t session_host_add_client	(	session_host_t *	host,
		acip_transport_t *	transport,
		acip_transport_ownership_t	ownership,
		const char *	ip,
		int	port )

Register a transport-backed client. The same API accepts TCP, WebSocket, and WebRTC. Ownership transfers only on success. NULL registers a participant whose transport will be supplied later. on_client_join runs after admission.

Definition at line 1129 of file host.c.

                                                                                                 {
  if (!host || !host->initialized) {
    return 0;
  }
 
  if ((ownership != ACIP_TRANSPORT_BORROWED && ownership != ACIP_TRANSPORT_OWNED) ||
      (!transport && ownership == ACIP_TRANSPORT_OWNED)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport ownership");
    return 0;
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Check if we have room
  if (host->client_count >= host->max_clients) {
    mutex_unlock(&host->clients_mutex);
    SET_ERRNO(ERROR_SESSION_FULL, "Maximum clients reached");
    return 0;
  }
 
  // Find empty slot
  for (int i = 0; i < host->max_clients; i++) {
    if (!host->clients[i].active) {
      host->clients[i].participant_type = PARTICIPANT_TYPE_NETWORK;
      host->clients[i].client_id = host->next_client_id++;
      host->clients[i].connection = NULL;
      if (ip) {
        SAFE_STRNCPY(host->clients[i].ip_address, ip, sizeof(host->clients[i].ip_address));
      }
      host->clients[i].port = port;
      host->clients[i].active = true;
      host->clients[i].video_active = false;
      host->clients[i].audio_active = false;
      host->clients[i].connected_at = (uint64_t)time(NULL);
      host->clients[i].transport = NULL;
      host->clients[i].transport_ownership = ACIP_TRANSPORT_BORROWED;
      host->clients[i].render_width = 0;
      host->clients[i].render_height = 0;
      memset(&host->clients[i].rendering, 0, sizeof(host->clients[i].rendering));
      host->clients[i].rendering.fps_limit = DEFAULT_MAX_FPS;
      host->clients[i].next_video_deadline = 0;
 
      // Allocate media buffers
      host->clients[i].incoming_video = image_new(480, 270); // Network-optimal size (HD preview)
      host->clients[i].incoming_audio = ringbuffer_create(
          sizeof(float), (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS) * HOST_AUDIO_BUFFER_FRAMES); // ~200ms buffer @ 48kHz
 
      if (!host->clients[i].incoming_video || !host->clients[i].incoming_audio) {
        // Cleanup on allocation failure
        if (host->clients[i].incoming_video) {
          image_destroy(host->clients[i].incoming_video);
          host->clients[i].incoming_video = NULL;
        }
        if (host->clients[i].incoming_audio) {
          ringbuffer_destroy(host->clients[i].incoming_audio);
          host->clients[i].incoming_audio = NULL;
        }
        host->clients[i].active = false;
        mutex_unlock(&host->clients_mutex);
        SET_ERRNO(ERROR_MEMORY, "Failed to allocate media buffers for client");
        return 0;
      }
 
      host->clients[i].transport = transport;
      host->clients[i].transport_ownership = ownership;
      uint32_t client_id = host->clients[i].client_id;
      host->client_count++;
 
      mutex_unlock(&host->clients_mutex);
 
      // Invoke callback
      if (host->callbacks.on_client_join) {
        host->callbacks.on_client_join(host, client_id, host->user_data);
      }
 
      return client_id;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return 0;
}

References ACIP_TRANSPORT_BORROWED, ACIP_TRANSPORT_OWNED, AUDIO_CHANNELS, DEFAULT_MAX_FPS, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_SESSION_FULL, HOST_AUDIO_BUFFER_FRAMES, image_destroy(), image_new(), OPUS_FRAME_SAMPLES, PARTICIPANT_TYPE_NETWORK, ringbuffer_create(), ringbuffer_destroy(), SAFE_STRNCPY, and SET_ERRNO.

Referenced by add_transport_client().

session_host_receive_packet()

asciichat_error_t session_host_receive_packet	(	session_host_t *	host,
		uint32_t	client_id,
		packet_type_t	type,
		const void *	data,
		size_t	len )

Process a packet delivered by an event-driven transport.

Definition at line 343 of file host.c.

                                                                            {
  if (!host || !host->initialized || (!data && len))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid host packet");
  acip_transport_t *client_transport = session_host_get_client_transport(host, client_id);
  switch (ptype) {
  case PACKET_TYPE_IMAGE_FRAME:
    // Client sent a video frame - parse and store in incoming buffer
    if (data && len >= sizeof(image_frame_packet_t)) {
      const image_frame_packet_t *frame_hdr = (const image_frame_packet_t *)data;
      const uint8_t *pixel_data = (const uint8_t *)data + sizeof(image_frame_packet_t);
      size_t pixel_data_size = len - sizeof(image_frame_packet_t);
      uint32_t width = NET_TO_HOST_U32(frame_hdr->width);
      uint32_t height = NET_TO_HOST_U32(frame_hdr->height);
      uint32_t pixel_format = NET_TO_HOST_U32(frame_hdr->pixel_format);
      size_t bytes_per_pixel = (pixel_format == PIXEL_FORMAT_RGBA || pixel_format == PIXEL_FORMAT_BGRA) ? 4 : 3;
      size_t expected_size = 0;
      size_t pixel_count = 0;
 
      if (pixel_format < PIXEL_FORMAT_RGB || pixel_format > PIXEL_FORMAT_BGRA || width == 0 || height == 0 ||
          width > INT_MAX || height > INT_MAX ||
          checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK ||
          checked_size_mul(pixel_count, bytes_per_pixel, &expected_size) != ASCIICHAT_OK ||
          expected_size != pixel_data_size) {
        log_warn("Discarding malformed video frame from client %u (%ux%u, format %u, payload %zu)", client_id, width,
                 height, pixel_format, pixel_data_size);
      } else {
        // Frame dimensions and pixel format are network-order fields. Resize
        // this participant's image when its capture dimensions change.
        mutex_lock(&host->clients_mutex);
        for (int j = 0; j < host->max_clients; j++) {
          if (host->clients[j].active && host->clients[j].client_id == client_id && host->clients[j].incoming_video) {
            image_t *img = host->clients[j].incoming_video;
            if (img->w != (int)width || img->h != (int)height) {
              image_t *resized = image_new(width, height);
              if (!resized) {
                log_warn("Could not allocate %ux%u video frame for client %u", width, height, client_id);
                break;
              }
              image_destroy(img);
              host->clients[j].incoming_video = img = resized;
            }
 
            uint8_t *dst = (uint8_t *)img->pixels;
            if (pixel_format == PIXEL_FORMAT_RGB) {
              memcpy(dst, pixel_data, pixel_count * 3);
            } else if (pixel_format == PIXEL_FORMAT_BGR) {
              for (size_t p = 0; p < pixel_count; p++) {
                dst[p * 3] = pixel_data[p * 3 + 2];
                dst[p * 3 + 1] = pixel_data[p * 3 + 1];
                dst[p * 3 + 2] = pixel_data[p * 3];
              }
            } else {
              const bool bgra = pixel_format == PIXEL_FORMAT_BGRA;
              for (size_t p = 0; p < pixel_count; p++) {
                const uint8_t *src = pixel_data + p * 4;
                dst[p * 3] = src[bgra ? 2 : 0];
                dst[p * 3 + 1] = src[1];
                dst[p * 3 + 2] = src[bgra ? 0 : 2];
              }
            }
            log_debug_every(500 * US_PER_MS_INT, "Frame received from client %u (%ux%u, format %u)", client_id, width,
                            height, pixel_format);
            break;
          }
        }
        mutex_unlock(&host->clients_mutex);
      }
    }
    break;
 
  case PACKET_TYPE_AUDIO_OPUS_BATCH:
    // Client sent Opus-encoded audio batch
    if (data && len > 16) { // Must have at least header
      const uint8_t *batch_data = (const uint8_t *)data;
      // Parse header: sample_rate (4), frame_duration (4), frame_count (4), reserved (4)
      (void)batch_data[0]; // Avoid unused variable warning if we don't use sample_rate/frame_duration
      uint32_t batch_frame_count_net = 0;
      memcpy(&batch_frame_count_net, batch_data + 8, sizeof(batch_frame_count_net));
      uint32_t batch_frame_count = NET_TO_HOST_U32(batch_frame_count_net);
 
      size_t frame_sizes_len = (size_t)batch_frame_count * sizeof(uint16_t);
      if (batch_frame_count > 0 && batch_frame_count <= 1000 && 16 + frame_sizes_len <= len) {
        const uint8_t *frame_sizes = batch_data + 16;
        const uint8_t *opus_frames = batch_data + 16 + (batch_frame_count * sizeof(uint16_t));
        const uint8_t *batch_end = batch_data + len;
 
        // Find client and decode audio
        mutex_lock(&host->clients_mutex);
        for (int j = 0; j < host->max_clients; j++) {
          if (host->clients[j].client_id == client_id && host->clients[j].active && host->clients[j].incoming_audio) {
            if (!host->clients[j].opus_decoder)
              host->clients[j].opus_decoder = opus_codec_create_decoder_channels(AUDIO_SAMPLE_RATE, AUDIO_CHANNELS);
            if (!host->clients[j].opus_decoder) {
              mutex_unlock(&host->clients_mutex);
              return SET_ERRNO(ERROR_AUDIO, "Failed to initialize participant decoder");
            }
            // Each participant owns an independent predictive Opus stream.
            const uint8_t *current_frame = opus_frames;
            for (uint32_t k = 0; k < batch_frame_count; k++) {
              uint16_t frame_size_net = 0;
              memcpy(&frame_size_net, frame_sizes + k * sizeof(frame_size_net), sizeof(frame_size_net));
              uint16_t frame_size = NET_TO_HOST_U16(frame_size_net);
              if ((size_t)(batch_end - current_frame) < frame_size) {
                break;
              }
              if (frame_size > 0) {
                // Allocate buffer for decoded samples
                float decoded_samples[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)]; // Max 20ms @ 48kHz
                int decoded_count = opus_codec_decode(host->clients[j].opus_decoder, current_frame, (int)frame_size,
                                                      decoded_samples, (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS));
                if (decoded_count > 0) {
                  host->clients[j].audio_active = true;
                  // Write samples to ringbuffer one at a time
                  for (int s = 0; s < decoded_count; s++) {
                    ringbuffer_write(host->clients[j].incoming_audio, &decoded_samples[s]);
                  }
                }
              }
              current_frame += frame_size;
            }
            log_debug_every(NS_PER_MS_INT, "Audio batch received from client %u (%u frames)", client_id,
                            batch_frame_count);
            break;
          }
        }
        mutex_unlock(&host->clients_mutex);
      }
    }
    break;
 
  case PACKET_TYPE_STREAM_START:
    log_info("Client %u started streaming", client_id);
    mutex_lock(&host->clients_mutex);
    for (int j = 0; j < host->max_clients; j++) {
      if (host->clients[j].client_id == client_id) {
        host->clients[j].video_active = true;
        break;
      }
    }
    mutex_unlock(&host->clients_mutex);
    break;
 
  case PACKET_TYPE_CLIENT_CAPABILITIES:
  case PACKET_TYPE_ACIP_SETTINGS_SYNC: {
    uint8_t reply[ACIP_SETTINGS_MAX_SIZE];
    size_t reply_length = 0;
    asciichat_error_t result = ASCIICHAT_OK;
    session_host_client_t *target = NULL;
    mutex_lock(&host->clients_mutex);
    for (int j = 0; j < host->max_clients; ++j) {
      if (host->clients[j].active && host->clients[j].client_id == client_id) {
        target = &host->clients[j];
        break;
      }
    }
    if (!target)
      result = SET_ERRNO(ERROR_INVALID_STATE, "Unknown settings participant");
    else if (ptype == PACKET_TYPE_CLIENT_CAPABILITIES) {
      if (!data || len != sizeof(terminal_capabilities_packet_t))
        result = SET_ERRNO(ERROR_INVALID_PARAM, "Invalid capabilities");
      else {
        terminal_capabilities_packet_t packet;
        memcpy(&packet, data, sizeof(packet));
        if (target->rendering.width) {
          // Codec advertisements cannot change an established viewer's settings.
          mutex_unlock(&host->clients_mutex);
          return ASCIICHAT_OK;
        }
        result = acip_render_settings_capabilities(&target->rendering, &packet);
        if (result == ASCIICHAT_OK) {
          uint8_t query[ACIP_SETTINGS_HEADER_SIZE];
          size_t query_length;
          acip_settings_header_t header = {.schema = 1, .expected_revision = UINT32_MAX};
          result = acip_settings_encode(&header, "", query, sizeof(query), &query_length);
          if (result == ASCIICHAT_OK)
            result =
                acip_settings_request(&target->rendering, query, query_length, reply, sizeof(reply), &reply_length);
        }
      }
    } else if (!target->rendering.revision)
      result = SET_ERRNO(ERROR_INVALID_STATE, "Settings received before capabilities");
    else
      result = acip_settings_request(&target->rendering, data, len, reply, sizeof(reply), &reply_length);
    if (target && result == ASCIICHAT_OK) {
      target->render_width = target->rendering.width;
      target->render_height = target->rendering.height;
      if (reply_length)
        result = packet_send_via_transport(target->transport, PACKET_TYPE_ACIP_SETTINGS_ACK, reply, reply_length, 0);
    }
    mutex_unlock(&host->clients_mutex);
    return result;
  }
 
  case PACKET_TYPE_STREAM_STOP:
    log_info("Client %u stopped streaming", client_id);
    mutex_lock(&host->clients_mutex);
    for (int j = 0; j < host->max_clients; j++) {
      if (host->clients[j].client_id == client_id) {
        host_forget_render_history(host, client_id);
        host->clients[j].video_active = false;
        host->clients[j].audio_active = false;
        break;
      }
    }
    mutex_unlock(&host->clients_mutex);
    break;
 
  case PACKET_TYPE_PING:
    // Respond with PONG
    log_debug_every(NS_PER_MS_INT, "PING from client %u", client_id);
    acip_send_pong(client_transport);
    break;
 
  case PACKET_TYPE_CLIENT_LEAVE:
    log_info("Client %u requested disconnect", client_id);
    // Mark for removal (will be handled separately to avoid deadlock)
    break;
 
  default:
    log_warn("Unknown packet type %u from client %u", ptype, client_id);
    break;
  }
 
  return ASCIICHAT_OK;
}

References acip_render_settings_capabilities(), acip_send_pong(), acip_settings_encode(), ACIP_SETTINGS_HEADER_SIZE, ACIP_SETTINGS_MAX_SIZE, acip_settings_request(), ASCIICHAT_OK, AUDIO_CHANNELS, AUDIO_SAMPLE_RATE, ERROR_AUDIO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, image_t::h, acip_render_settings_t::height, height, image_frame_packet_t::height, image_destroy(), image_new(), log_debug_every, log_info, log_warn, NET_TO_HOST_U16, NET_TO_HOST_U32, NS_PER_MS_INT, opus_codec_create_decoder_channels(), opus_codec_decode(), OPUS_FRAME_SAMPLES, packet_send_via_transport(), PACKET_TYPE_ACIP_SETTINGS_ACK, PACKET_TYPE_ACIP_SETTINGS_SYNC, PACKET_TYPE_AUDIO_OPUS_BATCH, PACKET_TYPE_CLIENT_CAPABILITIES, PACKET_TYPE_CLIENT_LEAVE, PACKET_TYPE_IMAGE_FRAME, PACKET_TYPE_PING, PACKET_TYPE_STREAM_START, PACKET_TYPE_STREAM_STOP, image_frame_packet_t::pixel_format, PIXEL_FORMAT_BGR, PIXEL_FORMAT_BGRA, PIXEL_FORMAT_RGB, PIXEL_FORMAT_RGBA, image_t::pixels, session_host_client_t::render_height, session_host_client_t::render_width, session_host_client_t::rendering, acip_render_settings_t::revision, ringbuffer_write(), session_host_get_client_transport(), SET_ERRNO, session_host_client_t::transport, US_PER_MS_INT, image_t::w, acip_render_settings_t::width, image_frame_packet_t::width, and width.

session_host_render_audio()

asciichat_error_t session_host_render_audio

(

session_host_t *

host

)

Mix and distribute one 20 ms audio frame without starting a thread.

Definition at line 817 of file host.c.

                                                                  {
  if (!host || !host->initialized)
    return SET_ERRNO(ERROR_INVALID_PARAM, "invalid host");
  uint64_t mix_start = time_get_ns();
  double total[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)] = {0};
  asciichat_error_t result = ASCIICHAT_OK;
  mutex_lock(&host->clients_mutex);
  // Drain each source once. Keep unclipped samples so mix-minus can subtract
  // the recipient before clipping without leaking its voice into the output.
  for (int i = 0; i < host->max_clients; i++) {
    session_host_client_t *client = &host->clients[i];
    memset(client->audio_frame, 0, sizeof(client->audio_frame));
    if (!client->active || !client->audio_active || !client->incoming_audio)
      continue;
    for (int j = 0; j < (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS); j++) {
      if (ringbuffer_read(client->incoming_audio, &client->audio_frame[j]))
        total[j] += client->audio_frame[j];
    }
  }
  for (int i = 0; i < host->max_clients; i++) {
    session_host_client_t *client = &host->clients[i];
    if (!client->active || !client->transport)
      continue;
    ASCII_OTEL_SCOPE(SERVER_AUDIO);
    if (!client->opus_encoder)
      client->opus_encoder =
          opus_codec_create_encoder_channels(OPUS_APPLICATION_AUDIO, AUDIO_SAMPLE_RATE, 128000, AUDIO_CHANNELS);
    if (!client->opus_encoder) {
      result = SET_ERRNO(ERROR_AUDIO, "Failed to initialize participant encoder");
      continue;
    }
    float mixed[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)];
    for (int j = 0; j < (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS); j++) {
      float sample = (float)(total[j] - client->audio_frame[j]);
      mixed[j] = sample > 1.0f ? 1.0f : sample < -1.0f ? -1.0f : sample;
    }
    uint8_t opus_buffer[AUDIO_OPUS_SESSION_PACKET_CAPACITY];
    size_t opus_len = opus_codec_encode(client->opus_encoder, mixed, OPUS_FRAME_SAMPLES * AUDIO_CHANNELS, opus_buffer,
                                        sizeof(opus_buffer));
    if (opus_len > 0) {
      uint16_t frame_sizes[1] = {(uint16_t)opus_len};
      asciichat_error_t sent = acip_send_audio_opus_batch(client->transport, opus_buffer, opus_len, frame_sizes, 1,
                                                          AUDIO_SAMPLE_RATE, CLIENT_AUDIO_PIPELINE_FRAME_MS);
      if (sent != ASCIICHAT_OK)
        log_warn("Failed to send mixed audio to client %u", client->client_id);
    }
  }
  mutex_unlock(&host->clients_mutex);
  stats_duration_record(stats_runtime_scope(), STATS_DURATION_AUDIO_MIX, time_get_ns() - mix_start);
#ifndef __EMSCRIPTEN__
  float recorded[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)];
  for (int j = 0; j < (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS); j++)
    recorded[j] = total[j] > 1.0 ? 1.0f : total[j] < -1.0 ? -1.0f : (float)total[j];
  audio_recording_submit(AUDIO_RECORDING_REMOTE, recorded, (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS), time_get_ns());
#endif
  return result;
}

References acip_send_audio_opus_batch(), session_host_client_t::active, ASCII_OTEL_SCOPE, ASCIICHAT_OK, session_host_client_t::audio_active, AUDIO_CHANNELS, session_host_client_t::audio_frame, AUDIO_OPUS_SESSION_PACKET_CAPACITY, AUDIO_RECORDING_REMOTE, audio_recording_submit(), AUDIO_SAMPLE_RATE, CLIENT_AUDIO_PIPELINE_FRAME_MS, session_host_client_t::client_id, ERROR_AUDIO, ERROR_INVALID_PARAM, session_host_client_t::incoming_audio, log_warn, OPUS_APPLICATION_AUDIO, opus_codec_create_encoder_channels(), opus_codec_encode(), session_host_client_t::opus_encoder, OPUS_FRAME_SAMPLES, ringbuffer_read(), SET_ERRNO, STATS_DURATION_AUDIO_MIX, stats_duration_record(), stats_runtime_scope(), and session_host_client_t::transport.

session_host_render_video()

asciichat_error_t session_host_render_video

(

session_host_t *

host

)

Run one shared host video cycle without starting a thread.

Definition at line 810 of file host.c.

                                                                  {
  if (!host || !host->initialized)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session host");
  host_render_video(host, false);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, and SET_ERRNO.

session_host_set_render_target()

asciichat_error_t session_host_set_render_target	(	session_host_t *	host,
		const session_host_render_target_t *	target )

Set local output on native or WASM hosts. NULL disables the local target. A client target is rendered once and delivered through its existing transport. A backend's context must outlive its registration.

Definition at line 1550 of file host.c.

                                                                                                                   {
  if (!host || !host->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "invalid host");
  }
  if (target) {
    bool has_backend = target->get_config || target->render_frame;
    bool complete_backend = target->get_config && target->render_frame;
    bool valid_target = target->client_id ? !has_backend : complete_backend;
    if (!valid_target)
      return SET_ERRNO(ERROR_INVALID_PARAM, "Local rendering requires a client or a complete display backend");
  }
 
  mutex_lock(&host->clients_mutex);
  if (target && target->client_id) {
    bool found = false;
    for (int i = 0; i < host->max_clients; ++i)
      if (host->clients[i].active && host->clients[i].client_id == target->client_id)
        found = true;
    if (!found) {
      mutex_unlock(&host->clients_mutex);
      return SET_ERRNO(ERROR_NOT_FOUND, "Local display client not found: %u", target->client_id);
    }
  }
  host->render_target = target ? *target : (session_host_render_target_t){0};
  mutex_unlock(&host->clients_mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, session_host_render_target_t::client_id, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, session_host_render_target_t::get_config, session_host_render_target_t::render_frame, and SET_ERRNO.