ANSI Utilities

Data Structures
struct	ansi_rle_context_t
struct	ansi_timing_t
struct	rgb_error_t

Enumerations
enum	ansi_color_mode_t { ANSI_MODE_FOREGROUND = 0 , ANSI_MODE_BACKGROUND , ANSI_MODE_FOREGROUND_BACKGROUND }

Functions
char *	ansi_strip_escapes (const char *input, size_t input_len)
	Strip all ANSI escape sequences from a string.
const char *	ansi_skip_escape (const char *ptr, const char *end)
	Find the end of an ANSI CSI escape sequence.
bool	ansi_is_already_colorized (const char *message, size_t pos)
	Check if a position in text is already colored.
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)
void	ansi_fast_init_16color (void)
char *	append_256color_fg (char *dst, uint8_t color_index)
char *	append_256color_bg (char *dst, uint8_t color_index)
uint8_t	rgb_to_256color (uint8_t r, uint8_t g, uint8_t b)
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

Enumeration Type Documentation

ansi_color_mode_t

enum ansi_color_mode_t

#include <ansi.h>

Enumerator
ANSI_MODE_FOREGROUND
ANSI_MODE_BACKGROUND
ANSI_MODE_FOREGROUND_BACKGROUND

Definition at line 38 of file ansi.h.

             {
  ANSI_MODE_FOREGROUND = 0,
  ANSI_MODE_BACKGROUND,
  ANSI_MODE_FOREGROUND_BACKGROUND,
} ansi_color_mode_t;

Function Documentation

ansi_fast_init()

void ansi_fast_init

(

void

)

#include <ansi.h>

Initialize fast ANSI generation (call once at startup)

Definition at line 319 of file ansi.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

)

#include <ansi.h>

Initialize 16-color mode (thread-safe, called on first use)

Definition at line 398 of file ansi.c.

                                  {
  if (!lifecycle_init(&g_color16_lc, "ansi_16color")) {
    return; // Already initialized
  }
  do_init_16color();
}

References lifecycle_init().

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

ansi_fast_init_256color()

void ansi_fast_init_256color

(

void

)

#include <ansi.h>

Initialize 256-color mode (thread-safe, called on first use)

Definition at line 334 of file ansi.c.

                                   {
  if (!lifecycle_init(&g_color256_lc, "ansi_256color")) {
    return; // Already initialized
  }
  do_init_256color();
}

References lifecycle_init().

Referenced by image_print_256color(), rgb_to_256color_halfblocks_scalar(), and session_display_create().

ansi_is_already_colorized()

bool ansi_is_already_colorized	(	const char *	message,
		size_t	pos
	)

#include <ansi.h>

Check if a position in text is already colored.

Scans from the start of the message to the given position, tracking ANSI escape codes. Returns true if there is an active color code (not in reset state).

Detects reset codes: \x1b[0m and \x1b[m

Parameters

message	The full message
pos	Position to check

Returns

true if already colored (not in reset state), false if in reset state

Definition at line 98 of file ansi.c.

                                                                {
  if (!message) {
    return false;
  }
 
  bool in_reset = true; // Start in reset state
 
  // Scan from beginning to current position looking for ANSI codes
  for (size_t i = 0; i < pos && message[i] != '\0'; i++) {
    if (message[i] == '\x1b' && message[i + 1] == '[') {
      // Found ANSI escape sequence start
      // Look for the end marker 'm'
      size_t j = i + 2;
      while (message[j] != '\0' && message[j] != 'm') {
        j++;
      }
 
      if (message[j] == 'm') {
        // Extract the color code part (between [ and m)
        // Check if it's a reset code: \x1b[0m or \x1b[m
        in_reset = ((j == i + 3 && message[i + 2] == '0') || (j == i + 2));
      }
    }
  }
 
  // Return true if NOT in reset state (already colorized)
  return !in_reset;
}

Referenced by colorize_log_message().

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
	)

#include <ansi.h>

Add pixel with run-length encoding (only emits SGR when color changes)

Parameters

ctx	RLE context
r	Red component
g	Green component
b	Blue component
ascii_char	ASCII character to append

Definition at line 261 of file ansi.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 ANSI_MODE_BACKGROUND, ANSI_MODE_FOREGROUND, ANSI_MODE_FOREGROUND_BACKGROUND, append_truecolor_bg(), append_truecolor_fg(), append_truecolor_fg_bg(), ansi_rle_context_t::buffer, ansi_rle_context_t::capacity, ansi_rle_context_t::first_pixel, ansi_rle_context_t::last_b, ansi_rle_context_t::last_g, ansi_rle_context_t::last_r, ansi_rle_context_t::length, log_warn_every, ansi_rle_context_t::mode, and US_PER_SEC_INT.

Referenced by image_print_color().

ansi_rle_finish()

void ansi_rle_finish

(

ansi_rle_context_t *

ctx

)

#include <ansi.h>

Finish RLE sequence with reset and null terminator

Parameters

ctx	RLE context

Definition at line 303 of file ansi.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';
  }
}

