mirror.c File Reference

Go to the source code of this file.

Macros
#define	RAIN_UPDATE_INTERVAL_MS   100.0

Functions
EMSCRIPTEN_KEEPALIVE int	mirror_init_with_args (const char *args_json)
EMSCRIPTEN_KEEPALIVE void	mirror_cleanup (void)
EMSCRIPTEN_KEEPALIVE char *	mirror_convert_frame (uint8_t *rgba_data, int src_width, int src_height)
EMSCRIPTEN_KEEPALIVE void	mirror_submit_audio_samples (const float *samples, int count, int source)
EMSCRIPTEN_KEEPALIVE char *	mirror_render_audio_visualization (unsigned int width, unsigned int height, int source)
EMSCRIPTEN_KEEPALIVE void	mirror_free_string (char *ptr)
EMSCRIPTEN_KEEPALIVE const unsigned char *	get_font_default_ptr (void)
EMSCRIPTEN_KEEPALIVE unsigned int	get_font_default_size (void)

Variables
const unsigned char	g_font_default []
const size_t	g_font_default_size
const unsigned char	g_font_matrix_resurrected []
const size_t	g_font_matrix_resurrected_size

Macro Definition Documentation

RAIN_UPDATE_INTERVAL_MS

#define RAIN_UPDATE_INTERVAL_MS   100.0

Definition at line 32 of file mirror.c.

Function Documentation

get_font_default_ptr()

EMSCRIPTEN_KEEPALIVE const unsigned char * get_font_default_ptr

(

void

)

Get the pointer to the embedded default font data

Returns

Pointer to font data

Definition at line 333 of file mirror.c.

                                                {
  // Auto-select matrix font when --matrix flag is set
  int matrix_rain_val = GET_OPTION(matrix_rain);
  log_info("[get_font_default_ptr] CALLED: matrix_rain=%d, g_font_matrix_resurrected=%p, g_font_default=%p",
           matrix_rain_val, (void *)g_font_matrix_resurrected, (void *)g_font_default);
  if (matrix_rain_val) {
    log_info("[get_font_default_ptr] RETURNING matrix font");
    return g_font_matrix_resurrected;
  }
  log_info("[get_font_default_ptr] RETURNING default font");
  return g_font_default;
}

References g_font_default, g_font_matrix_resurrected, GET_OPTION, and log_info.

get_font_default_size()

EMSCRIPTEN_KEEPALIVE unsigned int get_font_default_size

(

void

)

Get the size of the embedded default font

Returns

Font data size in bytes

Definition at line 351 of file mirror.c.

                                         {
  // Auto-select matrix font when --matrix flag is set
  if (GET_OPTION(matrix_rain)) {
    return (unsigned int)g_font_matrix_resurrected_size;
  }
  return (unsigned int)g_font_default_size;
}

References g_font_default_size, g_font_matrix_resurrected_size, and GET_OPTION.

mirror_cleanup()

EMSCRIPTEN_KEEPALIVE void mirror_cleanup

(

void

)

Definition at line 85 of file mirror.c.

                          {
  if (g_digital_rain) {
    digital_rain_destroy(g_digital_rain);
    g_digital_rain = NULL;
  }
  if (g_last_rain_output) {
    SAFE_FREE(g_last_rain_output);
    g_last_rain_output = NULL;
  }
  options_state_destroy();
  platform_destroy();
}

References digital_rain_destroy(), options_state_destroy(), platform_destroy(), and SAFE_FREE.

mirror_convert_frame()

EMSCRIPTEN_KEEPALIVE char * mirror_convert_frame	(	uint8_t *	rgba_data,
		int	src_width,
		int	src_height
	)

