renderer.c File Reference

render_file_* — ties together font resolution, platform renderer, FFmpeg encoder More...

Go to the source code of this file.

Data Structures
struct	render_file_ctx_s
	For render file ctx, this is the live record that ties progress, error, renderer, encoder together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. More...

Macros
#define	RENDER_AUTO_FONT_SIZE_PT   12.0
#define	RENDER_AUTO_VIDEO_MAX_DIMENSION   1280
#define	RENDER_AUTO_MIN_FONT_SIZE_PT   3.0

Functions
asciichat_error_t	render_file_create (const char *output_path, int cols, int rows, int fps, int theme, render_file_ctx_t **out)
void	render_file_set_live_timing (render_file_ctx_t *ctx)
asciichat_error_t	render_file_write_frame (render_file_ctx_t *ctx, const char *frame, uint64_t captured_ns)
void	render_file_begin_drain (render_file_ctx_t *ctx, uint64_t total, bool total_known)
void	render_file_set_snapshot_actual_duration (render_file_ctx_t *ctx, double actual_duration_sec)
asciichat_error_t	render_file_destroy (render_file_ctx_t *ctx)

Detailed Description

render_file_* — ties together font resolution, platform renderer, FFmpeg encoder

Definition in file renderer.c.

Macro Definition Documentation

RENDER_AUTO_FONT_SIZE_PT

#define RENDER_AUTO_FONT_SIZE_PT   12.0

Definition at line 23 of file renderer.c.

Referenced by render_file_create().

RENDER_AUTO_MIN_FONT_SIZE_PT

#define RENDER_AUTO_MIN_FONT_SIZE_PT   3.0

Definition at line 25 of file renderer.c.

Referenced by render_file_create().

RENDER_AUTO_VIDEO_MAX_DIMENSION

#define RENDER_AUTO_VIDEO_MAX_DIMENSION   1280

Definition at line 24 of file renderer.c.

Referenced by render_file_create().

Function Documentation

render_file_begin_drain()

void render_file_begin_drain	(	render_file_ctx_t *	ctx,
		uint64_t	total,
		bool	total_known )

Definition at line 364 of file renderer.c.

                                                                                       {
  if (ctx)
    render_progress_begin(ctx->progress, total, total_known);
}

References render_file_ctx_s::progress, and render_progress_begin().

Referenced by session_display_begin_drain().

render_file_create()

asciichat_error_t render_file_create	(	const char *	output_path,
		int	cols,
		int	rows,
		int	fps,
		int	theme,
		render_file_ctx_t **	out )

