mirror.h File Reference

Go to the source code of this file.

Functions
int	mirror_init (void)
char *	mirror_convert_frame (uint8_t *rgba_data, int src_width, int src_height, int contain)
void	mirror_free_string (char *ptr)
void	mirror_submit_audio_samples (const float *samples, int count, int source)
char *	mirror_render_audio_visualization (unsigned int width, unsigned int height, int source)
void	mirror_cleanup (void)
void	session_render_reset_stabilizer (void)
void	session_render_cleanup (void)

Function Documentation

mirror_cleanup()

void mirror_cleanup

(

void

)

Definition at line 96 of file mirror.c.

                          {
  session_render_cleanup();
  errno_destroy();
  options_state_destroy();
  buffer_system_cleanup();
  platform_destroy();
}

References buffer_system_cleanup(), errno_destroy(), options_state_destroy(), platform_destroy(), and session_render_cleanup().

Referenced by EMSCRIPTEN_BINDINGS(), and RendererSessionBinding::~RendererSessionBinding().

mirror_convert_frame()

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

Definition at line 108 of file mirror.c.

                                                                                           {
  if (!rgba_data || src_width <= 0 || src_height <= 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid browser frame pixels or dimensions");
    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(GET_OPTION(width), 80);
  int dst_height = (int)terminal_get_effective_height(GET_OPTION(height), 24);
  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 = (terminal_render_mode_t)GET_OPTION(render_mode);
  caps.text_renderer = GET_OPTION(renderer);
  caps.stabilize = GET_OPTION(stabilize);
  caps.palette_explicit = GET_OPTION(palette_explicit);
  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) {
    SET_ERRNO(ERROR_MEMORY, "Cannot allocate browser frame 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};
 
  // 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_buffers_stabilized(&img, dst_width, dst_height, &caps, preserve_aspect_ratio,
                                                             stretch, palette_chars, contain != 0, NULL, NULL,
                                                             caps.stabilize ? &g_stabilizer : NULL);
  if (!caps.stabilize)
    ascii_stabilizer_reset(&g_stabilizer);
 
  // 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);
      }
      g_digital_rain = digital_rain_init(dst_width, dst_height);
      if (!g_digital_rain) {
        log_error("Failed to initialize digital rain effect");
        goto validate_output;
      }
      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);
 
    // Always apply rain to the newest input. Caching an entire ANSI frame freezes
    // both the animation and webcam while the browser keeps counting presentations.
    double current_time = emscripten_get_now();
    float delta_time = (float)((current_time - g_last_rain_update_time) / 1000.0);
    g_last_rain_update_time = current_time;
    char *rain_output = digital_rain_apply(g_digital_rain, ascii_output, delta_time);
    if (rain_output) {
      SAFE_FREE(ascii_output);
      ascii_output = 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;
    }
    g_last_rain_update_time = 0.0;
  }
 
validate_output:
  if (ascii_output) {
    bool glyph_match = caps.text_renderer == ASCII_RENDERER_GLYPH && caps.render_mode != RENDER_MODE_HALF_BLOCK &&
                       dst_width > 0 && dst_height > 0 && dst_width <= IMAGE_MAX_WIDTH / 8 &&
                       dst_height <= IMAGE_MAX_HEIGHT / 8 &&
                       (!caps.palette_explicit || ascii_glyph_palette_supported(palette_chars));
    if (!glyph_match && (size_t)utf8_display_width(palette_chars) != utf8_char_count(palette_chars)) {
      ascii_frame_source_t source = {.frame_data = ascii_output, .frame_size = strlen(ascii_output)};
      size_t normalized_size;
      char *rectangular = ascii_create_grid(&source, 1, dst_width, dst_height, &normalized_size);
      SAFE_FREE(ascii_output);
      ascii_output = rectangular;
    }
    if (!ascii_output)
      return NULL;
    acip_render_settings_t rendering = {.caps = caps};
    const char *contract_palette =
        glyph_match && !caps.palette_explicit
            ? " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
            : palette_chars;
    SAFE_STRNCPY(rendering.palette, contract_palette, sizeof(rendering.palette));
    uint32_t effects = matrix_rain ? FRAME_RENDER_CONTRACT_RAIN : 0;
    if (session_frame_validate_contract(ascii_output, strlen(ascii_output), dst_width, dst_height, &rendering,
                                        effects) != ASCIICHAT_OK) {
      SAFE_FREE(ascii_output);
      return NULL;
    }
  }
  return ascii_output;
}

