ansi_fast.c File Reference

⚡ Fast ANSI color code generation with SIMD-accelerated terminal output More...

Go to the source code of this file.

Functions
char *	append_truecolor_fg (char *dst, uint8_t r, uint8_t g, uint8_t b)
char *	append_truecolor_bg (char *dst, uint8_t r, uint8_t g, uint8_t b)
char *	append_truecolor_fg_bg (char *dst, uint8_t fg_r, uint8_t fg_g, uint8_t fg_b, uint8_t bg_r, uint8_t bg_g, uint8_t bg_b)
void	ansi_rle_init (ansi_rle_context_t *ctx, char *buffer, size_t capacity, ansi_color_mode_t mode)
void	ansi_rle_add_pixel (ansi_rle_context_t *ctx, uint8_t r, uint8_t g, uint8_t b, char ascii_char)
void	ansi_rle_finish (ansi_rle_context_t *ctx)
void	ansi_fast_init (void)
void	ansi_fast_init_256color (void)
char *	append_256color_fg (char *dst, uint8_t color_index)
uint8_t	rgb_to_256color (uint8_t r, uint8_t g, uint8_t b)
void	ansi_fast_init_16color (void)
char *	append_16color_fg (char *dst, uint8_t color_index)
char *	append_16color_bg (char *dst, uint8_t color_index)
uint8_t	rgb_to_16color (uint8_t r, uint8_t g, uint8_t b)
void	get_16color_rgb (uint8_t color_index, uint8_t *r, uint8_t *g, uint8_t *b)
uint8_t	rgb_to_16color_dithered (int r, int g, int b, int x, int y, int width, int height, rgb_error_t *error_buffer)
char *	append_color_fg_for_mode (char *dst, uint8_t r, uint8_t g, uint8_t b, terminal_color_mode_t mode)

Detailed Description

⚡ Fast ANSI color code generation with SIMD-accelerated terminal output

Definition in file ansi_fast.c.

Function Documentation

ansi_fast_init()

void ansi_fast_init

(

void

)

Definition at line 198 of file ansi_fast.c.

                          {
  // Initialize the dec3 cache used by truecolor functions
  ascii_simd_init();
}

References ascii_simd_init().

Referenced by client_init_with_args(), mirror_init_with_args(), and session_display_create().

ansi_fast_init_16color()

void ansi_fast_init_16color

(

void

)

Definition at line 257 of file ansi_fast.c.

                                  {
  static_mutex_lock(&g_color16_mutex);
 
  if (color16_initialized) {
    static_mutex_unlock(&g_color16_mutex);
    return;
  }
 
  // Standard ANSI color codes
  const char *fg_codes[] = {"30", "31", "32", "33", "34", "35", "36", "37",          // Normal colors (30-37)
                            "90", "91", "92", "93", "94", "95", "96", "97"};         // Bright colors (90-97)
  const char *bg_codes[] = {"40",  "41",  "42",  "43",  "44",  "45",  "46",  "47",   // Normal colors (40-47)
                            "100", "101", "102", "103", "104", "105", "106", "107"}; // Bright colors (100-107)
 
  for (int i = 0; i < 16; i++) {
    SAFE_SNPRINTF(color16_fg_strings[i], sizeof(color16_fg_strings[i]), "\033[%sm", fg_codes[i]);
    SAFE_SNPRINTF(color16_bg_strings[i], sizeof(color16_bg_strings[i]), "\033[%sm", bg_codes[i]);
  }
 
  color16_initialized = true;
  static_mutex_unlock(&g_color16_mutex);
}

Referenced by append_16color_bg(), append_16color_fg(), image_print_16color(), image_print_16color_dithered(), image_print_16color_dithered_with_background(), and session_display_create().

ansi_fast_init_256color()

void ansi_fast_init_256color

(

void

)