Definition at line 53 of file renderer.c.

                                                              {
  if (!output_path || !out || cols <= 0 || rows <= 0)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing render output, grid, or context");
  *out = NULL;
  log_info("output_path=%s, cols=%d, rows=%d, fps=%d, theme=%d, out=%p", output_path ? output_path : "(null)", cols,
           rows, fps, theme, (void *)out);
  render_file_ctx_t *ctx = SAFE_CALLOC(1, sizeof(*ctx), render_file_ctx_t *);
  if (strcmp(output_path, "/dev/null") == 0) {
    ctx->discard = true;
    ctx->error = ASCIICHAT_OK;
    *out = ctx;
    return ASCIICHAT_OK;
  }
  ctx->kitty_only = strcmp(output_path, "--kitty") == 0;
  ctx->kitty = ctx->kitty_only || GET_OPTION(render_kitty);
  if (ctx->kitty && !GET_OPTION(snapshot_mode)) {
    SAFE_FREE(ctx);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Kitty graphics output requires --snapshot");
  }
  if (ctx->kitty && (strcmp(output_path, "-") == 0 || strcmp(output_path, "pipe:") == 0)) {
    SAFE_FREE(ctx);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Kitty graphics and binary media cannot share stdout");
  }
  const char *term = SAFE_GETENV("TERM");
  if (ctx->kitty && terminal_is_stdout_tty() &&
      (!term || strcmp(term, "dumb") == 0 || strcmp(term, "linux") == 0 || strcmp(term, "vt100") == 0)) {
    SAFE_FREE(ctx);
    return SET_ERRNO(ERROR_NOT_SUPPORTED,
                     "Kitty graphics require a capable terminal; redirect stdout to export the protocol");
  }
 
  // Resolve font spec → platform-appropriate file path, family name, or bundled data.
  char font_spec[PLATFORM_MAX_PATH_LENGTH] = {0};
  bool font_is_path = false;
  const uint8_t *font_data = NULL;
  size_t font_data_size = 0;
  const char *raw_font = GET_OPTION(render_font);
 
  // Log the font option value from GET_OPTION (for WASM font debugging)
  log_info("[WASM_FONT_GETTER] GET_OPTION(render_font) returned: '%s' (empty=%d), GET_OPTION(matrix_rain)=%d",
           raw_font ? raw_font : "(null)", (!raw_font || raw_font[0] == '\0') ? 1 : 0, GET_OPTION(matrix_rain));
 
  // Auto-select matrix font when --matrix flag is set, unless user explicitly overrides with --render-font
  log_debug("raw_font=%s, matrix_rain=%d", raw_font, GET_OPTION(matrix_rain));
  if ((!raw_font || raw_font[0] == '\0') && GET_OPTION(matrix_rain)) {
    raw_font = "matrix";
    log_debug("[MATRIX] Using matrix font (enabled by --matrix flag)");
  }
 
  platform_font_register("matrix", g_font_matrix_resurrected, g_font_matrix_resurrected_size);
  platform_font_register("default", g_font_default, g_font_default_size);
  platform_font_register("DejaVu Sans Mono", g_font_default, g_font_default_size);
  asciichat_error_t fe =
      platform_font_resolve(raw_font, font_spec, sizeof(font_spec), &font_is_path, &font_data, &font_data_size);
  if (fe != ASCIICHAT_OK) {
    if (raw_font && raw_font[0]) {
      SAFE_FREE(ctx);
      return fe;
    }
    log_warn("font resolution failed for '%s' — using bundled default", raw_font ? raw_font : "(explicit system)");
    fe = platform_font_resolve("default", font_spec, sizeof(font_spec), &font_is_path, &font_data, &font_data_size);
    if (fe != ASCIICHAT_OK) {
      SAFE_FREE(ctx);
      return fe;
    }
  }
 
  log_debug("Font resolved: font_spec='%s', font_is_path=%d, font_data=%p (size=%zu)", font_spec, font_is_path,
            (void *)font_data, font_data_size);
 
  // A zero size selects a compact default for video; explicit font sizes keep
  // their exact dimensions. Images and Kitty snapshots retain the 12 pt default.
  double font_size_pt = GET_OPTION(render_font_size);
  const char *extension = strrchr(output_path, '.');
  bool is_image =
      extension && (!strcmp(extension, ".png") || !strcmp(extension, ".jpg") || !strcmp(extension, ".jpeg") ||
                    !strcmp(extension, ".bmp") || !strcmp(extension, ".webp"));
  bool automatic_video_size = font_size_pt == 0.0 && !is_image && !ctx->kitty;
  if (font_size_pt == 0.0) {
    font_size_pt = RENDER_AUTO_FONT_SIZE_PT;
    if (automatic_video_size) {
      double width_scale = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / ((double)cols * 10.0);
      double height_scale = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / ((double)rows * 20.0);
      double scale = width_scale < height_scale ? width_scale : height_scale;
      if (scale < 1.0)
        font_size_pt *= scale;
      if (font_size_pt < RENDER_AUTO_MIN_FONT_SIZE_PT)
        font_size_pt = RENDER_AUTO_MIN_FONT_SIZE_PT;
    }
  }
  term_renderer_theme_t resolved_theme = (term_renderer_theme_t)theme;
  if (resolved_theme == TERM_RENDERER_THEME_AUTO) {
    resolved_theme =
        colorscheme_current_background() == TERM_BACKGROUND_DARK ? TERM_RENDERER_THEME_DARK : TERM_RENDERER_THEME_LIGHT;
    log_debug("auto theme resolved to %s", resolved_theme == TERM_RENDERER_THEME_DARK ? "dark" : "light");
  }
 
  term_renderer_config_t tr_cfg = {
      .cols = cols,
      .rows = rows,
      .font_size_pt = font_size_pt,
      .theme = resolved_theme,
      .font_is_path = font_is_path,
      .font_data = font_data,
      .font_data_size = font_data_size,
  };
  SAFE_STRNCPY(tr_cfg.font_spec, font_spec, sizeof(tr_cfg.font_spec));
 
  asciichat_error_t err = term_renderer_create(&tr_cfg, &ctx->renderer);
  if (err != ASCIICHAT_OK) {
    log_error("term_renderer_create failed: %s", asciichat_error_format(NULL, err));
    SAFE_FREE(ctx);
    return err;
  }
  int actual_width_px = term_renderer_width_px(ctx->renderer);
  int actual_height_px = term_renderer_height_px(ctx->renderer);
  // Hinting and font metrics vary. Recalculate once if the initial estimate
  // exceeds the target, retaining the original renderer if a bitmap font
  // cannot be scaled down.
  if (automatic_video_size &&
      (actual_width_px > RENDER_AUTO_VIDEO_MAX_DIMENSION || actual_height_px > RENDER_AUTO_VIDEO_MAX_DIMENSION) &&
      font_size_pt > RENDER_AUTO_MIN_FONT_SIZE_PT) {
    double width_scale = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / actual_width_px;
    double height_scale = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / actual_height_px;
    double scale = width_scale < height_scale ? width_scale : height_scale;
    double smaller = font_size_pt * scale * 0.98;
    if (smaller < RENDER_AUTO_MIN_FONT_SIZE_PT)
      smaller = RENDER_AUTO_MIN_FONT_SIZE_PT;
    tr_cfg.font_size_pt = smaller;
    terminal_renderer_t *candidate = NULL;
    err = term_renderer_create(&tr_cfg, &candidate);
    if (err == ASCIICHAT_OK) {
      int candidate_width = term_renderer_width_px(candidate);
      int candidate_height = term_renderer_height_px(candidate);
      if (candidate_width <= actual_width_px && candidate_height <= actual_height_px &&
          (candidate_width < actual_width_px || candidate_height < actual_height_px)) {
        term_renderer_destroy(ctx->renderer);
        ctx->renderer = candidate;
        actual_width_px = candidate_width;
        actual_height_px = candidate_height;
      } else {
        term_renderer_destroy(candidate);
      }
    } else {
      term_renderer_destroy(ctx->renderer);
      SAFE_FREE(ctx);
      return err;
    }
  }
  log_info("GRID DIMENSIONS: %ux%u cells -> PIXEL DIMENSIONS: %dx%d px", cols, rows, actual_width_px, actual_height_px);
  log_debug("term_renderer created (%dx%d cells, %dx%d px)", cols, rows, actual_width_px, actual_height_px);
 
  if (ctx->kitty_only) {
    ctx->fps = fps;
    ctx->progress = render_progress_create(true, "terminal");
    NAMED_REGISTER_CONTEXT(ctx, "render_file_ctx", output_path, NULL);
    ui_controller_title_render(UI_TITLE_RENDERING);
    *out = ctx;
    return ASCIICHAT_OK;
  }
  int output_width_px = actual_width_px;
  int output_height_px = actual_height_px;
  if (automatic_video_size &&
      (output_width_px > RENDER_AUTO_VIDEO_MAX_DIMENSION || output_height_px > RENDER_AUTO_VIDEO_MAX_DIMENSION)) {
    double scale_x = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / output_width_px;
    double scale_y = (double)RENDER_AUTO_VIDEO_MAX_DIMENSION / output_height_px;
    double scale = scale_x < scale_y ? scale_x : scale_y;
    output_width_px = ((int)(output_width_px * scale)) & ~1;
    output_height_px = ((int)(output_height_px * scale)) & ~1;
    if (output_width_px < 2)
      output_width_px = 2;
    if (output_height_px < 2)
      output_height_px = 2;
  }
  err = ffmpeg_encoder_create_scaled(output_path, actual_width_px, actual_height_px, output_width_px, output_height_px,
                                     fps, &ctx->encoder);
  if (err != ASCIICHAT_OK) {
    log_error("ffmpeg_encoder_create failed: %s", asciichat_error_format(NULL, err));
    term_renderer_destroy(ctx->renderer);
    SAFE_FREE(ctx);
    return err;
  }
  log_debug("ffmpeg_encoder created successfully");
 
  // Initialize audio fields
  ctx->audio_sample_rate = 48000; // Audio pipeline is 48kHz
  ctx->fps = fps;
  // Allocate large buffer for snapshot mode (5 seconds at 48kHz with ~14 FPS = 3,428 samples per frame)
  // Use 8192 to comfortably handle snapshot reads without excessive overhead
  ctx->audio_buf_size = 8192; // Temporary buffer for reading audio (in floats)
  ctx->audio_read_buf = SAFE_MALLOC(ctx->audio_buf_size * sizeof(float), float *);
 
  err = audio_recording_create_channels(&ctx->recording, 2);
  if (err != ASCIICHAT_OK) {
    ffmpeg_encoder_destroy(ctx->encoder);
    term_renderer_destroy(ctx->renderer);
    SAFE_FREE(ctx->audio_read_buf);
    SAFE_FREE(ctx);
    return err;
  }
  log_info("initialized encoder for %s", output_path);
 
  // Register render file context for debugging
  NAMED_REGISTER_CONTEXT(ctx, "render_file_ctx", output_path, NULL);
 
  bool binary_stdout = strcmp(output_path, "-") == 0 || strcmp(output_path, "pipe:") == 0;
  ctx->progress = render_progress_create(!binary_stdout, output_path);
  ui_controller_title_render(UI_TITLE_RENDERING);
  *out = ctx;
  return ASCIICHAT_OK;
}