References ansi_rle_context_t::buffer, ansi_rle_context_t::capacity, ansi_rle_context_t::length, and SAFE_MEMCPY.

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
	)

#include <ansi.h>

Initialize RLE context for efficient ANSI generation

Parameters

ctx	Context to initialize
buffer	Output buffer
capacity	Buffer capacity
mode	Color mode (foreground/background/both)

Definition at line 248 of file ansi.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;
}

References ansi_rle_context_t::buffer, ansi_rle_context_t::capacity, ansi_rle_context_t::first_pixel, ansi_rle_context_t::last_b, ansi_rle_context_t::last_g, ansi_rle_context_t::last_r, ansi_rle_context_t::length, and ansi_rle_context_t::mode.

Referenced by image_print_color().

ansi_skip_escape()

const char * ansi_skip_escape	(	const char *	ptr,
		const char *	end
	)

#include <ansi.h>

Find the end of an ANSI CSI escape sequence.

Given a pointer to an ESC character (\x1b) that starts a CSI sequence, returns a pointer past the final byte of the sequence. If the pointer does not point to a valid CSI sequence start, returns ptr + 1.

Parameters

ptr	Pointer to the ESC (\x1b) character
end	Pointer past the end of the string

Returns

Pointer to the first byte after the escape sequence

Definition at line 74 of file ansi.c.

                                                               {
  if (!ptr || ptr >= end || *ptr != '\x1b') {
    return ptr ? ptr + 1 : ptr;
  }
 
  const char *p = ptr + 1;
  if (p >= end || *p != '[') {
    return p; // Not a CSI sequence, skip just the ESC byte
  }
  p++; // Skip '['
 
  // Skip parameter bytes (0x30-0x3F) and intermediate bytes (0x20-0x2F)
  while (p < end && ((*p >= 0x30 && *p <= 0x3F) || (*p >= 0x20 && *p <= 0x2F))) {
    p++;
  }
 
  // Skip final byte (0x40-0x7E)
  if (p < end && *p >= 0x40 && *p <= 0x7E) {
    p++;
  }
 
  return p;
}

Referenced by truncate_with_ellipsis().

ansi_strip_escapes()

char * ansi_strip_escapes	(	const char *	input,
		size_t	input_len
	)

#include <ansi.h>

Strip all ANSI escape sequences from a string.

Removes all ANSI CSI sequences (ESC [ ... final_byte) from the input, leaving only printable text. Useful for creating plain text output from colorized ASCII art.

Parameters

input	Input string containing ANSI escape sequences
input_len	Length of input string

Returns

Newly allocated string with escapes removed (caller must free), or NULL on error

Definition at line 23 of file ansi.c.

                                                              {
  if (!input || input_len == 0) {
    return NULL;
  }
 
  // Allocate buffer directly for output (at most input_len bytes)
  char *output = SAFE_MALLOC(input_len + 1, char *);
  if (!output) {
    return NULL;
  }
 
  size_t out_pos = 0;
  size_t i = 0;
 
  while (i < input_len) {
    // Check for ESC character (start of ANSI sequence)
    if (input[i] == '\x1b' && i + 1 < input_len && input[i + 1] == '[') {
      // Skip ESC[
      i += 2;
 
      // Skip parameter bytes (digits, semicolons, and intermediate bytes)
      while (i < input_len) {
        char c = input[i];
        // Parameter bytes: 0x30-0x3F (digits, semicolon, etc.)
        // Intermediate bytes: 0x20-0x2F (space, !, ", etc.)
        if ((c >= 0x30 && c <= 0x3F) || (c >= 0x20 && c <= 0x2F)) {
          i++;
        } else {
          break;
        }
      }
 
      // Skip final byte (0x40-0x7E: @, A-Z, [, \, ], ^, _, `, a-z, {, |, }, ~)
      if (i < input_len) {
        char final = input[i];
        if (final >= 0x40 && final <= 0x7E) {
          i++;
        }
      }
    } else {
      // Regular character - copy to output
      output[out_pos++] = input[i];
      i++;
    }
  }
 
  // Null-terminate the output
  output[out_pos] = '\0';
  return output;
}

References SAFE_MALLOC.

Referenced by display_height(), display_width(), layout_print_two_column_row(), and log_mmap_write().

append_16color_bg()

char * append_16color_bg	(	char *	dst,
		uint8_t	color_index
	)

#include <ansi.h>

Append 16-color ANSI background SGR sequence

Parameters

dst	Destination buffer
color_index	16-color index (0-15)

Returns

Pointer to end of written data

Definition at line 421 of file ansi.c.

                                                        {
  // Ensure initialization before use
  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(), and rgb_to_16color_halfblocks_scalar().

append_16color_fg()

char * append_16color_fg	(	char *	dst,
		uint8_t	color_index
	)

#include <ansi.h>

Append 16-color ANSI foreground SGR sequence

Parameters

dst	Destination buffer
color_index	16-color index (0-15)

Returns

Pointer to end of written data

Definition at line 405 of file ansi.c.

                                                        {
  // Ensure initialization before use
  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(), image_print_16color_dithered_with_background(), and rgb_to_16color_halfblocks_scalar().

append_256color_bg()

char * append_256color_bg	(	char *	dst,
		uint8_t	color_index
	)

#include <ansi.h>

Append 256-color background SGR sequence

Parameters

dst	Destination buffer
color_index	256-color palette index (0-255)

Returns

Pointer to end of written data

Definition at line 352 of file ansi.c.

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

References SAFE_MEMCPY.

Referenced by rgb_to_256color_halfblocks_scalar().

append_256color_fg()

char * append_256color_fg	(	char *	dst,
		uint8_t	color_index
	)

#include <ansi.h>

Append 256-color foreground SGR sequence

Parameters

dst	Destination buffer
color_index	256-color palette index (0-255)

Returns

Pointer to end of written data

Definition at line 344 of file ansi.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;
}

References SAFE_MEMCPY.

Referenced by append_color_fg_for_mode(), image_print_256color(), and rgb_to_256color_halfblocks_scalar().

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
	)

#include <ansi.h>

Append color SGR sequence for the appropriate terminal color mode

Parameters

dst	Destination buffer
r	Red component
g	Green component
b	Blue component
mode	Terminal color mode capability

Returns

Pointer to end of written data

Definition at line 588 of file ansi.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(), COLOR_MODE_16_COLOR, COLOR_MODE_256_COLOR, COLOR_MODE_AUTO, COLOR_MODE_NONE, COLOR_MODE_TRUECOLOR, 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
	)