Definition at line 205 of file ansi_fast.c.

                                   {
  static_mutex_lock(&g_color256_mutex);
 
  if (color256_initialized) {
    static_mutex_unlock(&g_color256_mutex);
    return;
  }
 
  for (int i = 0; i < 256; i++) {
    SAFE_SNPRINTF(color256_strings[i], sizeof(color256_strings[i]), "\033[38;5;%dm", i);
  }
 
  color256_initialized = true;
  static_mutex_unlock(&g_color256_mutex);
}

Referenced by session_display_create().

ansi_rle_add_pixel()

void ansi_rle_add_pixel	(	ansi_rle_context_t *	ctx,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b,
		char	ascii_char
	)

Definition at line 142 of file ansi_fast.c.

                                                                                                   {
  // Check if we need to emit a new SGR sequence
  bool color_changed = ctx->first_pixel || (r != ctx->last_r) || (g != ctx->last_g) || (b != ctx->last_b);
 
  if (color_changed) {
    if (ctx->length + 40 >= ctx->capacity) {
      // Log when we can't add a color change due to buffer capacity
      log_warn_every(US_PER_SEC_INT, "RLE_CAPACITY: Cannot add SGR at length=%zu, capacity=%zu (need 40 bytes)",
                     ctx->length, ctx->capacity);
    }
  }
 
  if (color_changed && (ctx->length + 40 < ctx->capacity)) { // Reserve 40 bytes for SGR (FG+BG max is 38)
    char *pos = ctx->buffer + ctx->length;
 
    switch (ctx->mode) {
    case ANSI_MODE_FOREGROUND:
      pos = append_truecolor_fg(pos, r, g, b);
      break;
    case ANSI_MODE_BACKGROUND:
      pos = append_truecolor_bg(pos, r, g, b);
      break;
    case ANSI_MODE_FOREGROUND_BACKGROUND:
      // For FG+BG mode, use a default background (black) or implement dual-color logic
      pos = append_truecolor_fg_bg(pos, r, g, b, 0, 0, 0);
      break;
    }
 
    ctx->length = (size_t)(pos - ctx->buffer);
    ctx->last_r = r;
    ctx->last_g = g;
    ctx->last_b = b;
    ctx->first_pixel = false;
  }
 
  // Add the ASCII character
  if (ctx->length < ctx->capacity - 1) {
    ctx->buffer[ctx->length++] = ascii_char;
  }
}

References append_truecolor_bg(), append_truecolor_fg(), and append_truecolor_fg_bg().

Referenced by image_print_color().

ansi_rle_finish()

void ansi_rle_finish

(

ansi_rle_context_t *

ctx

)

Definition at line 184 of file ansi_fast.c.

                                              {
  // Add reset sequence (requires 4 bytes + 1 for null terminator = 5 bytes total)
  if (ctx->length + 5 <= ctx->capacity) {
    SAFE_MEMCPY(ctx->buffer + ctx->length, 4, "\033[0m", 4);
    ctx->length += 4;
  }
 
  // Null terminate
  if (ctx->length < ctx->capacity) {
    ctx->buffer[ctx->length] = '\0';
  }
}

Referenced by image_print_color().

ansi_rle_init()

void ansi_rle_init	(	ansi_rle_context_t *	ctx,
		char *	buffer,
		size_t	capacity,
		ansi_color_mode_t	mode
	)

Definition at line 129 of file ansi_fast.c.

                                                                                                   {
  ctx->buffer = buffer;
  ctx->capacity = capacity;
  ctx->length = 0;
  ctx->mode = mode;
  ctx->first_pixel = true;
  // Initialize with impossible color values to force first SGR
  ctx->last_r = 0xFF;
  ctx->last_g = 0xFF;
  ctx->last_b = 0xFF;
}

Referenced by image_print_color().

append_16color_bg()

char * append_16color_bg	(	char *	dst,
		uint8_t	color_index
	)

