display.h File Reference

🖥️ Unified terminal display abstraction for session-based rendering More...

Go to the source code of this file.

Data Structures
struct	session_display_config_t
	Terminal-rendering and snapshot settings used to create a display context. More...

Typedefs
typedef bool(*	session_display_should_exit_fn) (void *user_data)
	Callback type to check if initialization should be cancelled.

Functions
session_display_ctx_t *	session_display_create (const session_display_config_t *config)
	Create a new session display context.
session_display_ctx_t *	session_display_get_global_context (void)
	Get the global display context (used for signal handlers and special cleanup).
void	session_display_set_global_context_public (session_display_ctx_t *ctx)
	Set the global display context (public setter for discovery cleanup).
asciichat_error_t	session_display_finish_render_file (session_display_ctx_t *ctx)
	Destroy session display context and free resources.
void	session_display_begin_drain (session_display_ctx_t *ctx, uint64_t total, bool total_known)
void	session_display_destroy (session_display_ctx_t *ctx)
void	session_display_set_stdin_reader (session_display_ctx_t *ctx, void *reader)
	Set stdin frame reader for ASCII-to-video rendering.
bool	session_display_has_tty (session_display_ctx_t *ctx)
	Check if display has a TTY (terminal) available.
const terminal_capabilities_t *	session_display_get_caps (session_display_ctx_t *ctx)
	Get detected terminal capabilities.
const char *	session_display_get_palette_chars (session_display_ctx_t *ctx)
	Get the palette characters string.
size_t	session_display_get_palette_len (session_display_ctx_t *ctx)
	Get the palette character count.
const char *	session_display_get_luminance_palette (session_display_ctx_t *ctx)
	Get the luminance mapping palette.
int	session_display_get_tty_fd (session_display_ctx_t *ctx)
	Get the TTY file descriptor.
void *	session_display_get_stdin_reader (session_display_ctx_t *ctx)
	Get the stdin frame reader for ASCII-to-video rendering.
bool	session_display_has_render_file (session_display_ctx_t *ctx)
	Check if display has render-file configured.
uint32_t	session_display_get_render_fps (session_display_ctx_t *ctx)
	Get the render FPS configured for file output.
asciichat_error_t	session_display_init_render_file (session_display_ctx_t *ctx, uint32_t fps)
	Initialize render-file output after the capture frame rate is known.
void	session_display_set_render_live_timing (session_display_ctx_t *ctx)
void	session_display_set_render_fps (session_display_ctx_t *ctx, uint32_t fps)
	Set the render FPS for file output encoding.
bool	session_display_has_first_frame (session_display_ctx_t *ctx)
	Check if the display has rendered its first frame.
void	session_display_reset_first_frame (session_display_ctx_t *ctx)
	Reset the first frame flag to allow splash screen to show again on next render.
char *	session_display_convert_to_ascii (session_display_ctx_t *ctx, const image_t *image)
	Convert an image to ASCII art using display context and command-line options.
char *	session_display_convert_to_ascii_reuse (session_display_ctx_t *ctx, const image_t *image)
void	session_display_release_ascii (session_display_ctx_t *ctx, char *ascii)
void	session_display_reset_stabilizer (session_display_ctx_t *ctx, bool recording)
void	session_display_write_ascii (session_display_ctx_t *ctx, const char *frame_data)
	Write ASCII frame to terminal only (no encoding).
asciichat_error_t	session_display_encode_frame (session_display_ctx_t *ctx, const image_t *image, uint64_t captured_ns)
	Encode frame to render-file (FFmpeg only, no terminal output).
void	session_display_render_frame (session_display_ctx_t *ctx, const char *frame_data)
	Render an ASCII frame to the terminal.
void	session_display_write_raw (session_display_ctx_t *ctx, const char *data, size_t len)
	Render raw bytes to the terminal without frame processing.
void	session_display_set_snapshot_actual_duration (session_display_ctx_t *ctx, double actual_duration_sec)
	Set the actual wall-clock duration for snapshot mode frame timing.
