ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
splash.c
Go to the documentation of this file.
1
16
17/* Storage capacities in elements; text buffers include the terminating NUL. */
18#define TUI_SPLASH_UPDATE_NOTIFICATION_BUFFER_SIZE 1024
19
31#include "session/display.h"
34#include <libplatform/lifecycle.h>
35#include <ascii-chat/util/ip.h>
38#include <libplatform/terminal.h>
39#include <libplatform/keyboard.h>
40#include <libplatform/system.h>
41#include <libplatform/compiler.h>
42#include <libplatform/system.h>
43#include <libplatform/terminal.h>
48#include <options/options.h>
49#include <libflags/explicit.h>
50#include <ascii-chat/log/log.h>
51#include <ascii-chat/common.h>
52
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <stdint.h>
57#include <libplatform/atomic.h>
58#include <time.h>
59#include <unistd.h>
60#include <fcntl.h>
61
62// ============================================================================
63// ASCII Art and Constants
64// ============================================================================
65
66// Global update notification (set via splash_set_update_notification)
67static char g_update_notification[TUI_SPLASH_UPDATE_NOTIFICATION_BUFFER_SIZE] = {0};
68static mutex_t g_update_notification_mutex;
69static lifecycle_t g_update_notification_lifecycle = LIFECYCLE_INIT_MUTEX(&g_update_notification_mutex);
70
72
73static discovery_splash_t g_discovery_splash;
74static mutex_t g_discovery_splash_mutex;
75static lifecycle_t g_discovery_splash_lifecycle = LIFECYCLE_INIT_MUTEX(&g_discovery_splash_mutex);
76
77static void splash_mutex_init(lifecycle_t *lifecycle, mutex_t *mutex, const char *name) {
78 for (;;) {
79 if (lifecycle_init_once(lifecycle)) {
80 mutex_init(mutex, name);
81 lifecycle_init_commit(lifecycle);
82 return;
83 }
84 if (lifecycle_is_initialized(lifecycle))
85 return;
86 // A losing caller must not enter the native lock while its owner initializes it.
87 platform_sleep_ms(1);
88 }
89}
90
91static void discovery_splash_init(void) {
92 splash_mutex_init(&g_discovery_splash_lifecycle, &g_discovery_splash_mutex, "discovery_splash");
93}
94
95void splash_set_discovery_session(const char *session, bool joining) {
96 discovery_splash_init();
97 mutex_lock(&g_discovery_splash_mutex);
98 g_discovery_splash.enabled = true;
99 g_discovery_splash.joining = joining;
100 ui_controller_title_discovery(session && session[0], joining);
101 SAFE_STRNCPY(g_discovery_splash.session_string, session ? session : "", sizeof(g_discovery_splash.session_string));
102 mutex_unlock(&g_discovery_splash_mutex);
103}
104
106 discovery_splash_init();
107 mutex_lock(&g_discovery_splash_mutex);
108 memset(&g_discovery_splash, 0, sizeof(g_discovery_splash));
110 mutex_unlock(&g_discovery_splash_mutex);
111}
112
113static discovery_splash_t discovery_splash_snapshot(void) {
114 discovery_splash_init();
115 mutex_lock(&g_discovery_splash_mutex);
116 discovery_splash_t snapshot = g_discovery_splash;
117 mutex_unlock(&g_discovery_splash_mutex);
118 return snapshot;
119}
120
121// ============================================================================
122// Log Management
123// ============================================================================
124
125void splash_log_init(void) {
127 if (buf) {
129 }
130}
131
136
140
144static struct {
145 atomic_t is_running; // true while animation should continue
146 atomic_t should_stop; // set to true when splash should stop
147 atomic_t thread_created; // true if monitor thread was successfully created
148 platform_thread_t monitor_thread; // monitor thread handle
149 uint64_t start_time_ns; // when splash was started (for minimum display time)
150 atomic_t intro_done_time_ns; // when splash_intro_done() was called
151} g_splash_state = {.is_running = {0}, .should_stop = {0}, .thread_created = {0}, .start_time_ns = 0, .intro_done_time_ns = {0}};
152
153// ============================================================================
154// Header Rendering (callback for terminal_screen)
155// ============================================================================
156
161
167static void build_connection_target(char *buffer, size_t buffer_size) {
168 if (!buffer || buffer_size == 0) {
169 return;
170 }
171 buffer[0] = '\0';
172
173 // Mirror mode - no network connection
174 asciichat_mode_t mode = GET_OPTION(detected_mode);
175 if (mode == MODE_MIRROR) {
176 const char *media_url = GET_OPTION(media_url);
177 const char *media_file = GET_OPTION(media_file);
178
179 if (media_url && media_url[0] != '\0') {
180 snprintf(buffer, buffer_size, "Loading from URL...");
181 } else if (media_file && media_file[0] != '\0') {
182 snprintf(buffer, buffer_size, "Loading from file...");
183 } else {
184 snprintf(buffer, buffer_size, "Initializing...");
185 }
186 return;
187 }
188
189 // Check if we have a session string (discovery mode)
190 const char *session = GET_OPTION(session_string);
191 if (session && session[0] != '\0') {
192 snprintf(buffer, buffer_size, "Connecting to session: %s", session);
193 return;
194 }
195
196 // Check if we have an address (client mode)
197 const char *addr = GET_OPTION(address);
198
199 if (addr && addr[0] != '\0') {
200 // Use IP utility to classify the connection type
201 const char *ip_type = get_ip_type_string(addr);
202
203 // NOLINTNEXTLINE(bugprone-branch-clone)
204 if (strcmp(ip_type, "Localhost") == 0) {
205 snprintf(buffer, buffer_size, "Connecting to localhost...");
206 } else if (strcmp(ip_type, "LAN") == 0) {
207 snprintf(buffer, buffer_size, "Connecting to %s (LAN)", addr);
208 } else if (strcmp(ip_type, "Internet") == 0) {
209 snprintf(buffer, buffer_size, "Connecting to %s (Internet)", addr);
210 } else if (strcmp(addr, "localhost") == 0) {
211 // Hostname "localhost" not detected by IP util
212 snprintf(buffer, buffer_size, "Connecting to localhost...");
213 } else {
214 // Unknown or hostname
215 snprintf(buffer, buffer_size, "Connecting to %s", addr);
216 }
217 return;
218 }
219
220 // Fallback if no connection info available
221 snprintf(buffer, buffer_size, "Initializing...");
222}
223
238// ============================================================================
239// Public API
240// ============================================================================
241
242bool splash_should_display(bool is_intro) {
243 // Check option flags (display splash if enabled, regardless of TTY for testing)
244 if (is_intro) {
245 // Allow splash in snapshot mode if loading from URL/file (has loading time)
246 // Skip splash only for quick webcam snapshots (unless explicitly enabled)
247 bool splash_screen_opt = GET_OPTION(splash_screen);
248 bool splash_explicitly_set = flags_explicit_state_was_set("splash-screen");
249 bool is_snapshot = GET_OPTION(snapshot_mode);
250 bool has_media = (GET_OPTION(media_url) && strlen(GET_OPTION(media_url)) > 0) || (GET_OPTION(media_file) && strlen(GET_OPTION(media_file)) > 0);
251
252 // Show splash if enabled, but in snapshot mode only if:
253 // 1. Has media file/URL, OR
254 // 2. Explicitly enabled with --splash-screen=true
255 bool should_display = splash_screen_opt && (!is_snapshot || has_media || splash_explicitly_set);
256 // Show splash if:
257 // 1. Not in snapshot mode, OR
258 // 2. In snapshot mode but loading from URL/file (needs splash during load)
259 return should_display;
260 } else {
261 return GET_OPTION(status_screen);
262 }
263}
264
268static void render_splash_header(frame_buffer_t *buffer, terminal_size_t size, void *data) {
271 if (animation)
272 view.animation = *animation;
273 ui_session_splash_render(buffer, size, &view);
274}
275
276static void splash_help(terminal_size_t size, const void *snapshot) {
277 (void)snapshot;
278 terminal_size_t minimum;
279 char *text = ui_session_help_render(size, false, false, &minimum);
280 if (text) {
281 ui_controller_write(STDOUT_FILENO, text, strlen(text));
282 SAFE_FREE(text);
283 }
284}
285
286static void *splash_monitor_thread(void *arg) {
287 (void)arg;
288 bool keyboard_enabled = terminal_is_interactive();
289 bool use_colors = terminal_should_color_output(STDOUT_FILENO, options_terminal_settings());
290 splash_header_ctx_t previous = {0};
291 bool published = false;
292 while (!atomic_load_bool(&g_splash_state.should_stop) && !shutdown_is_requested()) {
293 uint64_t now = time_get_ns();
294 if (atomic_load_u64(&g_splash_state.intro_done_time_ns) && now - g_splash_state.start_time_ns >= 2 * NS_PER_SEC_INT)
295 break;
296 if (keyboard_enabled) {
297 keyboard_key_t key = ui_input_read_key(UI_SCREEN_SPLASH);
299 continue;
300 } else if (key == KEY_BACKTICK) {
302 } else if (discovery_splash_snapshot().enabled && key != ']' && key != KEY_QUESTION && ui_controller_current_screen() != UI_SCREEN_LOGS)
303 key = KEY_NONE;
305 // Search consumed the key.
306 } else if (key == ']') {
308 } else if (key == KEY_QUESTION || (key == KEY_ESCAPE && ui_controller_current_screen() == UI_SCREEN_HELP)) {
311 } else {
312 terminal_size_t minimum;
313 char *text = ui_session_help_render(ui_controller_size(), false, false, &minimum);
314 if (text) {
315 const bool snapshot = true;
316 ui_controller_submit(UI_SCREEN_HELP, STDOUT_FILENO, minimum, splash_help, &snapshot, sizeof(snapshot));
317 SAFE_FREE(text);
318 }
319 }
320 } else if (key == KEY_ESCAPE && ui_controller_current_screen() == UI_SCREEN_LOGS) {
322 } else if (key == KEY_ESCAPE) {
325 else
326 break;
327 }
328 }
329 splash_header_ctx_t view = {.discovery = discovery_splash_snapshot(), .use_colors = use_colors};
330 splash_mutex_init(&g_update_notification_lifecycle, &g_update_notification_mutex, "update_notification");
331 mutex_lock(&g_update_notification_mutex);
332 SAFE_STRNCPY(view.update_notification, g_update_notification, sizeof(view.update_notification));
333 mutex_unlock(&g_update_notification_mutex);
334 build_connection_target(view.connection_target, sizeof(view.connection_target));
335 bool should_render = terminal_is_interactive() || flags_explicit_state_was_set("splash-screen");
336 // Only publish model changes. The presentation runtime owns the animation
337 // clock while this monitor handles startup and input.
338 if (should_render && (!published || memcmp(&view, &previous, sizeof(view)))) {
339 terminal_screen_config_t config = {
340 .screen = UI_SCREEN_SPLASH,
341 .output_fd = platform_isatty(STDOUT_FILENO) ? STDOUT_FILENO : STDERR_FILENO,
342 .user_data_size = sizeof(view),
343 .minimum_cols = view.discovery.enabled ? 2 : 52,
344 .fixed_header_lines = view.discovery.enabled ? 0 : (view.update_notification[0] ? 9 : 8),
345 .render_header = render_splash_header,
346 .user_data = &view,
347 .show_logs = !view.discovery.enabled,
348 .hide_cursor = view.discovery.enabled,
349 };
350 terminal_screen_render(&config);
351 previous = view;
352 published = true;
353 }
354 platform_sleep_ms(16);
355 }
356 // Keep the startup frame until a URL-backed mirror has a media frame ready.
357 // Its capture may still be resolving a remote source after this monitor stops.
358 const char *media_url = GET_OPTION(media_url);
359 const char *render_file = GET_OPTION(render_file);
360 bool binary_stdout = GET_OPTION(render_kitty) || (render_file && (strcmp(render_file, "-") == 0 || strcmp(render_file, "pipe:") == 0 || strcmp(render_file, "--kitty") == 0));
361 bool retain_for_media = GET_OPTION(detected_mode) == MODE_MIRROR && media_url && media_url[0] && atomic_load_u64(&g_splash_state.intro_done_time_ns) != 0 && terminal_is_stdout_tty() &&
362 !binary_stdout && !GET_OPTION(snapshot_mode) && !shutdown_is_requested();
363 if (!retain_for_media)
366 atomic_store_bool(&g_splash_state.is_running, false);
367 return NULL;
368}
369
371 (void)ctx; // Not needed - display context is not actively used
372
373 // Check if splash should display
374 if (!splash_should_display(true)) {
375 return 0;
376 }
377
378 discovery_splash_t discovery = discovery_splash_snapshot();
379 if (discovery.enabled && (!terminal_is_interactive() || !terminal_is_stdout_tty() || GET_OPTION(snapshot_mode))) {
380 return 0;
381 }
382 if (atomic_load_bool(&g_splash_state.thread_created))
383 return 0;
384
385 // Redirect splash screen to stderr when stdout is piped (not a TTY).
386 // This keeps stdout clean for frame data while splash goes to stderr.
387 // Uses platform_isatty() so non-desktop platforms (iOS, WASM) can override.
388 if (!platform_isatty(STDOUT_FILENO)) {
389 terminal_screen_set_output_fd(STDERR_FILENO);
390 }
391
392 // Initialize log buffer (same pattern as server_status)
394
395 // Clear log buffer for clean slate
397
398 // Set running flag
399 atomic_store_bool(&g_splash_state.is_running, true);
400 atomic_store_bool(&g_splash_state.should_stop, false);
401 atomic_store_u64(&g_splash_state.intro_done_time_ns, 0);
402 g_splash_state.start_time_ns = time_get_ns();
403
404 // Start monitor thread (only create once)
405 bool expected_false = false;
406 if (!atomic_cas_bool(&g_splash_state.thread_created, &expected_false, true)) {
407 return 0;
408 }
409
410 int err = platform_thread_create(&g_splash_state.monitor_thread, "splash_monitor", splash_monitor_thread, NULL);
411 if (err != ASCIICHAT_OK) {
412 log_warn("Failed to create splash monitor thread: error=%d", err);
413 atomic_store_bool(&g_splash_state.thread_created, false);
414 atomic_store_bool(&g_splash_state.is_running, false);
415 return 0;
416 }
417
418 return 0; // ASCIICHAT_OK
419}
420
422 atomic_store_u64(&g_splash_state.intro_done_time_ns, time_get_ns());
423 if (discovery_splash_snapshot().enabled || (GET_OPTION(snapshot_mode) && GET_OPTION(snapshot_delay) == 0.0))
424 atomic_store_bool(&g_splash_state.should_stop, true);
425 // The monitor retires the splash snapshot before clearing is_running. Keep
426 // thread_created set until splash_wait_for_animation() joins that monitor.
427
428 return 0;
429}
430
432 // No-op: stderr suppression is no longer used
433 // Logging works naturally through session_log_buffer
434}
435
437 // No-op: display context is no longer cached
438}
439
441 // Check if splash animation is currently rendering
442 // Used to prevent ASCII art from rendering while splash is animating
443 return atomic_load_bool(&g_splash_state.is_running);
444}
445
447 if (!atomic_load_bool(&g_splash_state.thread_created))
448 return;
449
450 // Keep terminal ownership until the writer finishes, but allow shutdown to
451 // proceed if an undrained output pipe blocks the monitor thread. Polling
452 // also handles shutdown requested after the normal handoff has begun, and
453 // avoids platforms whose timed thread join falls back to a blocking join.
454 uint64_t shutdown_started_ns = 0;
455 while (atomic_load_bool(&g_splash_state.is_running)) {
456 if (shutdown_is_requested()) {
457 atomic_store_bool(&g_splash_state.should_stop, true);
458 uint64_t now = time_get_ns();
459 if (shutdown_started_ns == 0)
460 shutdown_started_ns = now;
461 if (now - shutdown_started_ns >= 100 * NS_PER_MS_INT)
462 return;
463 }
464 platform_sleep_ms(10);
465 }
466
467 // The monitor clears is_running after retiring its presentation snapshot.
468 asciichat_error_t err = thread_join(&g_splash_state.monitor_thread, NULL);
469 if (err != ASCIICHAT_OK) {
470 log_warn("Splash animation join failed: %s", asciichat_error_format(NULL, err));
471 return;
472 }
473 atomic_store_bool(&g_splash_state.thread_created, false);
474}
475
476void splash_set_update_notification(const char *notification) {
477 splash_mutex_init(&g_update_notification_lifecycle, &g_update_notification_mutex, "update_notification");
478 mutex_lock(&g_update_notification_mutex);
479
480 if (!notification || notification[0] == '\0') {
481 g_update_notification[0] = '\0';
482 log_debug("Cleared update notification for splash/status screens");
483 } else {
484 SAFE_STRNCPY(g_update_notification, notification, sizeof(g_update_notification));
485 log_debug("Set update notification for splash/status screens: %s", notification);
486 }
487
488 mutex_unlock(&g_update_notification_mutex);
489}
ANSI escape sequence utilities and fast color code generation.
const char * asciichat_error_format(const char *message, asciichat_error_t code)
void atomic_store_bool(atomic_t *a, bool value)
Atomically store a boolean value.
bool atomic_load_bool(atomic_t *a)
Atomic pointer wrapper.
void atomic_store_u64(atomic_t *a, uint64_t value)
Atomically store a uint64_t value.
uint64_t atomic_load_u64(atomic_t *a)
Atomically load a uint64_t value.
bool atomic_cas_bool(atomic_t *a, bool *expected, bool new_value)
Atomically compare-and-swap a boolean.
Platform initialization and static synchronization helpers.
void ui_errno_stacks_toggle(void)
bool ui_errno_stacks_handle_key(keyboard_key_t key)
Buffered terminal frame rendering.
struct frame_buffer frame_buffer_t
Opaque frame buffer handle.
bool enabled
Is filtering active?
Definition grep.c:62
int buffer_size
Size of circular buffer.
Definition grep.c:68
#define SAFE_STRNCPY(dst, src, size)
#define SAFE_FREE(ptr)
unsigned long long uint64_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ASCIICHAT_OK
Definition error_codes.h:50
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
struct session_log_buffer session_log_buffer_t
Thread-safe fixed-size history ring for session-screen log lines.
void log_clear_session_log_buffer(void)
Unregister the session log buffer.
void log_set_session_log_buffer(session_log_buffer_t *buf)
Register a session log buffer with the logger.
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
#define NS_PER_SEC_INT
Definition time.h:173
#define NS_PER_MS_INT
Definition time.h:172
#define GET_OPTION(field)
Definition options.h:1333
asciichat_mode_t
Mode type for options parsing.
Definition options.h:916
#define options_terminal_settings()
Definition options.h:1287
@ MODE_MIRROR
Mirror mode - local webcam viewing (no network).
Definition options.h:919
bool splash_is_running(void)
Check if splash screen animation is currently running.
Definition splash.c:440
struct session_display_ctx session_display_ctx_t
session display config is intentionally a small, concrete record. Fields such as snapshot_mode,...
int splash_intro_done(void)
Signal that intro splash should end (first frame ready to render).
Definition splash.c:421
void splash_restore_stderr(void)
Restore stderr after splash animation completes.
Definition splash.c:431
int splash_intro_start(session_display_ctx_t *ctx)
Start animated intro screen with rainbow ASCII art (non-blocking).
Definition splash.c:370
void splash_log_init(void)
Initialize log buffer for splash animation.
Definition splash.c:125
void splash_log_clear(void)
Clear splash log buffer.
Definition splash.c:137
void splash_set_update_notification(const char *notification)
Set update notification to display on splash/status screens.
Definition splash.c:476
bool splash_should_display(bool is_intro)
Render splash header with rainbow animation (callback for terminal_screen).
Definition splash.c:242
void splash_clear_display_context(void)
Clear the cached display context to prevent use-after-free.
Definition splash.c:436
void splash_log_destroy(void)
Destroy splash log buffer.
Definition splash.c:132
void splash_wait_for_animation(void)
Wait for splash animation thread to fully exit.
Definition splash.c:446
bool shutdown_is_requested(void)
Check if shutdown has been requested.
Definition common.c:86
const char * get_ip_type_string(const char *ip)
Get human-readable string describing IP address type.
Definition ip.c:1001
⚙️ Common definitions, error codes, macros, and types shared throughout the application
🖥️ Display Width and Terminal Centering Utilities
🌍 IP Address Parsing and Formatting Utilities
bool ui_session_logs_key(keyboard_key_t key)
📝 Logging API with multiple log levels and terminal output control
⚙️ Unified options parsing system for ascii-chat with builder pattern and lock-free access
bool log_search_is_active(void)
Check if filtering is active.
Definition search.c:413
void log_search_exit_mode(bool accept)
Exit search mode.
Definition search.c:303
Interactive search filtering for terminal screens.
char * ui_session_help_render(terminal_size_t size, bool has_media, bool browser, terminal_size_t *minimum)
Thread-safe circular log buffer for session screens (status, splash).
void ui_session_splash_render(frame_buffer_t *buf, terminal_size_t term_size, void *user_data)
ui_splash_view_t splash_header_ctx_t
Context data for splash header rendering.
Definition splash.c:160
#define TUI_SPLASH_UPDATE_NOTIFICATION_BUFFER_SIZE
Definition splash.c:18
atomic_t intro_done_time_ns
Definition splash.c:150
atomic_t thread_created
Definition splash.c:147
void splash_set_discovery_session(const char *session, bool joining)
Definition splash.c:95
uint64_t start_time_ns
Definition splash.c:149
ui_discovery_view_t discovery_splash_t
Definition splash.c:71
atomic_t should_stop
Definition splash.c:146
platform_thread_t monitor_thread
Definition splash.c:148
atomic_t is_running
Definition splash.c:145
void splash_clear_discovery_session(void)
Definition splash.c:105
Intro and status screen display for ascii-chat with animated rainbow effects.
🖥️ Unified terminal display abstraction for session-based rendering
bool terminal_should_color_output(int fd, const terminal_options_t *options)
bool terminal_is_interactive(void)
bool terminal_is_stdout_tty(void)
🔤 String Manipulation and Shell Escaping Utilities
For animation config, this is the live record that ties type, fps, speed, hidden_policy together....
Atomic value wrapper for integral/boolean types.
Definition atomic.h:76
Configuration for terminal screen rendering.
void terminal_screen_log_destroy(void)
Standard log cleanup for terminal screens.
void terminal_screen_render(const terminal_screen_config_t *config)
Render a terminal screen with fixed header and scrolling logs.
void terminal_screen_log_clear(void)
Clear buffered logs for terminal screens.
session_log_buffer_t * terminal_screen_log_init(void)
Initialize session log buffer for terminal screens.
void terminal_screen_set_output_fd(int fd)
Set output file descriptor for terminal screens (splash/status).
Reusable "fixed header + scrolling logs" terminal screen abstraction.
lifecycle_t lifecycle
Lifecycle state machine for init/shutdown synchronization.
Definition time.c:40
⏱️ High-precision timing utilities using sokol_time.h and uthash
void ui_controller_remove(ui_screen_t screen)
asciichat_error_t ui_controller_submit(ui_screen_t screen, int fd, terminal_size_t minimum, ui_render_fn render, const void *snapshot, size_t bytes)
const animation_sample_t * ui_controller_animation_sample(void)
void ui_controller_toggle_logs(void)
void ui_controller_title_activity(ui_title_activity_t activity)
int ui_controller_current_screen(void)
terminal_size_t ui_controller_size(void)
void ui_controller_hide_logs(void)
asciichat_error_t ui_controller_write(int fd, const char *data, size_t len)
void ui_controller_title_discovery(bool has_session, bool joining)
@ UI_TITLE_ACTIVITY_IDLE
@ UI_SCREEN_LOGS
@ UI_SCREEN_SPLASH
@ UI_SCREEN_HELP
keyboard_key_t ui_input_read_key(ui_screen_t screen)
Definition tui/input.c:346
int platform_isatty(int fd)
Definition util.c:70