#include <ansi.h>

Append truecolor background SGR sequence Maximum output: 19 bytes (\033[48;2;255;255;255m)

Parameters

dst	Destination buffer
r	Red component
g	Green component
b	Blue component

Returns

Pointer to end of written data

Definition at line 173 of file ansi.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 global_dec3_cache_t::dec3_initialized, global_dec3_cache_t::dec3_table, g_dec3_cache, init_dec3(), dec3_t::len, dec3_t::s, and SAFE_MEMCPY.

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
	)

#include <ansi.h>

Append truecolor foreground SGR sequence Maximum output: 19 bytes (\033[38;2;255;255;255m)

Parameters

dst	Destination buffer
r	Red component
g	Green component
b	Blue component

Returns

Pointer to end of written data

Definition at line 143 of file ansi.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 global_dec3_cache_t::dec3_initialized, global_dec3_cache_t::dec3_table, g_dec3_cache, init_dec3(), dec3_t::len, dec3_t::s, and SAFE_MEMCPY.

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
	)

#include <ansi.h>

Append combined foreground + background truecolor SGR Maximum output: 38 bytes (\033[38;2;255;255;255;48;2;255;255;255m)

Parameters

dst	Destination buffer
fg_r	Foreground red component
fg_g	Foreground green component
fg_b	Foreground blue component
bg_r	Background red component
bg_g	Background green component
bg_b	Background blue component

Returns

Pointer to end of written data

Definition at line 199 of file ansi.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 global_dec3_cache_t::dec3_initialized, global_dec3_cache_t::dec3_table, g_dec3_cache, init_dec3(), dec3_t::len, dec3_t::s, and SAFE_MEMCPY.

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
	)

#include <ansi.h>

Get RGB values for a 16-color ANSI index

Parameters

color_index	16-color index (0-15)
r	Output red component
g	Output green component
b	Output blue component

Definition at line 480 of file ansi.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
	)

#include <ansi.h>

Convert RGB to closest 16-color ANSI index Uses distance-based matching against standard ANSI colors

Parameters

r	Red component
g	Green component
b	Blue component

Returns

16-color index (0-15)

Definition at line 437 of file ansi.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(), rgb_to_16color_dithered(), and rgb_to_16color_halfblocks_scalar().

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
	)

#include <ansi.h>

Convert RGB to 16-color with Floyd-Steinberg dithering

Parameters

r	Red component
g	Green component
b	Blue component
x	Current pixel X coordinate
y	Current pixel Y coordinate
width	Image width
height	Image height
error_buffer	Dithering error buffer (width*height elements)

Returns

16-color index with dithering applied

Definition at line 511 of file ansi.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 rgb_error_t::b, rgb_error_t::g, get_16color_rgb(), rgb_error_t::r, 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
	)

#include <ansi.h>

Convert RGB to closest 256-color palette index Uses 6x6x6 color cube + grayscale ramp

Parameters

r	Red component
g	Green component
b	Blue component

Returns

256-color palette index (0-255)

Definition at line 360 of file ansi.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(), colorscheme_compile_scheme(), image_print_256color(), and rgb_to_256color_halfblocks_scalar().