void	session_display_reset (session_display_ctx_t *ctx)
	Reset terminal to default state.
void	session_display_clear (session_display_ctx_t *ctx)
	Clear the terminal screen.
void	session_display_cursor_home (session_display_ctx_t *ctx)
	Move cursor to home position (top-left).
bool	session_display_has_audio_playback (session_display_ctx_t *ctx)
	Check if display has audio playback configured.
asciichat_error_t	session_display_write_audio (session_display_ctx_t *ctx, const float *buffer, size_t num_samples)
	Write audio samples to playback buffer.
void	session_display_write_ascii_frame (session_display_ctx_t *ctx, const char *ascii, bool fresh)

Detailed Description

🖥️ Unified terminal display abstraction for session-based rendering

Definition in file src/common/session/display.h.

Function Documentation

session_display_convert_to_ascii_reuse()

char * session_display_convert_to_ascii_reuse	(	session_display_ctx_t *	ctx,
		const image_t *	image )

Single display owner; result must be released before its next conversion.

Definition at line 932 of file src/common/session/display.c.

                                                                                               {
  ASCII_OTEL_SCOPE(SESSION_DISPLAY_CONVERT_TO_ASCII_REUSE);
  return convert_to_ascii(ctx, image, true);
}

References ASCII_OTEL_SCOPE.

Referenced by session_pipeline_run_main(), and session_render_loop().

session_display_init_render_file()

asciichat_error_t session_display_init_render_file	(	session_display_ctx_t *	ctx,
		uint32_t	fps )

Initialize render-file output after the capture frame rate is known.

Parameters

ctx	Display context
fps	Frame rate used for output timing

Returns

ASCIICHAT_OK on success

Initialize render-file output after the capture frame rate is known.

Executes comprehensive terminal reset sequence for clean display state. Skips terminal control operations in snapshot mode.

Parameters

snapshot_mode

Whether snapshot mode is enabled

Definition at line 170 of file src/common/session/display.c.

                                                                                             {
  if (!ctx) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Display context is NULL");
  }
 
  const char *render_file_opt = GET_OPTION(render_file);
  if ((!render_file_opt || !render_file_opt[0]) && GET_OPTION(render_kitty))
    render_file_opt = "--kitty";
  if (!render_file_opt || render_file_opt[0] == '\0') {
    return ASCIICHAT_OK;
  }
  if (ctx->render_file) {
    return ASCIICHAT_OK;
  }
 
  uint32_t encoder_fps = fps;
  if (encoder_fps == 0) {
    encoder_fps = (uint32_t)GET_OPTION(fps);
  }
  if (encoder_fps == 0) {
    encoder_fps = 60;
  }
 
  int width = (int)GET_OPTION(width);
  int height = (int)GET_OPTION(height);
  ctx->render_fps = encoder_fps;
 
  log_info("render-file: Initializing encoder after media timing selection: path='%s', grid=%dx%d, fps=%u",
           render_file_opt, width, height, encoder_fps);
  asciichat_error_t err =
      render_file_create(render_file_opt, width, height, (int)encoder_fps, GET_OPTION(render_theme), &ctx->render_file);
  if (err != ASCIICHAT_OK) {
    asciichat_error_context_t error;
    if (HAS_ERRNO(&error))
      log_error("render-file: %s", error.context_message);
    log_error("render-file: Failed to create encoder %s", asciichat_error_format(NULL, err));
    return err;
  }
 
  log_info("render-file: Encoder initialized successfully at %u FPS", encoder_fps);
  return ASCIICHAT_OK;
}

References asciichat_error_format(), ASCIICHAT_OK, asciichat_error_context_t::context_message, ERROR_INVALID_PARAM, GET_OPTION, HAS_ERRNO, height, log_error, log_info, session_display_ctx::render_file, render_file_create(), session_display_ctx::render_fps, SET_ERRNO, and width.