References asciichat_error_format(), ASCIICHAT_OK, render_file_ctx_s::audio_buf_size, render_file_ctx_s::audio_read_buf, audio_recording_create_channels(), render_file_ctx_s::audio_sample_rate, colorscheme_current_background(), render_file_ctx_s::discard, render_file_ctx_s::encoder, render_file_ctx_s::error, ERROR_INVALID_PARAM, ERROR_NOT_SUPPORTED, ffmpeg_encoder_create_scaled(), ffmpeg_encoder_destroy(), term_renderer_config_t::font_size_pt, term_renderer_config_t::font_spec, render_file_ctx_s::fps, g_font_default, g_font_default_size, g_font_matrix_resurrected, g_font_matrix_resurrected_size, GET_OPTION, render_file_ctx_s::kitty, render_file_ctx_s::kitty_only, log_debug, log_error, log_info, log_warn, NAMED_REGISTER_CONTEXT, out, PLATFORM_MAX_PATH_LENGTH, render_file_ctx_s::progress, render_file_ctx_s::recording, RENDER_AUTO_FONT_SIZE_PT, RENDER_AUTO_MIN_FONT_SIZE_PT, RENDER_AUTO_VIDEO_MAX_DIMENSION, render_progress_create(), render_file_ctx_s::renderer, SAFE_CALLOC, SAFE_FREE, SAFE_GETENV, SAFE_MALLOC, SAFE_STRNCPY, SET_ERRNO, TERM_BACKGROUND_DARK, term_renderer_create(), term_renderer_destroy(), term_renderer_height_px(), TERM_RENDERER_THEME_AUTO, TERM_RENDERER_THEME_DARK, TERM_RENDERER_THEME_LIGHT, term_renderer_width_px(), ui_controller_title_render(), and UI_TITLE_RENDERING.