Definition at line 297 of file ansi_fast.c.

                                                        {
  if (!color16_initialized) {
    ansi_fast_init_16color();
  }
 
  if (color_index >= 16) {
    color_index = 0; // Default to black background
  }
 
  const char *color_str = color16_bg_strings[color_index];
  while (*color_str) {
    *dst++ = *color_str++;
  }
 
  return dst;
}

References ansi_fast_init_16color().

Referenced by image_print_16color_dithered_with_background().

append_16color_fg()

char * append_16color_fg	(	char *	dst,
		uint8_t	color_index
	)

Definition at line 280 of file ansi_fast.c.

                                                        {
  if (!color16_initialized) {
    ansi_fast_init_16color();
  }
 
  if (color_index >= 16) {
    color_index = 7; // Default to white
  }
 
  const char *color_str = color16_fg_strings[color_index];
  while (*color_str) {
    *dst++ = *color_str++;
  }
 
  return dst;
}

References ansi_fast_init_16color().

Referenced by append_color_fg_for_mode(), image_print_16color(), image_print_16color_dithered(), and image_print_16color_dithered_with_background().

append_256color_fg()

char * append_256color_fg	(	char *	dst,
		uint8_t	color_index
	)

Definition at line 222 of file ansi_fast.c.

                                                         {
  const char *color_str = color256_strings[color_index];
  size_t len = strlen(color_str);
  SAFE_MEMCPY(dst, len, color_str, len);
  return dst + len;
}

Referenced by append_color_fg_for_mode().

append_color_fg_for_mode()

char * append_color_fg_for_mode	(	char *	dst,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b,
		terminal_color_mode_t	mode
	)

Definition at line 463 of file ansi_fast.c.

                                                                                                       {
  switch (mode) {
  case COLOR_MODE_TRUECOLOR:
    return append_truecolor_fg(dst, r, g, b);
 
  case COLOR_MODE_256_COLOR: {
    uint8_t color_index = rgb_to_256color(r, g, b);
    return append_256color_fg(dst, color_index);
  }
 
  case COLOR_MODE_16_COLOR: {
    uint8_t color_index = rgb_to_16color(r, g, b);
    return append_16color_fg(dst, color_index);
  }
 
  case COLOR_MODE_NONE:
  case COLOR_MODE_AUTO:
  default:
    // No color output for monochrome mode or auto mode (fallback)
    return dst;
  }
}

References append_16color_fg(), append_256color_fg(), append_truecolor_fg(), rgb_to_16color(), and rgb_to_256color().

append_truecolor_bg()