Definition at line 103 of file mirror.c.

                                                                              {
  if (!rgba_data || src_width <= 0 || src_height <= 0) {
    return NULL;
  }
 
  g_frame_count++;
  // Derive a time value from frame count using actual target FPS from options
  int target_fps = (int)GET_OPTION(fps);
  if (target_fps <= 0) {
    target_fps = 60; // Default to 60 FPS if not set
  }
  float time_seconds = (float)g_frame_count / (float)target_fps;
 
  // Get current settings from options or terminal detection
  int dst_width = (int)terminal_get_effective_width();
  int dst_height = (int)terminal_get_effective_height();
  color_filter_t filter = (color_filter_t)GET_OPTION(color_filter);
  terminal_color_mode_t color_mode = (terminal_color_mode_t)GET_OPTION(color_mode);
  if (g_frame_count <= 3 || g_frame_count % 120 == 0) {
    log_debug("frame=%u color_filter=%d color_mode=%d", g_frame_count, (int)filter, (int)color_mode);
  }
  if (color_mode == TERM_COLOR_AUTO) {
    color_mode = TERM_COLOR_TRUECOLOR; // xterm.js supports truecolor
  }
  palette_type_t palette_type = (palette_type_t)GET_OPTION(palette_type);
  bool preserve_aspect_ratio = true; // Preserve webcam aspect ratio
  bool stretch = false;              // Don't stretch - maintain proportions
 
  // Build terminal capabilities structure with user's color mode
  terminal_capabilities_t caps = {0}; // Zero-initialize all fields first
  caps.color_level = color_mode;
  caps.capabilities = 0;
  caps.color_count = (color_mode == TERM_COLOR_NONE)  ? 0
                     : (color_mode == TERM_COLOR_16)  ? 16
                     : (color_mode == TERM_COLOR_256) ? 256
                                                      : 16777216;
  caps.utf8_support = true;
  caps.detection_reliable = true;
  caps.render_mode = (render_mode_t)GET_OPTION(render_mode);
  caps.wants_background = (caps.render_mode == RENDER_MODE_BACKGROUND);
  caps.wants_padding = true;
  caps.palette_type = palette_type;
  caps.desired_fps = 60;
  caps.color_filter = filter;
 
  // Convert RGBA to RGB (strip alpha channel) and optionally flip horizontally
  rgb_pixel_t *rgb_pixels = SAFE_MALLOC(src_width * src_height * sizeof(rgb_pixel_t), rgb_pixel_t *);
  if (!rgb_pixels) {
    return NULL;
  }
 
  bool flip_x = GET_OPTION(flip_x);
  bool flip_y = GET_OPTION(flip_y);
  for (int y = 0; y < src_height; y++) {
    for (int x = 0; x < src_width; x++) {
      int src_x = flip_x ? (src_width - 1 - x) : x;
      int src_y = flip_y ? (src_height - 1 - y) : y;
      int src_idx = (src_y * src_width + src_x) * 4;
      int dst_idx = y * src_width + x;
 
      rgb_pixels[dst_idx].r = rgba_data[src_idx + 0];
      rgb_pixels[dst_idx].g = rgba_data[src_idx + 1];
      rgb_pixels[dst_idx].b = rgba_data[src_idx + 2];
      // Alpha (rgba_data[src_idx + 3]) is discarded
    }
  }
 
  // Apply color filter to pixels if needed (except rainbow - handled in ANSI stage)
  if (filter != COLOR_FILTER_NONE && filter != COLOR_FILTER_RAINBOW) {
    // color_filter operates on packed RGB24 format
    uint8_t *rgb24 = (uint8_t *)rgb_pixels;
    int stride = src_width * 3;
    apply_color_filter(rgb24, src_width, src_height, stride, filter, time_seconds);
  }
 
  // Create image structure
  image_t img = {.w = src_width, .h = src_height, .pixels = rgb_pixels, .alloc_method = IMAGE_ALLOC_SIMD};
 
  // Get palette characters based on selected palette type
  const char *palette_chars;
  switch (palette_type) {
  case PALETTE_BLOCKS:
    palette_chars = PALETTE_CHARS_BLOCKS;
    break;
  case PALETTE_DIGITAL:
    palette_chars = PALETTE_CHARS_DIGITAL;
    break;
  case PALETTE_MINIMAL:
    palette_chars = PALETTE_CHARS_MINIMAL;
    break;
  case PALETTE_COOL:
    palette_chars = PALETTE_CHARS_COOL;
    break;
  case PALETTE_CUSTOM:
    // Custom palette uses user-provided characters from options
    palette_chars = GET_OPTION(palette_custom);
    if (!palette_chars || palette_chars[0] == '\0') {
      palette_chars = PALETTE_CHARS_STANDARD; // Fallback
    }
    break;
  case PALETTE_STANDARD:
  default:
    palette_chars = PALETTE_CHARS_STANDARD;
    break;
  }
 
  // Convert to ASCII using capability-aware function
  char *ascii_output = ascii_convert_with_capabilities(&img, dst_width, dst_height, &caps, preserve_aspect_ratio,
                                                       stretch, palette_chars);
 
  // Clean up
  SAFE_FREE(rgb_pixels);
 
  if (!ascii_output) {
    log_error("ascii_convert_with_capabilities returned NULL");
    return NULL;
  }
 
  // Apply rainbow color filter to ANSI output by replacing RGB values
  // This preserves character selection while applying rainbow colors
  if (filter == COLOR_FILTER_RAINBOW) {
    char *rainbow_output = rainbow_replace_ansi_colors(ascii_output, time_seconds);
    if (rainbow_output) {
      SAFE_FREE(ascii_output);
      ascii_output = rainbow_output;
    }
  }
 
  bool matrix_rain = GET_OPTION(matrix_rain);
  if (matrix_rain) {
    // Initialize digital rain context if needed or dimensions changed
    if (!g_digital_rain || g_digital_rain->num_columns != dst_width || g_digital_rain->num_rows != dst_height) {
      if (g_digital_rain) {
        digital_rain_destroy(g_digital_rain);
      }
      if (g_last_rain_output) {
        SAFE_FREE(g_last_rain_output);
        g_last_rain_output = NULL;
      }
      g_digital_rain = digital_rain_init(dst_width, dst_height);
      if (!g_digital_rain) {
        log_error("Failed to initialize digital rain effect");
        return ascii_output; // Return without effect on error
      }
      g_last_rain_update_time = emscripten_get_now();
    }
 
    // Update color from active filter (allows filter changes after initialization)
    digital_rain_set_color_from_filter(g_digital_rain, filter);
 
    // Time-based updates: only update effect every RAIN_UPDATE_INTERVAL_MS
    double current_time = emscripten_get_now();
    double elapsed_ms = current_time - g_last_rain_update_time;
 
    if (elapsed_ms >= RAIN_UPDATE_INTERVAL_MS) {
      // Calculate actual delta time in seconds
      float delta_time = (float)(elapsed_ms / 1000.0);
      g_last_rain_update_time = current_time;
 
      // Apply effect and cache a copy
      char *rain_output = digital_rain_apply(g_digital_rain, ascii_output, delta_time);
      if (rain_output) {
        // Free old cached output
        if (g_last_rain_output) {
          SAFE_FREE(g_last_rain_output);
        }
        // Cache a copy (we'll return the original rain_output)
        g_last_rain_output = strdup(rain_output);
        // Return the rain output (caller will free it)
        SAFE_FREE(ascii_output);
        ascii_output = rain_output;
      }
    } else if (g_last_rain_output) {
      // Use cached output
      SAFE_FREE(ascii_output);
      ascii_output = strdup(g_last_rain_output);
    }
  } else {
    // Clean up digital rain context if it exists but effect is disabled
    if (g_digital_rain) {
      digital_rain_destroy(g_digital_rain);
      g_digital_rain = NULL;
    }
    if (g_last_rain_output) {
      SAFE_FREE(g_last_rain_output);
      g_last_rain_output = NULL;
    }
    g_last_rain_update_time = 0.0;
  }
 
  return ascii_output;
}