Referenced by session_display_init_render_file().

render_file_destroy()

asciichat_error_t render_file_destroy

(

render_file_ctx_t *

ctx

)

Definition at line 375 of file renderer.c.

                                                              {
  if (!ctx)
    return ASCIICHAT_OK;
  if (ctx->discard) {
    SAFE_FREE(ctx);
    return ASCIICHAT_OK;
  }
  NAMED_UNREGISTER(ctx);
  ui_controller_title_render(ctx->error == ASCIICHAT_OK ? UI_TITLE_FINALIZING : UI_TITLE_FAILED);
  render_progress_finalize(ctx->progress);
  uint64_t target = ctx->audio_target;
  asciichat_error_t err = ASCIICHAT_OK;
  while (ctx->audio_samples_written < target) {
    int count = (int)((target - ctx->audio_samples_written) > (uint64_t)ctx->audio_buf_size
                          ? (uint64_t)ctx->audio_buf_size
                          : target - ctx->audio_samples_written);
    audio_recording_read(ctx->recording, ctx->audio_read_buf, count);
    err = ffmpeg_encoder_write_audio(ctx->encoder, ctx->audio_read_buf, count);
    if (err != ASCIICHAT_OK)
      break;
    ctx->audio_samples_written += count;
  }
  audio_recording_destroy(ctx->recording);
  asciichat_error_t close_err = ffmpeg_encoder_destroy(ctx->encoder);
  if (err == ASCIICHAT_OK)
    err = close_err;
  if (ctx->error != ASCIICHAT_OK)
    err = ctx->error;
  render_progress_destroy(ctx->progress);
  if (err == ASCIICHAT_OK && ctx->kitty && ctx->frames_written == 0)
    err = SET_ERRNO(ERROR_MEDIA_INIT, "No snapshot was rendered for Kitty output");
  if (err == ASCIICHAT_OK && ctx->kitty && ctx->frames_written > 0)
    err = kitty_image_write(stdout, term_renderer_pixels(ctx->renderer), term_renderer_width_px(ctx->renderer),
                            term_renderer_height_px(ctx->renderer), term_renderer_pitch(ctx->renderer));
  ui_controller_title_render(err == ASCIICHAT_OK ? UI_TITLE_IDLE : UI_TITLE_FAILED);
  term_renderer_destroy(ctx->renderer);
  SAFE_FREE(ctx->audio_read_buf);
  SAFE_FREE(ctx);
  return err;
}