char * append_truecolor_bg	(	char *	dst,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Definition at line 56 of file ansi_fast.c.

                                                                      {
  // Ensure dec3 cache is initialized
  if (!g_dec3_cache.dec3_initialized) {
    init_dec3();
  }
 
  SAFE_MEMCPY(dst, 19, "\033[48;2;", 7);
  dst += 7;
 
  SAFE_MEMCPY(dst, 12, g_dec3_cache.dec3_table[r].s, g_dec3_cache.dec3_table[r].len);
  dst += g_dec3_cache.dec3_table[r].len;
  *dst++ = ';';
 
  SAFE_MEMCPY(dst, 8, g_dec3_cache.dec3_table[g].s, g_dec3_cache.dec3_table[g].len);
  dst += g_dec3_cache.dec3_table[g].len;
  *dst++ = ';';
 
  SAFE_MEMCPY(dst, 4, g_dec3_cache.dec3_table[b].s, g_dec3_cache.dec3_table[b].len);
  dst += g_dec3_cache.dec3_table[b].len;
  *dst++ = 'm';
 
  return dst;
}

References g_dec3_cache, and init_dec3().

Referenced by ansi_rle_add_pixel(), grep_highlight(), and grep_highlight_colored().

append_truecolor_fg()

char * append_truecolor_fg	(	char *	dst,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Definition at line 26 of file ansi_fast.c.

                                                                      {
  // Ensure dec3 cache is initialized
  if (!g_dec3_cache.dec3_initialized) {
    init_dec3();
  }
 
  // Static prefix - 7 bytes
  SAFE_MEMCPY(dst, 19, "\033[38;2;", 7);
  dst += 7;
 
  // Red component + semicolon
  SAFE_MEMCPY(dst, 12, g_dec3_cache.dec3_table[r].s, g_dec3_cache.dec3_table[r].len);
  dst += g_dec3_cache.dec3_table[r].len;
  *dst++ = ';';
 
  // Green component + semicolon
  SAFE_MEMCPY(dst, 8, g_dec3_cache.dec3_table[g].s, g_dec3_cache.dec3_table[g].len);
  dst += g_dec3_cache.dec3_table[g].len;
  *dst++ = ';';
 
  // Blue component + suffix
  SAFE_MEMCPY(dst, 4, g_dec3_cache.dec3_table[b].s, g_dec3_cache.dec3_table[b].len);
  dst += g_dec3_cache.dec3_table[b].len;
  *dst++ = 'm';
 
  return dst;
}

References g_dec3_cache, and init_dec3().

Referenced by ansi_rle_add_pixel(), and append_color_fg_for_mode().

append_truecolor_fg_bg()

char * append_truecolor_fg_bg	(	char *	dst,
		uint8_t	fg_r,
		uint8_t	fg_g,
		uint8_t	fg_b,
		uint8_t	bg_r,
		uint8_t	bg_g,
		uint8_t	bg_b
	)

Definition at line 82 of file ansi_fast.c.

                                           {
  // Ensure dec3 cache is initialized
  if (!g_dec3_cache.dec3_initialized) {
    init_dec3();
  }
 
  SAFE_MEMCPY(dst, 38, "\033[38;2;", 7);
  dst += 7;
 
  // Foreground RGB (remaining: 31 bytes max)
  SAFE_MEMCPY(dst, 31, g_dec3_cache.dec3_table[fg_r].s, g_dec3_cache.dec3_table[fg_r].len);
  dst += g_dec3_cache.dec3_table[fg_r].len;
  *dst++ = ';';
 
  // Remaining: 27 bytes max
  SAFE_MEMCPY(dst, 27, g_dec3_cache.dec3_table[fg_g].s, g_dec3_cache.dec3_table[fg_g].len);
  dst += g_dec3_cache.dec3_table[fg_g].len;
  *dst++ = ';';
 
  // Remaining: 23 bytes max
  SAFE_MEMCPY(dst, 23, g_dec3_cache.dec3_table[fg_b].s, g_dec3_cache.dec3_table[fg_b].len);
  dst += g_dec3_cache.dec3_table[fg_b].len;
 
  // Background RGB (remaining: 20 bytes max)
  SAFE_MEMCPY(dst, 20, ";48;2;", 6);
  dst += 6;
 
  // Remaining: 14 bytes max
  SAFE_MEMCPY(dst, 14, g_dec3_cache.dec3_table[bg_r].s, g_dec3_cache.dec3_table[bg_r].len);
  dst += g_dec3_cache.dec3_table[bg_r].len;
  *dst++ = ';';
 
  // Remaining: 10 bytes max
  SAFE_MEMCPY(dst, 10, g_dec3_cache.dec3_table[bg_g].s, g_dec3_cache.dec3_table[bg_g].len);
  dst += g_dec3_cache.dec3_table[bg_g].len;
  *dst++ = ';';
 
  // Remaining: 6 bytes max
  SAFE_MEMCPY(dst, 6, g_dec3_cache.dec3_table[bg_b].s, g_dec3_cache.dec3_table[bg_b].len);
  dst += g_dec3_cache.dec3_table[bg_b].len;
  *dst++ = 'm';
 
  return dst;
}

References g_dec3_cache, and init_dec3().

Referenced by ansi_rle_add_pixel().

get_16color_rgb()

void get_16color_rgb	(	uint8_t	color_index,
		uint8_t *	r,
		uint8_t *	g,
		uint8_t *	b
	)

Definition at line 357 of file ansi_fast.c.

                                                                              {
  // Same color table as rgb_to_16color()
  static const uint8_t ansi_colors[16][3] = {
      {0, 0, 0},       // 0: Black
      {128, 0, 0},     // 1: Dark Red
      {0, 128, 0},     // 2: Dark Green
      {128, 128, 0},   // 3: Dark Yellow (Brown)
      {0, 0, 128},     // 4: Dark Blue
      {128, 0, 128},   // 5: Dark Magenta
      {0, 128, 128},   // 6: Dark Cyan
      {192, 192, 192}, // 7: Light Gray
      {128, 128, 128}, // 8: Dark Gray
      {255, 0, 0},     // 9: Bright Red
      {0, 255, 0},     // 10: Bright Green
      {255, 255, 0},   // 11: Bright Yellow
      {0, 0, 255},     // 12: Bright Blue
      {255, 0, 255},   // 13: Bright Magenta
      {0, 255, 255},   // 14: Bright Cyan
      {255, 255, 255}  // 15: White
  };
 
  if (color_index >= 16) {
    color_index = 7; // Default to light gray
  }
 
  *r = ansi_colors[color_index][0];
  *g = ansi_colors[color_index][1];
  *b = ansi_colors[color_index][2];
}

Referenced by image_print_16color_dithered_with_background(), and rgb_to_16color_dithered().

rgb_to_16color()

uint8_t rgb_to_16color	(	uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Definition at line 314 of file ansi_fast.c.

                                                        {
  // Convert RGB to the closest 16-color ANSI color
  // This uses a simple distance-based approach
 
  // Define the 16 ANSI colors in RGB
  static const uint8_t ansi_colors[16][3] = {
      {0, 0, 0},       // 0: Black
      {128, 0, 0},     // 1: Dark Red
      {0, 128, 0},     // 2: Dark Green
      {128, 128, 0},   // 3: Dark Yellow (Brown)
      {0, 0, 128},     // 4: Dark Blue
      {128, 0, 128},   // 5: Dark Magenta
      {0, 128, 128},   // 6: Dark Cyan
      {192, 192, 192}, // 7: Light Gray
      {128, 128, 128}, // 8: Dark Gray
      {255, 0, 0},     // 9: Bright Red
      {0, 255, 0},     // 10: Bright Green
      {255, 255, 0},   // 11: Bright Yellow
      {0, 0, 255},     // 12: Bright Blue
      {255, 0, 255},   // 13: Bright Magenta
      {0, 255, 255},   // 14: Bright Cyan
      {255, 255, 255}  // 15: White
  };
 
  uint8_t best_match = 0;
  int min_distance = INT_MAX;
 
  for (int i = 0; i < 16; i++) {
    int dr = (int)r - (int)ansi_colors[i][0];
    int dg = (int)g - (int)ansi_colors[i][1];
    int db = (int)b - (int)ansi_colors[i][2];
    int distance = dr * dr + dg * dg + db * db;
 
    if (distance < min_distance) {
      min_distance = distance;
      best_match = i;
    }
  }
 
  return best_match;
}

Referenced by append_color_fg_for_mode(), colorscheme_compile_scheme(), image_print_16color(), and rgb_to_16color_dithered().

rgb_to_16color_dithered()

uint8_t rgb_to_16color_dithered	(	int	r,
		int	g,
		int	b,
		int	x,
		int	y,
		int	width,
		int	height,
		rgb_error_t *	error_buffer
	)

Definition at line 388 of file ansi_fast.c.

                                                                                                                     {
  // Add accumulated error from previous pixels
  if (error_buffer) {
    // Use size_t for index calculation to prevent integer overflow on large images
    size_t error_idx = (size_t)y * (size_t)width + (size_t)x;
    r += error_buffer[error_idx].r;
    g += error_buffer[error_idx].g;
    b += error_buffer[error_idx].b;
 
    // Reset error for this pixel
    error_buffer[error_idx].r = 0;
    error_buffer[error_idx].g = 0;
    error_buffer[error_idx].b = 0;
  }
 
  // Clamp values to [0, 255]
  uint8_t r_clamped = clamp_rgb((int)r);
  uint8_t g_clamped = clamp_rgb((int)g);
  uint8_t b_clamped = clamp_rgb((int)b);
 
  // Find the closest 16-color match
  uint8_t closest_color = rgb_to_16color(r_clamped, g_clamped, b_clamped);
 
  // Calculate quantization error if dithering is enabled
  if (error_buffer) {
    uint8_t actual_r, actual_g, actual_b;
    get_16color_rgb(closest_color, &actual_r, &actual_g, &actual_b);
 
    int error_r = r - (int)actual_r;
    int error_g = g - (int)actual_g;
    int error_b = b - (int)actual_b;
 
    // Distribute error using Floyd-Steinberg weights:
    //     * 7/16
    // 3/16 5/16 1/16
 
    // Error to right pixel (x+1, y)
    // Use size_t for all index calculations to prevent integer overflow
    if (x + 1 < width) {
      size_t right_idx = (size_t)y * (size_t)width + (size_t)(x + 1);
      error_buffer[right_idx].r += (error_r * 7) / 16;
      error_buffer[right_idx].g += (error_g * 7) / 16;
      error_buffer[right_idx].b += (error_b * 7) / 16;
    }
 
    // Error to pixels on next row (y+1)
    if (y + 1 < height) {
      // Bottom-left pixel (x-1, y+1)
      if (x - 1 >= 0) {
        size_t bl_idx = (size_t)(y + 1) * (size_t)width + (size_t)(x - 1);
        error_buffer[bl_idx].r += (error_r * 3) / 16;
        error_buffer[bl_idx].g += (error_g * 3) / 16;
        error_buffer[bl_idx].b += (error_b * 3) / 16;
      }
 
      // Bottom pixel (x, y+1)
      size_t bottom_idx = (size_t)(y + 1) * (size_t)width + (size_t)x;
      error_buffer[bottom_idx].r += (error_r * 5) / 16;
      error_buffer[bottom_idx].g += (error_g * 5) / 16;
      error_buffer[bottom_idx].b += (error_b * 5) / 16;
 
      // Bottom-right pixel (x+1, y+1)
      if (x + 1 < width) {
        size_t br_idx = (size_t)(y + 1) * (size_t)width + (size_t)(x + 1);
        error_buffer[br_idx].r += (error_r * 1) / 16;
        error_buffer[br_idx].g += (error_g * 1) / 16;
        error_buffer[br_idx].b += (error_b * 1) / 16;
      }
    }
  }
 
  return closest_color;
}

References get_16color_rgb(), and rgb_to_16color().

Referenced by image_print_16color_dithered(), and image_print_16color_dithered_with_background().

rgb_to_256color()

uint8_t rgb_to_256color	(	uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Definition at line 230 of file ansi_fast.c.

                                                         {
  // Map to 6x6x6 color cube (216 colors) + grayscale ramp
 
  // Check if it's close to grayscale
  int avg = (r + g + b) / 3;
  int gray_diff = abs(r - avg) + abs(g - avg) + abs(b - avg);
 
  if (gray_diff < 30) {
    // Use grayscale ramp (colors 232-255)
    int gray_level = (avg * 23) / 255;
    return (uint8_t)(232 + gray_level);
  }
 
  // Use 6x6x6 color cube (colors 16-231)
  int r6 = (r * 5) / 255;
  int g6 = (g * 5) / 255;
  int b6 = (b * 5) / 255;
 
  return (uint8_t)(16 + (r6 * 36) + (g6 * 6) + b6);
}

Referenced by append_color_fg_for_mode(), and colorscheme_compile_scheme().