main.c File Reference

Local webcam mirror mode: view webcam as ASCII art without network. More...

Go to the source code of this file.

Functions
int	mirror_main (void)
	Run mirror mode main loop.

Detailed Description

Local webcam mirror mode: view webcam as ASCII art without network.

Mirror mode provides a simple way to view your own webcam feed converted to ASCII art directly in the terminal. No server connection is required.

Features

• Local webcam capture and ASCII conversion
• Terminal capability detection for optimal color output
• Frame rate limiting for smooth display
• Clean shutdown on Ctrl+C

Usage

Run as a standalone mode:

ascii-chat mirror

Author

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

Date

2025

Definition in file mirror/main.c.

Function Documentation

mirror_main()

int mirror_main

(

void

)

Run mirror mode main loop.

Initializes webcam and terminal, then continuously captures frames, converts them to ASCII art, and displays them locally.

Returns

0 on success, non-zero error code on failure

Definition at line 209 of file mirror/main.c.

                      {
  log_info("Starting mirror mode");
 
  // Install console control-c handler
  platform_set_console_ctrl_handler(mirror_console_ctrl_handler);
 
#ifndef _WIN32
  platform_signal(SIGPIPE, SIG_IGN);
#endif
 
  // Initialize webcam
  int webcam_result = webcam_init(GET_OPTION(webcam_index));
  if (webcam_result != 0) {
    log_fatal("Failed to initialize webcam: %s", asciichat_error_string(webcam_result));
    webcam_print_init_error_help(webcam_result);
    return webcam_result;
  }
 
  // Initialize display
  if (mirror_display_init() != 0) {
    log_fatal("Failed to initialize display");
    webcam_cleanup();
    return ERROR_DISPLAY;
  }
 
  // Detect terminal capabilities
  terminal_capabilities_t caps = detect_terminal_capabilities();
  caps = apply_color_mode_override(caps);
 
  // Initialize ANSI color lookup tables based on terminal capabilities
  if (caps.color_level == TERM_COLOR_TRUECOLOR) {
    ansi_fast_init();
  } else if (caps.color_level == TERM_COLOR_256) {
    ansi_fast_init_256color();
  } else if (caps.color_level == TERM_COLOR_16) {
    ansi_fast_init_16color();
  }
 
  // Initialize palette
  char palette_chars[256] = {0};
  size_t palette_len = 0;
  char luminance_palette[256] = {0};
 
  const char *custom_chars = GET_OPTION(palette_custom_set) ? GET_OPTION(palette_custom) : NULL;
  palette_type_t palette_type = GET_OPTION(palette_type);
  if (initialize_client_palette(palette_type, custom_chars, palette_chars, &palette_len, luminance_palette) != 0) {
    log_fatal("Failed to initialize palette");
    mirror_display_cleanup();
    webcam_cleanup();
    return ERROR_INVALID_STATE;
  }
 
  // Frame rate limiting
  const long frame_interval_ms = 1000 / 60; // 60 FPS target
  struct timespec last_frame_time = {0, 0};
 
  // Snapshot mode timing
  struct timespec snapshot_start_time = {0, 0};
  bool snapshot_done = false;
  if (GET_OPTION(snapshot_mode)) {
    (void)clock_gettime(CLOCK_MONOTONIC, &snapshot_start_time);
  }
 
  // FPS tracking
  uint64_t frame_count = 0;
  struct timespec fps_report_time;
  (void)clock_gettime(CLOCK_MONOTONIC, &fps_report_time);
 
  log_info("Mirror mode running - press Ctrl+C to exit");
  log_set_terminal_output(false);
 
  while (!mirror_should_exit()) {
    // Frame rate limiting
    struct timespec current_time;
    (void)clock_gettime(CLOCK_MONOTONIC, &current_time);
 
    long elapsed_ms = (current_time.tv_sec - last_frame_time.tv_sec) * 1000 +
                      (current_time.tv_nsec - last_frame_time.tv_nsec) / 1000000;
 
    if (elapsed_ms < frame_interval_ms) {
      platform_sleep_usec((frame_interval_ms - elapsed_ms) * 1000);
      continue;
    }
 
    // Snapshot mode: check if delay has elapsed (delay 0 = capture first frame immediately)
    if (GET_OPTION(snapshot_mode) && !snapshot_done) {
      double elapsed_sec = (double)(current_time.tv_sec - snapshot_start_time.tv_sec) +
                           (double)(current_time.tv_nsec - snapshot_start_time.tv_nsec) / 1e9;
 
      float snapshot_delay = GET_OPTION(snapshot_delay);
      if (elapsed_sec >= snapshot_delay) {
        snapshot_done = true;
      }
    }
 
    // Read frame from webcam
    image_t *image = webcam_read();
    if (!image) {
      platform_sleep_usec(10000); // 10ms delay before retry
      continue;
    }
 
    // Convert image to ASCII
    // When stretch is 0 (disabled), we preserve aspect ratio (true)
    // When stretch is 1 (enabled), we allow stretching without aspect ratio preservation (false)
    bool stretch = GET_OPTION(stretch);
    unsigned short int width = GET_OPTION(width);
    unsigned short int height = GET_OPTION(height);
    bool preserve_aspect_ratio = !stretch;
    char *ascii_frame = ascii_convert_with_capabilities(image, width, height, &caps, preserve_aspect_ratio, stretch,
                                                        palette_chars, luminance_palette);
 
    if (ascii_frame) {
      // When piping/redirecting in snapshot mode, only output the final frame
      // When outputting to TTY, show live preview frames
      bool snapshot_mode = GET_OPTION(snapshot_mode);
      bool should_write = !snapshot_mode || g_mirror_has_tty || snapshot_done;
      if (should_write) {
        mirror_write_frame(ascii_frame);
      }
 
      // Snapshot mode: exit after capturing the final frame
      if (snapshot_mode && snapshot_done) {
        SAFE_FREE(ascii_frame);
        image_destroy(image);
        break;
      }
 
      SAFE_FREE(ascii_frame);
      frame_count++;
    }
 
    image_destroy(image);
    last_frame_time = current_time;
 
    // FPS reporting every 5 seconds
    uint64_t fps_elapsed_us = ((uint64_t)current_time.tv_sec * 1000000 + (uint64_t)current_time.tv_nsec / 1000) -
                              ((uint64_t)fps_report_time.tv_sec * 1000000 + (uint64_t)fps_report_time.tv_nsec / 1000);
 
    if (fps_elapsed_us >= 5000000) {
      double fps = (double)frame_count / ((double)fps_elapsed_us / 1000000.0);
      log_debug("Mirror FPS: %.1f", fps);
      frame_count = 0;
      fps_report_time = current_time;
    }
  }
 
  // Cleanup
  log_set_terminal_output(true);
  log_info("Mirror mode shutting down");
 
  mirror_display_cleanup();
  webcam_cleanup();
 
  return 0;
}

References ansi_fast_init(), ansi_fast_init_16color(), ansi_fast_init_256color(), apply_color_mode_override(), ascii_convert_with_capabilities(), terminal_capabilities_t::color_level, detect_terminal_capabilities(), ERROR_DISPLAY, ERROR_INVALID_STATE, GET_OPTION, image_destroy(), initialize_client_palette(), log_debug, log_fatal, log_info, log_set_terminal_output(), platform_set_console_ctrl_handler(), platform_signal(), platform_sleep_usec(), SAFE_FREE, TERM_COLOR_16, TERM_COLOR_256, TERM_COLOR_TRUECOLOR, webcam_cleanup(), webcam_init(), webcam_print_init_error_help(), and webcam_read().