References ASCIICHAT_OK, render_file_ctx_s::audio_buf_size, render_file_ctx_s::audio_read_buf, audio_recording_destroy(), audio_recording_read(), render_file_ctx_s::audio_samples_written, render_file_ctx_s::audio_target, render_file_ctx_s::discard, render_file_ctx_s::encoder, render_file_ctx_s::error, ERROR_MEDIA_INIT, ffmpeg_encoder_destroy(), ffmpeg_encoder_write_audio(), render_file_ctx_s::frames_written, render_file_ctx_s::kitty, kitty_image_write(), NAMED_UNREGISTER, render_file_ctx_s::progress, render_file_ctx_s::recording, render_progress_destroy(), render_progress_finalize(), render_file_ctx_s::renderer, SAFE_FREE, SET_ERRNO, term_renderer_destroy(), term_renderer_height_px(), term_renderer_pitch(), term_renderer_pixels(), term_renderer_width_px(), ui_controller_title_render(), UI_TITLE_FAILED, UI_TITLE_FINALIZING, and UI_TITLE_IDLE.

Referenced by session_display_finish_render_file().

render_file_set_live_timing()

void render_file_set_live_timing

(

render_file_ctx_t *

ctx

)

Definition at line 266 of file renderer.c.

                                                         {
  if (ctx) {
    ctx->live_timing = true;
    if (ctx->encoder)
      ffmpeg_encoder_set_live_timing(ctx->encoder);
  }
}

References render_file_ctx_s::encoder, ffmpeg_encoder_set_live_timing(), and render_file_ctx_s::live_timing.

Referenced by session_display_render_frame(), and session_display_set_render_live_timing().

render_file_set_snapshot_actual_duration()

void render_file_set_snapshot_actual_duration	(	render_file_ctx_t *	ctx,
		double	actual_duration_sec )

Definition at line 369 of file renderer.c.

                                                                                                  {
  if (!ctx || !ctx->encoder)
    return;
  ffmpeg_encoder_set_snapshot_actual_duration(ctx->encoder, actual_duration_sec);
}

References render_file_ctx_s::encoder, and ffmpeg_encoder_set_snapshot_actual_duration().

Referenced by session_display_set_snapshot_actual_duration().

render_file_write_frame()

asciichat_error_t render_file_write_frame	(	render_file_ctx_t *	ctx,
		const char *	frame,
		uint64_t	captured_ns )

Definition at line 348 of file renderer.c.

                                                                                                           {
  if (!ctx || !frame)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing render context or frame");
  if (ctx->error != ASCIICHAT_OK)
    return ctx->error;
  if (ctx->discard)
    return ASCIICHAT_OK;
  asciichat_error_t err = render_file_write_frame_internal(ctx, frame, captured_ns);
  if (err != ASCIICHAT_OK)
    ui_controller_title_render(UI_TITLE_FAILED);
  render_progress_frame(ctx->progress, frame, err == ASCIICHAT_OK);
  if (err != ASCIICHAT_OK)
    ctx->error = err;
  return err;
}

References ASCIICHAT_OK, render_file_ctx_s::discard, render_file_ctx_s::error, ERROR_INVALID_PARAM, render_file_ctx_s::progress, render_progress_frame(), SET_ERRNO, ui_controller_title_render(), and UI_TITLE_FAILED.

Referenced by session_display_encode_frame(), and session_display_render_frame().