Referenced by session_display_create().

session_display_release_ascii()

void session_display_release_ascii	(	session_display_ctx_t *	ctx,
		char *	ascii )

Definition at line 942 of file src/common/session/display.c.

                                                                            {
  if (!ctx || ascii != ctx->ascii_workspace.buf)
    SAFE_FREE(ascii);
}

References session_display_ctx::ascii_workspace, outbuf_t::buf, and SAFE_FREE.

Referenced by session_pipeline_run_main(), and session_render_loop().

session_display_reset_stabilizer()

void session_display_reset_stabilizer	(	session_display_ctx_t *	ctx,
		bool	recording )

Clear only the history owned by the calling display or recording worker.

Definition at line 937 of file src/common/session/display.c.

                                                                                  {
  if (ctx)
    ascii_stabilizer_reset(recording ? &ctx->recording_stabilizer : &ctx->stabilizer);
}

References ascii_stabilizer_reset(), session_display_ctx::recording_stabilizer, and session_display_ctx::stabilizer.

Referenced by session_pipeline_run_main().

session_display_set_render_live_timing()

void session_display_set_render_live_timing

(

session_display_ctx_t *

ctx

)

Definition at line 1280 of file src/common/session/display.c.

                                                                        {
  if (ctx && ctx->render_file)
    render_file_set_live_timing(ctx->render_file);
}

References session_display_ctx::render_file, and render_file_set_live_timing().

Referenced by session_pipeline_create().

session_display_write_ascii_frame()

void session_display_write_ascii_frame	(	session_display_ctx_t *	ctx,
		const char *	ascii,
		bool	fresh )

Publish an acquired frame, or redraw retained content without advancing displayed FPS.