References apply_color_filter(), ascii_convert_with_capabilities(), rgb_pixel_t::b, terminal_capabilities_t::capabilities, terminal_capabilities_t::color_count, terminal_capabilities_t::color_filter, COLOR_FILTER_NONE, COLOR_FILTER_RAINBOW, terminal_capabilities_t::color_level, terminal_capabilities_t::desired_fps, terminal_capabilities_t::detection_reliable, digital_rain_apply(), digital_rain_destroy(), digital_rain_init(), digital_rain_set_color_from_filter(), rgb_pixel_t::g, GET_OPTION, IMAGE_ALLOC_SIMD, log_debug, log_error, digital_rain_t::num_columns, digital_rain_t::num_rows, PALETTE_BLOCKS, PALETTE_CHARS_BLOCKS, PALETTE_CHARS_COOL, PALETTE_CHARS_DIGITAL, PALETTE_CHARS_MINIMAL, PALETTE_CHARS_STANDARD, PALETTE_COOL, PALETTE_CUSTOM, PALETTE_DIGITAL, PALETTE_MINIMAL, PALETTE_STANDARD, terminal_capabilities_t::palette_type, rgb_pixel_t::r, RAIN_UPDATE_INTERVAL_MS, rainbow_replace_ansi_colors(), terminal_capabilities_t::render_mode, RENDER_MODE_BACKGROUND, SAFE_FREE, SAFE_MALLOC, TERM_COLOR_16, TERM_COLOR_256, TERM_COLOR_AUTO, TERM_COLOR_NONE, TERM_COLOR_TRUECOLOR, terminal_get_effective_height(), terminal_get_effective_width(), terminal_capabilities_t::utf8_support, image_t::w, terminal_capabilities_t::wants_background, and terminal_capabilities_t::wants_padding.

