ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
discovery/main.c
Go to the documentation of this file.
1
2/* Storage capacities in elements; text buffers include the terminating NUL. */
3#define DISCOVERY_MAIN_ERROR_BUFFER_SIZE 512
4
41
43
44#include "main.h"
45#include "../main.h" // Global exit API
46#include "session.h"
47#include "session/capture.h"
48#include "session/display.h"
49#include "session/host.h"
50#include "session/audio.h"
51#include "session/render.h"
53#include "session/client_like.h"
54#include "session/participant.h"
55#include "session/connection.h"
56#include "session/protocol.h"
61#include <ascii-chat/buffer.h>
62#include <ascii-chat/otel.h>
64#include <libplatform/terminal.h>
65
66#include <stdio.h>
67
68#include <ascii-chat/log/log.h>
69#include <options/options.h>
70#include <options/common.h>
74#include <libplatform/compiler.h>
75#include <libplatform/system.h>
76#include <libplatform/terminal.h>
77#include <libplatform/keyboard.h>
81
82/* ============================================================================
83 * Global Discovery Session
84 * ============================================================================ */
85
105
106static void discovery_media_interrupt(void *context) {
107 discovery_video_receiver_t *receiver = context;
108 atomic_store_bool(&receiver->running, false);
110}
111
112static asciichat_error_t discovery_media_join(void *context) {
113 discovery_video_receiver_t *receiver = context;
114 if (receiver->receiver_started) {
115 asciichat_error_t result = thread_join(&receiver->receiver_thread, NULL);
116 if (result != ASCIICHAT_OK)
117 return result;
118 receiver->receiver_started = false;
119 }
120 if (receiver->audio_started) {
121 asciichat_error_t result = thread_join(&receiver->audio_thread, NULL);
122 if (result != ASCIICHAT_OK)
123 return result;
124 receiver->audio_started = false;
125 }
126 return ASCIICHAT_OK;
127}
128
129static void discovery_media_release(void *context) {
130 discovery_video_receiver_t *receiver = context;
131 if (receiver->audio) {
132 audio_destroy(receiver->audio);
133 receiver->audio = NULL;
134 }
136 receiver->audio_pipeline = NULL;
137 log_info("DISCOVERY_MEDIA_RELEASED: workers=0");
138}
139
156
157static void *discovery_host_audio_capture(void *user_data) {
158 discovery_host_audio_capture_t *capture = user_data;
159 float samples[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)];
160 while (atomic_load_bool(&capture->running) && !should_exit()) {
161 size_t count = session_audio_read_captured(capture->audio, samples, (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS));
162 if (!count) {
163 platform_sleep_ns(NS_PER_MS_INT);
164 continue;
165 }
166 capture->result = session_host_inject_audio(capture->host, capture->participant_id, samples, count);
167 if (capture->result != ASCIICHAT_OK)
168 break;
169 }
170 atomic_store_bool(&capture->running, false);
171 return NULL;
172}
173
174static void discovery_host_audio_join(discovery_host_audio_capture_t *capture) {
175 atomic_store_bool(&capture->running, false);
176 if (!capture->started)
177 return;
178 // The worker borrows this role's stack and audio context. Retain both until
179 // the join succeeds, including error/shutdown paths.
180 while (thread_join(&capture->thread, NULL) != ASCIICHAT_OK) {
181 log_warn_every(NS_PER_SEC_INT, "Waiting for native host audio capture worker to stop");
182 platform_sleep_ns(NS_PER_MS_INT);
183 }
184 capture->started = false;
185}
186
187static void *discovery_audio_send_thread(void *user_data) {
188 discovery_video_receiver_t *ctx = user_data;
189 float samples[(OPUS_FRAME_SAMPLES * AUDIO_CHANNELS)];
191 while (atomic_load_bool(&ctx->running) && !should_exit()) {
193 platform_sleep_ns(NS_PER_MS_INT);
194 continue;
195 }
197 continue;
198 ASCII_OTEL_SCOPE(CLIENT_AUDIO_CAPTURE);
199 int size = client_audio_pipeline_capture(ctx->audio_pipeline, samples, (OPUS_FRAME_SAMPLES * AUDIO_CHANNELS), encoded, sizeof(encoded));
200 if (size <= 0)
201 continue;
202 uint16_t frame_size = (uint16_t)size;
204 if (result != ASCIICHAT_OK) {
205 log_warn("Discovery audio send failed %s", asciichat_error_format(NULL, result));
206 atomic_store_bool(&ctx->running, false);
207 break;
208 }
209 }
210 return NULL;
211}
212
213static asciichat_error_t discovery_present_frame(const ascii_frame_packet_t *header, const char *text, void *context) {
214 discovery_video_receiver_t *receiver = context;
215 (void)header;
216 session_display_render_frame(receiver->display, text);
217 if (text && text[0]) {
218 receiver->observed_video_frames++;
219 if (receiver->observed_video_frames == 1 || (GET_OPTION(test_audio) && receiver->observed_video_frames % 25 == 0))
220 log_info("Discovery decoded video: frames=%llu", (unsigned long long)receiver->observed_video_frames);
221 }
222 return ASCIICHAT_OK;
223}
224
225static asciichat_error_t discovery_play_samples(const float *samples, size_t count, void *context) {
226 discovery_video_receiver_t *receiver = context;
227 if (!receiver->audio)
228 return ASCIICHAT_OK;
229 size_t observed_count = count;
230 double energy = 0;
231 if (GET_OPTION(test_audio))
232 for (size_t i = 0; i < count; ++i)
233 energy += (double)samples[i] * samples[i];
234 while (count) {
236 asciichat_error_t result = audio_write_samples(receiver->audio, samples, (int)chunk);
237 if (result != ASCIICHAT_OK)
238 return result;
239 samples += chunk;
240 count -= chunk;
241 }
242 // Test-source diagnostics observe remote decoded PCM only, after successful
243 // playback submission. Local test monitoring never reaches this callback.
244 if (GET_OPTION(test_audio) && observed_count && energy / observed_count >= 0.000025) {
245 uint64_t now = time_get_ns();
246 if (receiver->observed_audio_ns && now - receiver->observed_audio_ns > receiver->observed_audio_gap_ns)
247 receiver->observed_audio_gap_ns = now - receiver->observed_audio_ns;
248 receiver->observed_audio_ns = now;
249 receiver->observed_audio_samples += observed_count;
250 receiver->observed_audio_blocks++;
251 if (receiver->observed_audio_blocks == 1 || receiver->observed_audio_blocks % 25 == 0)
252 log_info("Discovery decoded remote audio: blocks=%llu samples=%llu at_ns=%llu max_gap_ns=%llu", (unsigned long long)receiver->observed_audio_blocks,
253 (unsigned long long)receiver->observed_audio_samples, (unsigned long long)now, (unsigned long long)receiver->observed_audio_gap_ns);
254 }
255 return ASCIICHAT_OK;
256}
257
258static asciichat_error_t discovery_decode_opus(const void *data, size_t length, float *samples, size_t capacity, size_t *decoded, void *context) {
259 discovery_video_receiver_t *receiver = context;
260 *decoded = 0;
261 if (!receiver->audio)
262 return ASCIICHAT_OK;
263 int count = client_audio_pipeline_playback(receiver->audio_pipeline, data, (int)length, samples, (int)capacity);
264 if (count < 0)
265 return SET_ERRNO(ERROR_AUDIO, "Could not decode participant Opus audio");
266 *decoded = (size_t)count;
267 return ASCIICHAT_OK;
268}
269
270static void discovery_host_pong(void *arg) {
272}
273
274static asciichat_error_t discovery_media_packet(network_connection_t *network, packet_type_t type, const void *payload, size_t length, void *arg) {
275 (void)network;
276 discovery_video_receiver_t *receiver = arg;
277 return session_protocol_dispatch(&receiver->protocol, type, payload, length);
278}
279static void *discovery_video_receive_thread(void *arg) {
280 discovery_video_receiver_t *receiver = arg;
281 network_connection_callbacks_t callbacks = {.packet = discovery_media_packet};
282 receiver->result = network_connection_run(receiver->network, &callbacks, receiver);
283 if ((!atomic_load_bool(&receiver->running) || should_exit()) && (receiver->result == ASCIICHAT_OK || receiver->result == ERROR_NETWORK || receiver->result == ERROR_NETWORK_TIMEOUT))
284 receiver->result = ASCIICHAT_OK;
285 atomic_store_bool(&receiver->running, false);
286 return NULL;
287}
288
290static discovery_session_t *g_discovery = NULL;
291
292/* ============================================================================
293 * State Change Callback
294 * ============================================================================ */
295
302static void on_discovery_state_change(discovery_state_t new_state, void *user_data) {
303 (void)user_data; // Unused
304 switch (new_state) {
310 break;
313 break;
316 break;
319 break;
322 break;
323 default:
325 break;
326 }
327 if (new_state == DISCOVERY_STATE_ACTIVE)
329 static uint64_t setup_started;
330 if (new_state == DISCOVERY_STATE_CONNECTING_ACDS)
331 setup_started = time_get_ns();
332 if (setup_started && (new_state == DISCOVERY_STATE_ACTIVE || new_state == DISCOVERY_STATE_FAILED)) {
334 setup_started = 0;
335 }
336
337 const char *state_names[] = {"INIT", "CONNECTING_ACDS", "CREATING_SESSION", "JOINING_SESSION", "WAITING_PEER", "NEGOTIATING",
338 "STARTING_HOST", "CONNECTING_HOST", "ACTIVE", "MIGRATING", "FAILED", "ENDED"};
339
340 if (new_state >= 0 && new_state < (int)(sizeof(state_names) / sizeof(state_names[0]))) {
341 if (new_state == DISCOVERY_STATE_ACTIVE && g_discovery)
342 stats_runtime_connection_state(discovery_session_is_host(g_discovery) ? "ACTIVE / host" : "ACTIVE / participant");
343 else
344 stats_runtime_connection_state(state_names[new_state]);
345 log_info("Discovery state: %s", state_names[new_state]);
346 }
347}
348
355static void on_session_ready(const char *session_string, void *user_data) {
356 (void)user_data; // Unused
357
358 if (session_string && session_string[0]) {
359 const char *requested = GET_OPTION(session_string);
360 splash_set_discovery_session(session_string, requested && requested[0]);
361 log_info("Share this string to connect: %s", session_string);
362 log_info("Run: ascii-chat %s", session_string);
363 }
364}
365
378
380static void on_discovery_error(asciichat_error_t error, const char *message, void *user_data) {
381 discovery_ui_state_t *ui = user_data;
382 mutex_lock(&ui->mutex);
383 SAFE_STRNCPY(ui->error, message ? message : "Unknown discovery error", sizeof(ui->error));
384 ui->error_code = error;
385 mutex_unlock(&ui->mutex);
386 log_error("%s", asciichat_error_format(message ? message : "Unknown discovery error", error));
387 signal_exit();
388}
389
399static bool discovery_capture_should_exit_adapter(void *user_data) {
400 (void)user_data; // Unused parameter
401 return should_exit();
402}
403
414static void discovery_keyboard_handler(session_capture_ctx_t *capture, int key, void *user_data) {
415 (void)user_data; // Unused parameter
416 // Discovery mode doesn't have a display context yet, pass NULL for display
417 // Help screen will be silently ignored (no-op)
418 session_handle_keyboard_input(capture, NULL, (keyboard_key_t)key);
419}
420
421/* ============================================================================
422 * Discovery Run Callback (for session_client_like)
423 * ============================================================================ */
424
436static asciichat_error_t discovery_send_settings(const options_t *values, uint32_t request, void *context) {
437 return acip_settings_send(context, values, request, UINT32_MAX);
438}
439
445static asciichat_error_t discovery_run(session_capture_ctx_t *capture, session_display_ctx_t *display, void *user_data) {
446 (void)user_data; // Unused
447
449 bool snapshot_mode = GET_OPTION(snapshot_mode);
450
451role_dispatch:
452 result = discovery_session_apply_handoff(g_discovery);
453 if (result != ASCIICHAT_OK)
454 return result;
455
456 // Wait for session to become active (host negotiation complete)
457 // This processes ACDS events until we have a determined role
458 // Snapshot capture requires negotiation to finish before its exit condition is honored.
459 // The snapshot delay will be honored once we transition to active state and start capturing
460 while (true) {
461 if (should_exit() && !snapshot_mode) {
462 return ASCIICHAT_OK;
463 }
464 result = discovery_session_process(g_discovery, 50 * NS_PER_MS_INT);
465 if (result != ASCIICHAT_OK && result != ERROR_NETWORK_TIMEOUT) {
466 log_error("Discovery session process failed %s", asciichat_error_format(NULL, result));
467 return result;
468 }
469
470 if (g_discovery->handoff_pending)
471 goto role_dispatch;
472 if (discovery_session_is_active(g_discovery)) {
473 break; // Session is active, role is determined
474 }
475 platform_sleep_ns(NS_PER_MS_INT);
476 }
477
478 // In snapshot mode, proceed to role handling even if should_exit() is true
479 // We'll check for exit conditions during the actual frame rendering phase
480 if (should_exit() && !snapshot_mode) {
481 log_info("Shutdown requested during discovery negotiation");
482 return ASCIICHAT_OK;
483 }
484
485 // Session is active - run based on our role
486 bool we_are_host = discovery_session_is_host(g_discovery);
487
488 if (we_are_host) {
489 // HOST ROLE: Capture own media, manage participants, mix and broadcast
490 log_info("Hosting session - capturing and broadcasting");
491
492 // Keep terminal logging enabled until a peer connects and we have video to render.
493 // This keeps the splash/log UI visible while waiting for peers instead of a blank screen.
494
495 // Get the host context already created and started during discovery negotiation
496 session_host_t *host = discovery_session_get_host(g_discovery);
497 if (!host) {
498 log_fatal("Failed to get session host from discovery");
499 return ERROR_INVALID_STATE;
500 }
501
502 // Set display context so host renders frames locally
503 asciichat_error_t display_result = session_host_set_display(host, display);
504 if (display_result != ASCIICHAT_OK) {
505 log_error("Failed to set display context on host: %d", display_result);
506 // Non-fatal - host can still render frames for broadcasting, just not locally
507 } else {
508 log_info("Display context set on host for local frame rendering");
509 }
510
511 // The passed capture context is set up for network mode (participant receiving frames).
512 // For host role, we need local media capture. Reuse the existing capture context
513 // which should have test pattern, webcam, or file configured.
514 // Note: session_client_like should have initialized this with the media source.
515
516 // Add memory participant for host's own media
517 uint32_t host_participant_id = session_host_add_memory_participant(host);
518 if (host_participant_id == 0) {
519 log_error("Failed to add memory participant for host");
520 // Host context is owned by discovery session - don't destroy
521 return ERROR_INVALID_STATE;
522 }
523
524 log_info("Host participating with ID %u", host_participant_id);
525
526 // The native host is also a media source. Own its capture worker for this
527 // role and feed the same memory participant used for local video.
528 session_audio_ctx_t *host_audio = NULL;
529 discovery_host_audio_capture_t host_capture = {.host = host, .participant_id = host_participant_id};
530 if (GET_OPTION(audio_enabled)) {
531 host_audio = session_audio_create(true);
532 if (!host_audio)
533 return SET_ERRNO(ERROR_AUDIO, "Failed to create host audio capture");
535 result = session_audio_start_capture(host_audio);
536 if (result != ASCIICHAT_OK) {
537 session_audio_destroy(host_audio);
538 return result;
539 }
540 host_capture.audio = host_audio;
541 atomic_store_bool(&host_capture.running, true);
542 result = platform_thread_create(&host_capture.thread, "host_audio_capture", discovery_host_audio_capture, &host_capture);
543 if (result != ASCIICHAT_OK) {
544 session_audio_destroy(host_audio);
545 return result;
546 }
547 host_capture.started = true;
549 }
550
551 // Start the render thread (handles video mixing and ASCII rendering for display)
552 result = session_host_start_render(host);
553 if (result != ASCIICHAT_OK) {
554 discovery_host_audio_join(&host_capture);
556 session_audio_destroy(host_audio);
557 log_error("Failed to start render thread: %d", result);
558 // Host context is owned by discovery session - don't destroy
559 return result;
560 }
561
562 // Main loop: capture own media and keep discovery responsive
563 while (discovery_session_is_active(g_discovery)) {
564 ASCII_OTEL_SCOPE(CLIENT_VIDEO_FRAME);
565 // Exit conditions:
566 // 1. Non-snapshot mode: check should_exit() (Ctrl+C, SIGTERM, any exit signal)
567 // 2. Snapshot mode: exit when should_exit() is true AND we've rendered at least one frame
568 // (to allow the full snapshot_delay to elapse while ignoring the snapshot timeout in should_exit)
569 // 3. Discovery session ended: always exit
570
571 if (should_exit()) {
572 // In snapshot mode, if we haven't rendered any frames yet, don't exit yet
573 // Wait until at least one frame has been displayed
574 if (!snapshot_mode || g_snapshot_first_frame_rendered) {
575 log_debug("Exit condition met (snapshot_mode=%d, first_frame_rendered=%d)", snapshot_mode, g_snapshot_first_frame_rendered ? 1 : 0);
576 break;
577 } else {
578 log_debug_every(5 * NS_PER_SEC_INT, "Waiting for first frame (snapshot_mode=true, first_frame_rendered=false)");
579 }
580 }
581
582 keyboard_key_t key = ui_input_read_key(UI_SCREEN_MEDIA);
583 if (key != KEY_NONE)
584 session_handle_keyboard_input(capture, display, key);
585 // Capture frame from local media (webcam, test pattern, file, etc.)
586 // The capture context is set up during session_client_like_run() and handles all media types
588 image_t *frame = session_capture_read_frame(capture);
589 asciichat_error_context_t capture_failure;
590 if (!frame && errno_peek_since(frame_scope, &capture_failure)) {
591 result = capture_failure.code;
592 break;
593 }
594 if (frame) {
595 log_debug_every(5 * NS_PER_SEC_INT, "Captured frame, injecting into host");
596 // Inject host's frame into mixer for broadcasting
597 result = session_host_inject_frame(host, host_participant_id, frame);
598 if (result == ASCIICHAT_OK)
600 if (result != ASCIICHAT_OK) {
601 LOG_ERRNO_IF_SET("Failed to inject host frame");
602 break;
603 }
604 } else {
605 log_debug_every(5 * NS_PER_SEC_INT, "No frame captured");
606 }
607
608 if (host_capture.started && !atomic_load_bool(&host_capture.running))
609 break;
610
611 // Keep discovery session responsive (NAT negotiations, migrations).
612 // This runs after a captured frame and must not add a fixed delay to
613 // the media cadence; session_capture_sleep_for_fps() is the sole frame
614 // pacing point in the host loop.
616 result = discovery_session_process(g_discovery, 0);
617 if (result != ASCIICHAT_OK && result != ERROR_NETWORK_TIMEOUT) {
618 log_error("Discovery session process failed %s", asciichat_error_format(NULL, result));
619 break;
620 }
621
622 if (result == ASCIICHAT_OK)
623 ASSERT_NO_ERRNO_SINCE(process_scope);
625 result = ASCIICHAT_OK;
626
627 // Frame rate limiting (60 FPS)
629 }
630
631 log_debug("Host role main loop exited (snapshot_mode=%d, first_frame_rendered=%d, session_active=%d)", snapshot_mode, g_snapshot_first_frame_rendered ? 1 : 0,
632 discovery_session_is_active(g_discovery) ? 1 : 0);
633
634 discovery_host_audio_join(&host_capture);
635 if (result == ASCIICHAT_OK && host_capture.result != ASCIICHAT_OK)
636 result = SET_ERRNO(host_capture.result, "Native host audio capture worker failed");
638 session_audio_destroy(host_audio);
639
640 // Stop render thread before returning (display will be destroyed by caller)
642
643 if (result != ASCIICHAT_OK)
644 return result;
645
646 if (should_exit()) {
647 return ASCIICHAT_OK;
648 }
649
650 if (g_discovery->handoff_pending) {
651 // A retained host re-enters this branch and registers fresh local media.
652 result = session_host_remove_client(host, host_participant_id);
653 if (result != ASCIICHAT_OK)
654 return result;
655 goto role_dispatch;
656 }
657
658 // If we reach here, discovery session is no longer active (role change)
659 if (!discovery_session_is_active(g_discovery)) {
660 log_info("Session ended or role changed");
661 return ASCIICHAT_OK;
662 }
663 } else {
665 acip_transport_t *transport = session_participant_get_transport(participant);
666 if (transport) {
667 bool quic_disconnected = false;
668 bool enable_audio = GET_OPTION(audio_enabled);
669 log_info("Discovery participant audio: %s", enable_audio ? "enabled" : "disabled");
670 uint64_t advertised_revision = UINT64_MAX;
671 terminal_size_t advertised = {.cols = GET_OPTION(width) > 0 ? GET_OPTION(width) : 80, .rows = GET_OPTION(height) > 0 ? GET_OPTION(height) : 24};
673 session_protocol_build_capabilities(advertised.cols, advertised.rows, &packet);
674 result = acip_send_capabilities(transport, &packet, sizeof(packet));
675 if (result != ASCIICHAT_OK)
676 return result;
677 result = acip_send_stream_start(transport, STREAM_TYPE_VIDEO | (enable_audio ? STREAM_TYPE_AUDIO : 0));
678 if (result != ASCIICHAT_OK)
679 return result;
680 discovery_video_receiver_t receiver = {
681 .network = session_participant_connection(g_discovery->participant_ctx), .transport = transport, .display = display, .running = {0}, .result = ASCIICHAT_OK};
683 &receiver.protocol, transport,
684 (session_protocol_media_t){.terminal_output = true, .on_frame = discovery_present_frame, .on_samples = discovery_play_samples, .decode_opus = discovery_decode_opus, .context = &receiver},
685 (acip_client_callbacks_t){.on_pong = discovery_host_pong, .app_ctx = g_discovery});
686 audio_context_t audio = {0};
687 session_connection_init(&receiver.connection, (session_connection_ops_t){discovery_media_interrupt, discovery_media_join, discovery_media_release}, &receiver);
688 NAMED_REGISTER_ATOMIC(&receiver.running, "discovery.media_running", NULL);
689 NAMED_REGISTER_ATOMIC(&receiver.connection.state, "discovery.media_state", NULL);
690 if (enable_audio) {
691 result = audio_init(&audio);
692 if (result != ASCIICHAT_OK)
693 goto media_cleanup;
694 receiver.audio = &audio;
695 session_capture_set_audio_context(capture, &audio);
697 bool has_media_audio = media_source_has_audio(local_source);
698 audio.capture_media_source = local_source;
699 audio.playback_only = !audio_should_enable_microphone(GET_OPTION(audio_capture_source), has_media_audio);
700 log_info("Discovery audio input: media=%d, microphone=%d", has_media_audio, audio_should_enable_microphone(GET_OPTION(audio_capture_source), has_media_audio));
702 config.flags.jitter_buffer = false;
704 if (!receiver.audio_pipeline) {
705 result = SET_ERRNO(ERROR_AUDIO, "Failed to create discovery audio pipeline");
706 goto media_cleanup;
707 }
708 audio_set_pipeline(&audio, receiver.audio_pipeline);
709 receiver.audio = &audio;
710 result = audio_start_duplex(&audio);
711 if (result != ASCIICHAT_OK) {
712 goto media_cleanup;
713 }
714 }
715 atomic_store_bool(&receiver.running, true);
716 result = platform_thread_create(&receiver.receiver_thread, "discovery_video_receive", discovery_video_receive_thread, &receiver);
717 if (result != ASCIICHAT_OK)
718 goto media_cleanup;
719 receiver.receiver_started = true;
720 if (enable_audio) {
721 result = platform_thread_create(&receiver.audio_thread, "discovery_audio_send", discovery_audio_send_thread, &receiver);
722 receiver.audio_started = result == ASCIICHAT_OK;
723 if (!receiver.audio_started)
724 atomic_store_bool(&receiver.running, false);
725 }
726 if (result != ASCIICHAT_OK)
727 goto media_cleanup;
728 result = session_connection_start(&receiver.connection);
729 if (result != ASCIICHAT_OK)
730 goto media_cleanup;
731 while (!should_exit() && discovery_session_is_active(g_discovery) && acip_transport_is_connected(transport) && atomic_load_bool(&receiver.running)) {
732 ASCII_OTEL_SCOPE(CLIENT_VIDEO_FRAME);
733 result = session_protocol_update_settings(&advertised, &advertised_revision, discovery_send_settings, transport);
734 if (result != ASCIICHAT_OK)
735 break;
736 keyboard_key_t key = ui_input_read_key(UI_SCREEN_MEDIA);
737 if (key != KEY_NONE)
738 session_handle_keyboard_input(capture, display, key);
739 uint64_t iteration_start = time_get_ns();
740 if (snapshot_mode && g_snapshot_first_frame_rendered_ns > 0 && time_ns_to_s(time_elapsed_ns(g_snapshot_first_frame_rendered_ns, iteration_start)) >= GET_OPTION(snapshot_delay)) {
741 signal_exit();
742 break;
743 }
744 uint64_t capture_start = time_get_ns();
746 image_t *frame = session_capture_read_frame(capture);
747 asciichat_error_context_t capture_failure;
748 if (!frame && errno_peek_since(frame_scope, &capture_failure)) {
749 result = capture_failure.code;
750 break;
751 }
752 uint64_t capture_end = time_get_ns();
753 uint64_t processing_start = capture_end;
754 uint64_t processing_end = processing_start;
755 uint64_t send_start = processing_start;
756 uint64_t send_end = send_start;
757 if (frame) {
758 image_t *processed = session_capture_process_for_transmission(capture, frame);
759 if (processed) {
760 processing_end = time_get_ns();
761 send_start = processing_end;
762 result = acip_send_image_frame(transport, processed->pixels, processed->w, processed->h, PIXEL_FORMAT_RGB);
763 send_end = time_get_ns();
764 image_destroy(processed);
765 if (result != ASCIICHAT_OK)
766 break;
767 }
768 }
769 if (processing_end == processing_start)
770 processing_end = time_get_ns();
771 if (frame && result == ASCIICHAT_OK)
773 uint64_t signaling_start = send_end;
774 // The capture scheduler owns the wait; signaling must not add another
775 // sleep to the media frame deadline.
776 result = discovery_session_process(g_discovery, 0);
777 uint64_t signaling_end = time_get_ns();
778 if (result != ASCIICHAT_OK && result != ERROR_NETWORK_TIMEOUT)
779 break;
780 uint64_t event_start = time_get_ns();
781 APP_CALLBACK_VOID(platform_pump_events);
782 uint64_t event_end = time_get_ns();
783 uint64_t elapsed = time_get_ns() - iteration_start;
784 if (elapsed > 50 * NS_PER_MS_INT) {
786 "Discovery media loop took %.1fms (capture=%.1fms process=%.1fms send=%.1fms signaling=%.1fms "
787 "events=%.1fms)",
788 (double)elapsed / 1e6, (double)(capture_end - capture_start) / 1e6, (double)(processing_end - processing_start) / 1e6, (double)(send_end - send_start) / 1e6,
789 (double)(signaling_end - signaling_start) / 1e6, (double)(event_end - event_start) / 1e6);
790 }
792 }
793 media_cleanup:
794 quic_disconnected = acip_transport_get_type(transport) == ACIP_TRANSPORT_QUIC && !acip_transport_is_connected(transport);
796 /* These workers borrow stack audio/display state. Retain it and retry a
797 * failed join before returning to the application/media cleanup. */
798 while (session_connection_stop(&receiver.connection) != ASCIICHAT_OK) {
799 LOG_ERRNO_IF_SET("Waiting for discovery media workers");
800 platform_sleep_ms(10);
801 }
802 NAMED_UNREGISTER(&receiver.running);
804 bool quic_recoverable = acip_transport_get_type(transport) == ACIP_TRANSPORT_QUIC && (quic_disconnected || g_discovery->handoff_pending || g_discovery->state == DISCOVERY_STATE_MIGRATING) &&
805 (g_discovery->state == DISCOVERY_STATE_ACTIVE || g_discovery->state == DISCOVERY_STATE_MIGRATING) &&
806 (receiver.result == ASCIICHAT_OK || receiver.result == ERROR_NETWORK || receiver.result == ERROR_NETWORK_TIMEOUT) &&
807 (result == ASCIICHAT_OK || result == ERROR_NETWORK || result == ERROR_NETWORK_TIMEOUT || (result == ERROR_INVALID_STATE && quic_disconnected));
808 if (!should_exit() && (g_discovery->session_type == SESSION_TYPE_WEBRTC || quic_recoverable)) {
809 if (!g_discovery->handoff_pending && g_discovery->state != DISCOVERY_STATE_MIGRATING) {
810 if (g_discovery->state == DISCOVERY_STATE_FAILED)
811 return g_discovery->error;
812 result = discovery_session_handle_host_disconnect(g_discovery, 1);
813 if (result != ASCIICHAT_OK)
814 return result;
815 }
816 goto role_dispatch;
817 }
818 if (receiver.result != ASCIICHAT_OK)
819 return receiver.result;
820 if (result != ASCIICHAT_OK && result != ERROR_NETWORK_TIMEOUT)
821 return result;
822 return ASCIICHAT_OK;
823 }
824 return SET_ERRNO(ERROR_INVALID_STATE, "Active discovery participant has no connection");
825 }
826
827 return result;
828}
829
830/* ============================================================================
831 * Main Discovery Mode Loop
832 * ============================================================================ */
833
834static asciichat_error_t discovery_prepare(void *user_data) {
835 (void)user_data;
836 return discovery_session_start(g_discovery);
837}
838
840int discovery_main(void) {
841
842 // Discovery-specific setup: initialize ACDS connection and session negotiation
843 // Note: Shared setup (keepawake, splash, terminal, capture, display, audio)
844 // is handled by session_client_like_run()
845
846 // Get session string from options (command-line argument)
847 const char *session_string = GET_OPTION(session_string);
848 bool is_initiator = (session_string == NULL || session_string[0] == '\0');
849
850 int port_int = GET_OPTION(port);
851
852 log_debug("Discovery: is_initiator=%d, port=%d", is_initiator, port_int);
853
854 char service_url_override[URL_BUFFER_SIZE];
855 const char *service_url = GET_OPTION(discovery_server);
856 if (GET_OPTION(discovery_port) != ACIP_DISCOVERY_DEFAULT_PORT) {
857 asciichat_error_t override_result = connection_endpoint_override_port(service_url, (uint16_t)GET_OPTION(discovery_port), service_url_override, sizeof(service_url_override));
858 if (override_result != ASCIICHAT_OK) {
859 log_fatal("Invalid --discovery-service URL for --discovery-service-port override");
860 return ERROR_USAGE;
861 }
862 service_url = service_url_override;
863 }
864
865 discovery_ui_state_t ui = {0};
866 asciichat_error_t ui_result = mutex_init(&ui.mutex, "discovery_ui");
867 if (ui_result != ASCIICHAT_OK)
868 return ui_result;
869
870 // Create discovery session configuration
871 discovery_config_t discovery_config = {
872 .acds_address = NULL,
873 .acds_port = ACIP_DISCOVERY_DEFAULT_PORT,
874 .acds_url = service_url,
875 .session_string = is_initiator ? NULL : session_string,
876 .password = GET_OPTION(password),
877 .local_port = (uint16_t)port_int,
878 .on_state_change = on_discovery_state_change,
879 .on_session_ready = on_session_ready,
880 .on_error = on_discovery_error,
881 .callback_user_data = &ui,
882 .should_exit_callback = discovery_capture_should_exit_adapter,
883 .exit_callback_data = NULL,
884 };
885
886 acip_websocket_runtime_t *websocket_runtime = NULL;
887 if (service_url && (strncmp(service_url, "ws://", 5) == 0 || strncmp(service_url, "wss://", 6) == 0)) {
888 asciichat_error_t runtime_result = acip_websocket_runtime_create(&websocket_runtime);
889 if (runtime_result != ASCIICHAT_OK) {
890 mutex_destroy(&ui.mutex);
891 return runtime_result;
892 }
893 }
894
895 // Create discovery session (stored in global for discovery_run() to access)
896 g_discovery = discovery_session_create(&discovery_config);
897 if (!g_discovery) {
898 mutex_destroy(&ui.mutex);
899 acip_websocket_runtime_destroy(&websocket_runtime);
900 log_fatal("Failed to create discovery session");
901 return ERROR_MEMORY;
902 }
903
904 splash_set_discovery_session(session_string, !is_initiator);
905
906 // No network interrupt callback needed - discovery session handles its own shutdown
908
909 /* ========================================================================
910 * Configure and Run Shared Client-Like Session Framework
911 * ========================================================================
912 * session_client_like_run() handles all shared initialization:
913 * - Terminal output management
914 * - Keepawake system
915 * - Splash screen lifecycle
916 * - Media source selection
917 * - FPS probing
918 * - Audio initialization
919 * - Display context creation
920 * - Proper cleanup ordering
921 *
922 * Discovery mode provides:
923 * - discovery_run() callback: NAT negotiation, role determination, media handling
924 * - discovery_keyboard_handler: interactive controls for participant role
925 */
926
928 .run_fn = discovery_run,
929 .prepare_fn = discovery_prepare,
930 .run_user_data = NULL,
932 .discovery = (void *)g_discovery, // Opaque pointer to discovery session
933 .custom_should_exit = NULL,
934 .exit_user_data = NULL,
935 .keyboard_handler = discovery_keyboard_handler,
936 .max_reconnect_attempts = 0, // Discovery doesn't retry - role is determined once
937 .should_reconnect_callback = NULL,
938 .reconnect_user_data = NULL,
939 .reconnect_delay_ms = 0,
940 .print_newline_on_tty_exit = false, // Server/participant manages cursor
941 };
942
943 log_debug("Discovery: calling session_client_like_run()");
944 asciichat_error_t session_result = session_client_like_run(&config);
945 log_debug("Discovery: session_client_like_run() returned %d", session_result);
946
947 // Cleanup discovery session
948 log_debug("Discovery: cleaning up");
949
950 if (g_discovery) {
951 discovery_session_stop(g_discovery);
952 while (discovery_session_destroy(g_discovery) != ASCIICHAT_OK) {
953 LOG_ERRNO_IF_SET("Waiting for discovery connection resources");
954 platform_sleep_ms(10);
955 }
956 g_discovery = NULL;
957 }
958
959 acip_websocket_runtime_destroy(&websocket_runtime);
961 char discovery_error[sizeof(ui.error)];
962 mutex_lock(&ui.mutex);
963 SAFE_STRNCPY(discovery_error, ui.error, sizeof(discovery_error));
964 asciichat_error_t discovery_error_code = ui.error_code;
965 mutex_unlock(&ui.mutex);
966
967 if (session_result != ASCIICHAT_OK || discovery_error[0]) {
969 NOTICE(WARNING, "DISCOVERY FAILED", "Discovery failed: %s", discovery_error[0] ? discovery_error : asciichat_error_format(NULL, session_result));
970 if (session_result == ASCIICHAT_OK)
971 session_result = discovery_error_code;
972 }
973 mutex_destroy(&ui.mutex);
974 return (session_result == ASCIICHAT_OK) ? 0 : (int)session_result;
975}
ascii-chat Discovery Service (ACDS) Protocol Message Formats
Application-level callbacks for library code.
#define APP_CALLBACK_VOID(callback_name)
bool errno_peek_since(asciichat_errno_scope_t scope, asciichat_error_context_t *out)
void errno_scope_end(asciichat_errno_scope_t scope, asciichat_errno_outcome_t outcome)
asciichat_errno_scope_t errno_checkpoint(void)
asciichat_errno_scope_t errno_scope_begin(void)
const char * asciichat_error_format(const char *message, asciichat_error_t code)
#define SET_ERRNO(code,...)
#define ASSERT_NO_ERRNO_SINCE(scope)
@ ASCIICHAT_ERRNO_HANDLED
#define LOG_ERRNO_IF_SET(message)
void atomic_store_bool(atomic_t *a, bool value)
Atomically store a boolean value.
bool atomic_load_bool(atomic_t *a)
Atomic pointer wrapper.
#define OPUS_FRAME_SAMPLES
#define CLIENT_AUDIO_PIPELINE_FRAME_MS
#define AUDIO_OPUS_MAX_DECODE_SAMPLES
#define AUDIO_SAMPLE_RATE
Definition audio/limits.h:8
#define AUDIO_CHANNELS
Definition audio/limits.h:9
#define CLIENT_AUDIO_PIPELINE_MAX_OPUS_PACKET
asciichat_error_t session_client_like_run(const session_client_like_config_t *config)
Shared initialization and teardown for client-like modes (mirror, client, discovery).
struct session_client_like_config session_client_like_config_t
@ SESSION_CLIENT_LIKE_KIND_DISCOVERY
Definition client_like.h:66
int client_audio_pipeline_playback(client_audio_pipeline_t *pipeline, const uint8_t *opus_in, int opus_len, float *output, int num_samples)
Decode Opus packet and process for playback.
client_audio_pipeline_t * client_audio_pipeline_create(const client_audio_pipeline_config_t *config)
Create and initialize a client audio pipeline.
client_audio_pipeline_config_t client_audio_pipeline_config_for_source(bool has_media_audio)
int client_audio_pipeline_capture(client_audio_pipeline_t *pipeline, const float *input, int num_samples, uint8_t *opus_out, int max_opus_len)
Process captured audio and encode to Opus.
void client_audio_pipeline_destroy(client_audio_pipeline_t *pipeline)
Destroy a client audio pipeline.
Unified client-side audio processing pipeline.
void session_capture_set_audio_context(session_capture_ctx_t *ctx, void *audio_ctx)
Set the audio context for playback control.
void session_capture_complete_open(session_capture_ctx_t *ctx, uint64_t epoch)
uint64_t session_capture_source_epoch(session_capture_ctx_t *ctx)
📹 Unified media capture abstraction for session-based video sources
asciichat_error_t session_protocol_update_settings(terminal_size_t *advertised, uint64_t *advertised_revision, session_protocol_send_settings_fn send, void *context)
asciichat_error_t session_protocol_dispatch(session_protocol_t *protocol, packet_type_t type, const void *payload, size_t length)
void session_protocol_init(session_protocol_t *protocol, acip_transport_t *transport, session_protocol_media_t media, acip_client_callbacks_t control)
void session_protocol_build_capabilities(unsigned short width, unsigned short height, terminal_capabilities_packet_t *packet)
asciichat_error_t connection_endpoint_override_port(const char *input, uint16_t port, char *output, size_t output_size)
Shared endpoint normalization for TCP and WebSocket connections.
Named object registry for debugging — log identifiable resource names.
#define DISCOVERY_MAIN_ERROR_BUFFER_SIZE
int discovery_main(void)
Discovery mode entry point for unified binary.
ascii-chat Discovery Mode Entry Point Header
🔄 Network byte order conversion helpers
unsigned int height
Definition fft.c:24
unsigned int width
Definition fft.c:24
bool audio_should_enable_microphone(audio_capture_source_t source, bool has_media_audio)
Determine if microphone should be enabled based on audio source setting and media state.
size_t audio_ring_buffer_read(audio_ring_buffer_t *rb, float *data, size_t samples)
Read audio samples from ring buffer.
asciichat_error_t audio_init(audio_context_t *ctx)
Initialize audio context and PortAudio.
size_t audio_ring_buffer_available_read(audio_ring_buffer_t *rb)
Get number of samples available for reading.
asciichat_error_t audio_start_duplex(audio_context_t *ctx)
Start full-duplex audio (simultaneous capture and playback).
void audio_destroy(audio_context_t *ctx)
Destroy audio context and clean up resources.
asciichat_error_t audio_write_samples(audio_context_t *ctx, const float *buffer, int num_samples)
Write audio samples to playback buffer.
void audio_set_pipeline(audio_context_t *ctx, void *pipeline)
Set audio pipeline for echo cancellation.
unsigned short uint16_t
unsigned int uint32_t
#define SAFE_STRNCPY(dst, src, size)
unsigned long long uint64_t
unsigned char uint8_t
#define NAMED_REGISTER_ATOMIC(a, name, parent_ptr)
Register an atomic_t with automatic format specifier.
#define NAMED_UNREGISTER(ptr)
Unregister a pointer.
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ERROR_NETWORK
Definition error_codes.h:76
@ ERROR_AUDIO
Definition error_codes.h:66
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_USAGE
Definition error_codes.h:52
@ ERROR_NETWORK_TIMEOUT
Definition error_codes.h:79
#define URL_BUFFER_SIZE
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
#define log_fatal(...)
Log a FATAL message.
Definition log/log.h:640
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
void log_set_terminal_output(bool enabled)
Control stderr output to terminal.
bool media_source_has_audio(media_source_t *source)
Check if media source has audio stream.
Definition source.c:774
#define ACIP_DISCOVERY_DEFAULT_PORT
Discovery server default port (use OPT_ACDS_PORT_INT_DEFAULT from options.h).
Definition acds.h:1102
@ SESSION_TYPE_WEBRTC
WebRTC P2P mesh with STUN/TURN relay.
Definition acds.h:151
#define NS_PER_SEC_INT
Definition time.h:173
#define NS_PER_MS_INT
Definition time.h:172
uint64_t time_elapsed_ns(uint64_t start_ns, uint64_t end_ns)
Calculate elapsed time with wraparound safety.
Definition time.c:117
#define US_PER_SEC_INT
Definition time.h:177
#define STREAM_TYPE_VIDEO
Video stream.
Definition packet.h:1012
#define STREAM_TYPE_AUDIO
Audio stream.
Definition packet.h:1013
packet_type_t
Network protocol packet type enumeration.
Definition packet.h:315
#define GET_OPTION(field)
Definition options.h:1333
struct options_state options_t
Immutable, RCU-published snapshot of the application's runtime configuration.
#define PIXEL_FORMAT_RGB
Packed RGB24 pixel format used by ACIP image-frame senders.
void session_host_stop_render(session_host_t *host)
Stop media rendering thread.
Definition host.c:1619
struct session_audio_ctx session_audio_ctx_t
Opaque session audio context handle.
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.
Definition host.c:1301
size_t session_audio_read_captured(session_audio_ctx_t *ctx, float *buffer, size_t num_samples)
Read captured audio samples.
asciichat_error_t session_audio_start_capture(session_audio_ctx_t *ctx)
Start audio capture (microphone input).
struct session_participant session_participant_t
Client session state spanning connection, transport, media workers, and callbacks.
struct session_display_ctx session_display_ctx_t
session display config is intentionally a small, concrete record. Fields such as snapshot_mode,...
image_t * session_capture_process_for_transmission(session_capture_ctx_t *ctx, image_t *frame)
Process a frame for network transmission (resize if needed).
void session_audio_destroy(session_audio_ctx_t *ctx)
Destroy session audio context and free resources.
struct session_host session_host_t
Opaque session host handle.
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.
Definition host.c:1251
acip_transport_t * session_participant_get_transport(session_participant_t *p)
Get the current transport for the participant.
uint32_t session_host_add_memory_participant(session_host_t *host)
Add a memory participant (host's own media).
Definition host.c:1175
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.
Definition host.c:1567
void session_handle_keyboard_input(session_capture_ctx_t *capture, session_display_ctx_t *display, keyboard_key_t key)
Handle keyboard input in a session.
struct session_capture_ctx session_capture_ctx_t
session capture config keeps the values that move through the subsystem: type, path,...
void session_display_render_frame(session_display_ctx_t *ctx, const char *frame_data)
Render an ASCII frame to the terminal.
image_t * session_capture_read_frame(session_capture_ctx_t *ctx)
Read the next video frame from the capture source.
struct acip_transport acip_transport_t
Forward declaration of ACIP transport.
Definition host.h:508
session_audio_ctx_t * session_audio_create(bool is_host)
Create a new session audio context.
asciichat_error_t session_host_remove_client(session_host_t *host, uint32_t client_id)
Remove a client by ID.
Definition host.c:1342
void * session_capture_get_media_source(session_capture_ctx_t *ctx)
Get the underlying media source from capture context.
void session_capture_sleep_for_fps(session_capture_ctx_t *ctx)
Sleep to maintain target frame rate.
asciichat_error_t session_host_start_render(session_host_t *host)
Start media rendering thread (video mixing and audio distribution).
Definition host.c:1582
void image_destroy(image_t *image)
Destroy an image allocated with image_new().
🏠 Server-side session hosting abstraction
🔊 Audio Capture and Playback Interface for ascii-chat
ACIP client-side protocol API.
struct acip_websocket_runtime acip_websocket_runtime_t
@ ACIP_TRANSPORT_QUIC
QUIC/UDP (future).
struct network_connection network_connection_t
Common utilities and helpers for option parsing across all modes.
@ STATS_DURATION_CONNECTION_SETUP
🎮 Keyboard input handler for interactive session controls
asciichat_error_t acip_send_image_frame(acip_transport_t *transport, const void *pixel_data, uint32_t width, uint32_t height, uint32_t pixel_format)
Send image frame to server (client → server).
asciichat_error_t acip_send_stream_start(acip_transport_t *transport, uint8_t stream_types)
Request to start media streaming (client → server).
asciichat_error_t acip_send_capabilities(acip_transport_t *transport, const void *cap_data, size_t cap_len)
Send terminal capabilities to server (client → server).
asciichat_error_t acip_settings_send(acip_transport_t *transport, const options_t *values, uint32_t request, uint32_t expected_revision)
asciichat_error_t network_connection_run(network_connection_t *c, const network_connection_callbacks_t *callbacks, void *context)
void stats_duration_record(stats_scope_t *scope, stats_duration_id_t id, uint64_t elapsed_ns)
📝 Logging API with multiple log levels and terminal output control
#define log_debug_every(interval_us, fmt,...)
Rate-limited DEBUG logging.
Definition log/log.h:743
#define log_warn_every(interval_us, fmt,...)
Rate-limited WARN logging.
Definition log/log.h:749
void signal_exit(void)
Definition main.c:252
bool should_exit(void)
Definition main.c:248
void set_interrupt_callback(void(*cb)(void))
Definition main.c:272
Global application exit and signal handling API.
#define NOTICE(severity, title,...)
Definition notice.h:56
⚙️ Unified options parsing system for ascii-chat with builder pattern and lock-free access
#define ASCII_OTEL_SCOPE(id)
Definition otel.h:77
network_connection_t * session_participant_connection(session_participant_t *p)
👤 Client-side session participation abstraction
bool g_snapshot_first_frame_rendered
void stats_runtime_connection_state(const char *state)
Definition runtime.c:132
stats_scope_t * stats_runtime_scope(void)
Definition runtime.c:78
asciichat_error_t acip_send_audio_opus_batch(acip_transport_t *transport, const void *opus_data, size_t opus_len, const uint16_t *frame_sizes, uint32_t frame_count, uint32_t sample_rate, uint32_t frame_duration)
Send batched Opus-encoded audio frames.
Definition send.c:338
ACIP shared/bidirectional packet sending functions.
void splash_set_discovery_session(const char *session, bool joining)
Definition splash.c:95
void splash_clear_discovery_session(void)
Definition splash.c:105
Intro and status screen display for ascii-chat with animated rainbow effects.
void * session_audio_get_context(session_audio_ctx_t *ctx)
void session_audio_set_capture_source(session_audio_ctx_t *ctx, void *source)
🔊 Session-level audio coordination wrapper
asciichat_error_t session_connection_stop(session_connection_t *connection)
void session_connection_init(session_connection_t *connection, session_connection_ops_t ops, void *context)
asciichat_error_t session_connection_start(session_connection_t *connection)
void session_connection_interrupt_transport(acip_transport_t *transport)
🖥️ Unified terminal display abstraction for session-based rendering
uint64_t g_snapshot_first_frame_rendered_ns
Centralized render loop abstraction for all display modes.
bool discovery_session_is_active(const discovery_session_t *session)
Check if session is active (call in progress).
void discovery_session_stop(discovery_session_t *session)
Stop the discovery session.
bool discovery_session_is_host(const discovery_session_t *session)
Check if we are the host.
void discovery_session_host_pong(discovery_session_t *session)
discovery_session_t * discovery_session_create(const discovery_config_t *config)
Configuration for discovery session.
asciichat_error_t discovery_session_start(discovery_session_t *session)
Start the discovery session.
session_host_t * discovery_session_get_host(discovery_session_t *session)
Get host context (if we are host).
asciichat_error_t discovery_session_process(discovery_session_t *session, int64_t timeout_ns)
Process session events (call in main loop).
asciichat_error_t discovery_session_handle_host_disconnect(discovery_session_t *session, uint32_t disconnect_reason)
Report host loss and await the authoritative ACDS handoff decision. Records the local recovery deadli...
asciichat_error_t discovery_session_apply_handoff(discovery_session_t *session)
Replace the old role after a committed handoff and media-worker shutdown. Releases borrowed-role reso...
asciichat_error_t discovery_session_destroy(discovery_session_t *session)
Destroy discovery session and free resources.
session_participant_t * discovery_session_get_participant(discovery_session_t *session)
Get participant context (if we are participant).
discovery_state_t
Discovery session state.
@ DISCOVERY_STATE_JOINING_SESSION
Joining existing session.
@ DISCOVERY_STATE_ACTIVE
Session active (call in progress).
@ DISCOVERY_STATE_MIGRATING
Host migration in progress.
@ DISCOVERY_STATE_NEGOTIATING
NAT negotiation in progress.
@ DISCOVERY_STATE_CONNECTING_HOST
Connecting to host as participant.
@ DISCOVERY_STATE_CREATING_SESSION
Creating new session.
@ DISCOVERY_STATE_CONNECTING_ACDS
Connecting to ACDS.
@ DISCOVERY_STATE_WAITING_PEER
Waiting for peer to join (initiator).
@ DISCOVERY_STATE_FAILED
Session failed.
@ DISCOVERY_STATE_STARTING_HOST
Starting as host.
Client-side packet handler callbacks.
Definition handlers.h:55
The wire metadata for one rendered ASCII frame. width and height describe the terminal grid,...
Definition packet.h:916
When code needs to work with asciichat errno snapshot, it keeps total, copied here instead of scatter...
Atomic value wrapper for integral/boolean types.
Definition atomic.h:76
When code needs to work with audio device info, it keeps index, max_input_channels,...
void * capture_media_source
Borrowed local media audio; configure before starting duplex.
audio_ring_buffer_t * capture_buffer
OLD: Worker → Network (will become processed_capture_rb).
bool playback_only
True for playback-only mode (mirror), skip microphone capture.
Pipeline configuration parameters.
client_audio_pipeline_flags_t flags
Client audio pipeline state.
Configuration for discovery session.
discovery video receiver is intentionally a small, concrete record. Fields such as connection,...
session_audio_ctx_t * audio
Discovery session context.
This is the handoff point for discovery host audio capture. Callers fill host, audio,...
asciichat_error_t error_code
acip_transport_t * transport
platform_thread_t receiver_thread
session_protocol_t protocol
client_audio_pipeline_t * audio_pipeline
platform_thread_t audio_thread
session_display_ctx_t * display
session_connection_t connection
network_connection_t * network
int h
Image height in pixels (must be > 0).
rgb_pixel_t * pixels
Pixel data array (width * height RGB pixels, row-major order).
int w
Image width in pixels (must be > 0).
Media source for video and audio capture.
Definition source.c:47
Callbacks and operations used by network connection callbacks. Packet payloads are borrowed until ret...
acip_transport_t * transport
Groups the callbacks and caller data for session connection ops. The owner invokes these function poi...
session protocol media keeps the values that move through the subsystem: context, terminal_output,...
Terminal capabilities packet structure (Packet Type 5).
Definition packet.h:1093
⏱️ High-precision timing utilities using sokol_time.h and uthash
void ui_controller_title_activity(ui_title_activity_t activity)
void ui_controller_title_ready(void)
@ UI_TITLE_CONNECTING
@ UI_TITLE_WAITING_PEERS
@ UI_TITLE_CREATING_SESSION
@ UI_TITLE_ACTIVITY_IDLE
@ UI_TITLE_RECONNECTING
@ UI_TITLE_JOINING_SESSION
@ UI_SCREEN_MEDIA
keyboard_key_t ui_input_read_key(ui_screen_t screen)
Definition tui/input.c:346
asciichat_error_t acip_websocket_runtime_create(acip_websocket_runtime_t **out)
void acip_websocket_runtime_destroy(acip_websocket_runtime_t **runtime)