Definition at line 947 of file src/common/session/display.c.

                                                                                                  {
  ASCII_OTEL_SCOPE(SESSION_DISPLAY_WRITE_ASCII_FRAME);
  if (!ctx || !ctx->initialized) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Display context is NULL or uninitialized");
    return;
  }
 
  // Shutdown is asynchronous; queued frames must not retry a failed output.
  if (atomic_load_bool(&ctx->output_failed)) {
    return;
  }
 
  if (!ascii) {
    SET_ERRNO(ERROR_INVALID_PARAM, "ASCII data is NULL");
    return;
  }
 
  // Re-evaluate color_level on every frame to pick up live color_mode changes
  terminal_color_mode_t color_mode = (terminal_color_mode_t)GET_OPTION(color_mode);
  if (color_mode != TERM_COLOR_AUTO) {
    ctx->caps.color_level = color_mode;
  }
 
  // Suppress frame rendering when help screen is active
 
  bool visualization_enabled = GET_OPTION(waveform) || GET_OPTION(fft);
  char *visualization_frame = visualization_enabled ? session_display_create_visualization_frame(ctx) : NULL;
  if (visualization_frame)
    ascii = visualization_frame;
 
  // Leave room for cursor controls when passing the frame to the presenter.
  const size_t max_frame_len = UI_CONTROLLER_MAX_FRAME_BYTES - 7;
  size_t frame_len = strnlen(ascii, max_frame_len);
  if (frame_len == max_frame_len) {
    SET_ERRNO(ERROR_BUFFER_FULL, "ASCII frame exceeds the presenter limit");
    SAFE_FREE(visualization_frame);
    return;
  }
  if (frame_len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "ASCII data is empty");
    SAFE_FREE(visualization_frame);
    return;
  }
 
  /* Inspect the payload before any terminal presentation.  This is bounded
   * diagnostics: it records shape/control-byte anomalies and a short tail,
   * never the full webcam frame. */
  {
    size_t lines = 0, current = 0, min_line = SIZE_MAX, max_line = 0, last_line = 0;
    unsigned control_bytes = 0, escape_bytes = 0;
    for (size_t i = 0; i < frame_len; ++i) {
      unsigned char byte = (unsigned char)ascii[i];
      if (byte == '\n') {
        min_line = MIN(min_line, current);
        max_line = MAX(max_line, current);
        last_line = current;
        ++lines;
        current = 0;
      } else {
        current++;
        if (byte < 32 && byte != '\r' && byte != '\t')
          ++control_bytes;
        if (byte == 0x1b)
          ++escape_bytes;
      }
    }
    if (current) {
      min_line = MIN(min_line, current);
      max_line = MAX(max_line, current);
      last_line = current;
    }
    char tail[64] = {0};
    size_t tail_start = frame_len > 24 ? frame_len - 24 : 0;
    size_t tail_used = 0;
    for (size_t i = tail_start; i < frame_len && tail_used + 4 < sizeof(tail); ++i)
      tail_used += (size_t)safe_snprintf(tail + tail_used, sizeof(tail) - tail_used, "%02X ", (unsigned char)ascii[i]);
 
    // Also capture the actual glyphs in the final row.  Byte/line counts alone
    // cannot distinguish a bad terminal write from a bad rendered frame.
    size_t row_start = 0;
    for (size_t i = 0; i < frame_len; ++i)
      if (ascii[i] == '\n')
        row_start = i + 1;
    char last_row[192] = {0};
    size_t row_used = 0;
    for (size_t i = row_start; i < frame_len && row_used + 5 < sizeof(last_row); ++i) {
      unsigned char byte = (unsigned char)ascii[i];
      if (byte == 0x1b) {
        ++i;
        while (i < frame_len && !((ascii[i] >= '@' && ascii[i] <= 'Z') || (ascii[i] >= 'a' && ascii[i] <= 'z')))
          ++i;
        continue;
      }
      if (byte >= 32 && byte < 127)
        last_row[row_used++] = (char)byte;
      else if (byte == '\r' || byte == '\t')
        last_row[row_used++] = ' ';
      else
        row_used += (size_t)safe_snprintf(last_row + row_used, sizeof(last_row) - row_used, "\\x%02X", byte);
    }
    log_debug_every(US_PER_SEC_INT,
                    "FRAME_DATA: bytes=%zu lines=%zu line_bytes=%zu..%zu last=%zu controls=%u escapes=%u last_row=\"%s\" tail=%s",
                    frame_len, lines, min_line == SIZE_MAX ? 0 : min_line, max_line, last_line, control_bytes,
                    escape_bytes, last_row, tail);
  }
 
  // Apply digital rain effect if enabled
  char *display_frame = (char *)ascii;
  char *rain_result = NULL;
  if (ctx->digital_rain && !visualization_enabled) {
    uint64_t t_rain_start = time_get_ns();
    uint64_t current_time_ns = t_rain_start;
    float delta_time = (float)(current_time_ns - ctx->last_frame_time_ns) / (float)NS_PER_SEC_INT;
    ctx->last_frame_time_ns = current_time_ns;
 
    // Update digital rain color from current filter
    color_filter_t current_filter = GET_OPTION(color_filter);
    digital_rain_set_color_from_filter(ctx->digital_rain, current_filter);
 
    rain_result = digital_rain_apply(ctx->digital_rain, (char *)ascii, delta_time);
    if (rain_result) {
      display_frame = rain_result;
      frame_len = strnlen(rain_result, max_frame_len);
      if (frame_len == max_frame_len) {
        SET_ERRNO(ERROR_BUFFER_FULL, "Digital rain frame exceeds the presenter limit");
        SAFE_FREE(rain_result);
        SAFE_FREE(visualization_frame);
        return;
      }
 
      uint64_t t_rain_end = time_get_ns();
      char rain_str[TIME_DURATION_BUFFER_SIZE];
      time_pretty(t_rain_end - t_rain_start, -1, rain_str, sizeof(rain_str));
      log_debug("DIGITAL_RAIN (write_ascii): Effect applied (%s)", rain_str);
    }
  }
 
  // Binary video owns stdout in every terminal mode.
  const char *output = GET_OPTION(render_file);
  bool binary_stdout = ctx->render_file && (strcmp(output, "-") == 0 || strcmp(output, "pipe:") == 0 ||
                                            strcmp(output, "--kitty") == 0 || GET_OPTION(render_kitty));
  char *zalgo_frame = NULL;
  int zalgo_level = GET_OPTION(zalgo);
  if (zalgo_level > 0 && !binary_stdout) {
    asciichat_error_t err =
        zalgo_apply(display_frame, frame_len, zalgo_level, UI_CONTROLLER_MAX_FRAME_BYTES - 7, &zalgo_frame);
    if (err == ASCIICHAT_OK) {
      display_frame = zalgo_frame;
      frame_len = strlen(zalgo_frame);
    } else {
      log_warn_every(5 * US_PER_SEC_INT, "Cannot apply Zalgo: %s", asciichat_error_format(NULL, err));
    }
  }
 
  char *plain_frame = NULL;
  if (GET_OPTION(strip_ansi)) {
    // Expand REP before stripping escapes so repeated cells are preserved.
    char *expanded = ansi_expand_rle(display_frame, frame_len);
    if (expanded) {
      size_t capacity = strlen(expanded) + 1;
      plain_frame = SAFE_MALLOC(capacity, char *);
      strip_ansi_codes(expanded, plain_frame, capacity);
      SAFE_FREE(expanded);
      display_frame = plain_frame;
      frame_len = strlen(plain_frame);
    }
  }
 
  // Handle first frame - perform initial terminal reset and splash cleanup
  bool was_first_frame = atomic_exchange_bool(&ctx->first_frame, false);
  if (was_first_frame) {
    ui_controller_title_ready();
    ui_controller_title_activity(UI_TITLE_ACTIVITY_IDLE);
    // Stop splash screen when first frame is ready
    splash_intro_done();
    splash_wait_for_animation();
  }
 
  if (binary_stdout) {
    if (GET_OPTION(snapshot_mode) && !g_snapshot_first_frame_rendered) {
      g_snapshot_first_frame_rendered = true;
      g_snapshot_first_frame_rendered_ns = time_get_ns();
    }
    SAFE_FREE(plain_frame);
    SAFE_FREE(zalgo_frame);
    SAFE_FREE(rain_result);
    SAFE_FREE(visualization_frame);
    return;
  }
 
  // Output routing logic
  // A snapshot still needs terminal cursor framing when stdout is a real TTY.
  // `terminal_is_interactive()` also depends on stdin, which is commonly false
  // for scripted snapshot invocations even though the PTY can display output.
  bool use_tty_control = ctx->has_tty ||
                         (ctx->snapshot_mode && ctx->tty_info.fd >= 0 && platform_isatty(ctx->tty_info.fd));
 
  uint64_t frame_write_started_ns = time_get_ns();
 
  // Increment shared frame counter for both client and host rendering
  // This metric is used by debug scripts to measure FPS across all modes
  static atomic_t g_display_frames_rendered = {0};
  int frame_number = atomic_fetch_add_u64(&g_display_frames_rendered, 1) + 1;
  log_dev("[FRAMES_RENDERED_TOTAL] %d", frame_number);
 
  if (use_tty_control) {
    // TTY mode: Buffer cursor control + frame data together for atomic frame display
    const char *cursor_home_sequence = "\033[H";
    const char *erase_below_sequence = "\033[J";
    size_t cursor_seq_len = 3;
    size_t erase_below_len = 3;
    // The frame is shorter than the terminal in some configurations.  Erase
    // from the final frame cursor to the bottom of the screen in the same
    // submission so stale rows cannot survive a resize or a shorter frame.
    size_t total_size = cursor_seq_len + frame_len + erase_below_len;
 
    if (ctx->tty_frame_capacity < total_size) {
      size_t capacity = ctx->tty_frame_capacity ? ctx->tty_frame_capacity : 4096;
      while (capacity < total_size && capacity <= SIZE_MAX / 2)
        capacity *= 2;
      if (capacity < total_size)
        capacity = total_size;
      ctx->tty_frame_buffer = SAFE_REALLOC(ctx->tty_frame_buffer, capacity, char *);
      ctx->tty_frame_capacity = capacity;
    }
    char *frame_buffer = ctx->tty_frame_buffer;
    if (frame_buffer) {
      memcpy(frame_buffer, cursor_home_sequence, cursor_seq_len);
      memcpy(frame_buffer + cursor_seq_len, display_frame, frame_len);
      memcpy(frame_buffer + cursor_seq_len + frame_len, erase_below_sequence, erase_below_len);
 
      log_debug_every(US_PER_SEC_INT, "FRAME_WRITE_TTY: Writing %zu bytes (cursor=%zu + frame=%zu) to stdout",
                      total_size, cursor_seq_len, frame_len);
      int output_fd = ctx->tty_info.fd >= 0 ? ctx->tty_info.fd : STDOUT_FILENO;
      asciichat_error_t presented = ASCIICHAT_OK;
      if (ctx->snapshot_mode) {
        // Snapshot processes may exit immediately after the first frame. Write
        // directly so teardown cannot discard a queued UI-controller update.
        if (platform_write_all(output_fd, frame_buffer, total_size) != total_size)
          presented = SET_ERRNO(ERROR_FILE_OPERATION, "Cannot write snapshot frame to terminal");
      } else {
        presented = (fresh ? ui_controller_present : ui_controller_present_retained)(
            UI_SCREEN_MEDIA, output_fd, (terminal_size_t){.cols = UI_MEDIA_MIN_COLS, .rows = UI_MEDIA_MIN_ROWS},
            frame_buffer, total_size);
      }
      if (was_first_frame && presented == ASCIICHAT_OK)
        ui_controller_remove(UI_SCREEN_SPLASH);
      ssize_t written = presented == ASCIICHAT_OK ? (ssize_t)total_size : -1;
      log_debug_every(US_PER_SEC_INT, "FRAME_WRITE_TTY: Wrote %zd bytes (requested %zu)", written, total_size);
 
      // Start snapshot timer on first ASCII frame rendered
      if (GET_OPTION(snapshot_mode) && !g_snapshot_first_frame_rendered) {
        g_snapshot_first_frame_rendered = true;
        g_snapshot_first_frame_rendered_ns = time_get_ns();
        log_debug("SNAPSHOT: FIRST ASCII FRAME RENDERED (write_ascii) - Timer started");
      }
 
      // The UI controller copies the submission before this workspace is reused.
    }
 
    // Live presentation owns terminal writes on its worker. Draining here
    // blocks packet reception, including audio, behind a slow terminal reader.
    if (ctx->snapshot_mode) {
      (void)fflush(stdout);
      int flush_fd = (ctx->tty_info.fd >= 0) ? ctx->tty_info.fd : STDOUT_FILENO;
      (void)terminal_flush(flush_fd);
    }
 
  } else if (terminal_is_interactive()) {
    // Piped to interactive terminal: output ASCII frames with newline
    char *write_buf = SAFE_MALLOC(frame_len + 1, char *);
    if (write_buf) {
      memcpy(write_buf, display_frame, frame_len);
      write_buf[frame_len] = '\n';
      if (ui_controller_write(STDOUT_FILENO, write_buf, frame_len + 1) != ASCIICHAT_OK) {
        atomic_store_bool(&ctx->output_failed, true);
        APP_CALLBACK_VOID(signal_exit);
        SAFE_FREE(write_buf);
        goto cleanup_frame;
      }
      SAFE_FREE(write_buf);
    }
 
    if (ctx->snapshot_mode) {
      (void)fflush(stdout);
      int flush_fd = (ctx->tty_info.fd >= 0) ? ctx->tty_info.fd : STDOUT_FILENO;
      (void)terminal_flush(flush_fd);
    }
  } else {
    // Named render files leave stdout available for ASCII output
    char *write_buf = SAFE_MALLOC(frame_len + 1, char *);
    if (write_buf) {
      memcpy(write_buf, display_frame, frame_len);
      write_buf[frame_len] = '\n';
      if (ui_controller_write(STDOUT_FILENO, write_buf, frame_len + 1) != ASCIICHAT_OK) {
        atomic_store_bool(&ctx->output_failed, true);
        APP_CALLBACK_VOID(signal_exit);
        SAFE_FREE(write_buf);
        goto cleanup_frame;
      }
 
      // Start snapshot timer on first ASCII frame rendered
      if (GET_OPTION(snapshot_mode) && !g_snapshot_first_frame_rendered) {
        g_snapshot_first_frame_rendered = true;
        g_snapshot_first_frame_rendered_ns = time_get_ns();
        log_debug("SNAPSHOT: FIRST ASCII FRAME RENDERED (write_ascii piped) - Timer started");
      }
 
      SAFE_FREE(write_buf);
    }
 
    // Writes already reach the OS synchronously; streaming frames do not need
    // a durability barrier or a terminal drain on the receiving thread.
    (void)fflush(stdout);
    if (ctx->snapshot_mode && ctx->has_tty) {
      int flush_fd = (ctx->tty_info.fd >= 0) ? ctx->tty_info.fd : STDOUT_FILENO;
      (void)terminal_flush(flush_fd);
    }
  }
 