mirror_free_string()

EMSCRIPTEN_KEEPALIVE void mirror_free_string

(

char *

ptr

)

Definition at line 318 of file mirror.c.

                                   {
  SAFE_FREE(ptr);
}

References SAFE_FREE.

mirror_init_with_args()

EMSCRIPTEN_KEEPALIVE int mirror_init_with_args

(

const char *

args_json

)

Initialize mirror mode with command-line style arguments

Parameters

args_json

JSON array of argument strings, e.g. ["mirror", "--width", "80", "--height", "40"]

Returns

0 on success, -1 on error

Definition at line 47 of file mirror.c.

                                                 {
  // Initialize platform layer
  asciichat_error_t err = platform_init();
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Initialize logging to stderr (console.error in browser)
  log_init(NULL, LOG_DEBUG, true, false);
  // Use debug-style format in WASM so browser console shows full log headers
  log_set_format(OPT_LOG_TEMPLATE_DEFAULT_DEBUG, false);
 
  // Parse space-separated arguments
  char *args_copy = NULL;
  char *argv[64] = {NULL};
  int argc = wasm_parse_args(args_json, argv, 64, &args_copy);
  if (argc < 0) {
    return -1;
  }
 
  // Initialize options (sets up RCU, defaults, etc.)
  err = options_init(argc, argv);
  free(args_copy);
 
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Log option values after initialization
  log_info("[mirror_init_with_args] After options_init: argc=%d, matrix_rain=%d", argc, GET_OPTION(matrix_rain));
 
  // Initialize ANSI color code generation (dec3 cache for RGB values)
  ansi_fast_init();
 
  return 0;
}

References ansi_fast_init(), ASCIICHAT_OK, GET_OPTION, LOG_DEBUG, log_info, log_init(), log_set_format(), OPT_LOG_TEMPLATE_DEFAULT_DEBUG, options_init(), platform_init(), and wasm_parse_args().

mirror_render_audio_visualization()

EMSCRIPTEN_KEEPALIVE char * mirror_render_audio_visualization	(	unsigned int	width,
		unsigned int	height,
		int	source
	)

Definition at line 306 of file mirror.c.

                                                                                             {
  audio_visualization_source_t audio_source = source == AUDIO_VISUALIZATION_SOURCE_MIC
                                                 ? AUDIO_VISUALIZATION_SOURCE_MIC
                                                 : AUDIO_VISUALIZATION_SOURCE_MEDIA;
  if (GET_OPTION(fft))
    return audio_visualization_render_fft(width, height, audio_source, true, AUDIO_VISUALIZATION_COLOR_BRIGHTER,
                                          GET_OPTION(flip_x), GET_OPTION(flip_y));
  return audio_visualization_render_waveform(width, height, audio_source, true, AUDIO_VISUALIZATION_COLOR_BRIGHTER,
                                             GET_OPTION(flip_x), GET_OPTION(flip_y));
}

References AUDIO_VISUALIZATION_COLOR_BRIGHTER, audio_visualization_render_fft(), audio_visualization_render_waveform(), AUDIO_VISUALIZATION_SOURCE_MEDIA, AUDIO_VISUALIZATION_SOURCE_MIC, and GET_OPTION.

mirror_submit_audio_samples()

EMSCRIPTEN_KEEPALIVE void mirror_submit_audio_samples	(	const float *	samples,
		int	count,
		int	source
	)

Definition at line 297 of file mirror.c.

                                                                              {
  if (!samples || count <= 0 || count > 8192)
    return;
  audio_visualization_submit(source == AUDIO_VISUALIZATION_SOURCE_MIC ? AUDIO_VISUALIZATION_SOURCE_MIC
                                                                       : AUDIO_VISUALIZATION_SOURCE_MEDIA,
                             samples, (size_t)count);
}

References AUDIO_VISUALIZATION_SOURCE_MEDIA, AUDIO_VISUALIZATION_SOURCE_MIC, and audio_visualization_submit().

Variable Documentation

g_font_default

const unsigned char g_font_default[]

extern

Referenced by get_font_default_ptr().

g_font_default_size

const size_t g_font_default_size

extern

Referenced by get_font_default_size().

g_font_matrix_resurrected

const unsigned char g_font_matrix_resurrected[]

extern

Referenced by get_font_default_ptr().

g_font_matrix_resurrected_size

const size_t g_font_matrix_resurrected_size

extern

Referenced by get_font_default_size().