References apply_color_filter(), ascii_convert_with_buffers_stabilized(), ascii_create_grid(), ascii_glyph_palette_supported(), ASCII_RENDERER_GLYPH, ascii_stabilizer_reset(), ASCIICHAT_OK, rgb_pixel_t::b, color_mode, digital_rain_apply(), digital_rain_destroy(), digital_rain_init(), digital_rain_set_color_from_filter(), ERROR_INVALID_PARAM, ERROR_MEMORY, FRAME_RENDER_CONTRACT_RAIN, rgb_pixel_t::g, GET_OPTION, height, IMAGE_MAX_HEIGHT, IMAGE_MAX_WIDTH, log_debug, log_error, acip_render_settings_t::palette, 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, rgb_pixel_t::r, rainbow_replace_ansi_colors(), SAFE_FREE, SAFE_MALLOC, SAFE_STRNCPY, session_frame_validate_contract(), SET_ERRNO, source, utf8_char_count(), utf8_display_width(), and width.

Referenced by MirrorFrameBinding::convert().

mirror_free_string()

void mirror_free_string

(

char *

ptr

)

Definition at line 336 of file mirror.c.

                                   {
  SAFE_FREE(ptr);
}

References SAFE_FREE.

Referenced by MirrorFrameBinding::convert(), and MirrorFrameBinding::renderAudio().

mirror_init()

int mirror_init

(

void

)

Browser-facing C interface implemented in mirror.c.

Initialize mirror mode with native defaults.

Returns

0 on success, -1 on error

Definition at line 51 of file mirror.c.

                      {
  // Initialize platform layer
  asciichat_error_t err = platform_init();
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  char *argv[] = {"mirror", NULL};
  err = options_init(1, argv);
 
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  if (GET_OPTION(fft) && audio_visualization_fft_init() != ASCIICHAT_OK)
    return -1;
 
  // Honor parsed verbosity and let INFO use stdout (console.log).
  log_init(NULL, GET_OPTION(log_level), false, false);
  // Use debug-style format in WASM so browser console shows full log headers.
  log_set_format(OPT_LOG_TEMPLATE_DEFAULT_DEBUG, false);
 
  // Log option values after initialization
  log_info("Mirror options initialized");
 
  // Initialize ANSI color code generation (dec3 cache for RGB values)
  ansi_fast_init();
 
  return 0;
}

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

Referenced by RendererSessionBinding::RendererSessionBinding().

mirror_render_audio_visualization()

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

Definition at line 320 of file mirror.c.

                                                                                             {
  audio_visualization_source_t audio_source =
      source == AUDIO_VISUALIZATION_SOURCE_MIC ? AUDIO_VISUALIZATION_SOURCE_MIC : AUDIO_VISUALIZATION_SOURCE_MEDIA;
  char *text =
      GET_OPTION(fft)
          ? audio_visualization_render_fft(width, height, audio_source, true, AUDIO_VISUALIZATION_COLOR_BRIGHTER,
                                           GET_OPTION(flip_x), GET_OPTION(flip_y))
          : audio_visualization_render_waveform(width, height, audio_source, true, AUDIO_VISUALIZATION_COLOR_BRIGHTER,
                                                GET_OPTION(flip_x), GET_OPTION(flip_y));
  if (text && session_frame_validate(text, strlen(text), width, height) != ASCIICHAT_OK) {
    SAFE_FREE(text);
    return NULL;
  }
  return text;
}

References ASCIICHAT_OK, AUDIO_VISUALIZATION_COLOR_BRIGHTER, audio_visualization_render_fft(), audio_visualization_render_waveform(), AUDIO_VISUALIZATION_SOURCE_MEDIA, AUDIO_VISUALIZATION_SOURCE_MIC, GET_OPTION, height, SAFE_FREE, session_frame_validate(), source, and width.

Referenced by MirrorFrameBinding::renderAudio().

mirror_submit_audio_samples()

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

Definition at line 312 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, audio_visualization_submit(), and source.

Referenced by MirrorFrameBinding::submitAudio().

session_render_cleanup()

void session_render_cleanup

(

void

)

Definition at line 86 of file mirror.c.

                                  {
  session_render_reset_stabilizer();
  if (g_digital_rain) {
    digital_rain_destroy(g_digital_rain);
    g_digital_rain = NULL;
  }
  g_last_rain_update_time = 0.0;
  g_frame_count = 0;
}

References digital_rain_destroy(), and session_render_reset_stabilizer().

Referenced by EMSCRIPTEN_BINDINGS(), and mirror_cleanup().

session_render_reset_stabilizer()

void session_render_reset_stabilizer

(

void

)

Definition at line 82 of file mirror.c.

                                           {
  ascii_stabilizer_reset(&g_stabilizer);
}

References ascii_stabilizer_reset().

Referenced by EMSCRIPTEN_BINDINGS(), and session_render_cleanup().