cleanup_frame:
  log_dev_every(3 * US_PER_SEC_INT, "FRAME_WRITE: Published in %.2f ms",
                (double)(time_get_ns() - frame_write_started_ns) / NS_PER_MS_INT);
 
  // Clean up digital rain result if allocated
  SAFE_FREE(plain_frame);
  SAFE_FREE(zalgo_frame);
  if (rain_result) {
    SAFE_FREE(rain_result);
  }
  SAFE_FREE(visualization_frame);
}

References ansi_expand_rle(), APP_CALLBACK_VOID, ASCII_OTEL_SCOPE, asciichat_error_format(), ASCIICHAT_OK, session_display_ctx::caps, color_mode, session_display_ctx::digital_rain, digital_rain_apply(), digital_rain_set_color_from_filter(), ERROR_BUFFER_FULL, ERROR_FILE_OPERATION, ERROR_INVALID_PARAM, session_display_ctx::first_frame, g_snapshot_first_frame_rendered, g_snapshot_first_frame_rendered_ns, GET_OPTION, session_display_ctx::has_tty, session_display_ctx::initialized, session_display_ctx::last_frame_time_ns, log_debug, log_debug_every, log_dev, log_dev_every, log_warn_every, MAX, MIN, NS_PER_MS_INT, NS_PER_SEC_INT, session_display_ctx::output_failed, platform_write_all(), session_display_ctx::render_file, SAFE_FREE, SAFE_MALLOC, SAFE_REALLOC, safe_snprintf(), SET_ERRNO, signal_exit(), session_display_ctx::snapshot_mode, splash_intro_done(), splash_wait_for_animation(), strip_ansi_codes(), TIME_DURATION_BUFFER_SIZE, time_pretty(), session_display_ctx::tty_frame_buffer, session_display_ctx::tty_frame_capacity, session_display_ctx::tty_info, UI_CONTROLLER_MAX_FRAME_BYTES, ui_controller_present(), ui_controller_present_retained(), ui_controller_remove(), ui_controller_title_activity(), ui_controller_title_ready(), ui_controller_write(), UI_MEDIA_MIN_COLS, UI_MEDIA_MIN_ROWS, UI_SCREEN_MEDIA, UI_SCREEN_SPLASH, UI_TITLE_ACTIVITY_IDLE, US_PER_SEC_INT, and zalgo_apply().

Referenced by session_display_write_ascii(), and session_pipeline_run_main().