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)
	When code needs to work with rgb error, it keeps r, g, b here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields.
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)
void	get_256color_rgb (uint8_t index, 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 <include/ascii-chat/video/terminal/ansi.h>

Enumerator
ANSI_MODE_FOREGROUND
ANSI_MODE_BACKGROUND
ANSI_MODE_FOREGROUND_BACKGROUND

Definition at line 39 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 <include/ascii-chat/video/terminal/ansi.h>

Initialize fast ANSI generation (call once at startup)

Definition at line 227 of file ansi.c.

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

References ascii_simd_init().

Referenced by client_init(), mirror_init(), and session_display_create().

ansi_fast_init_16color()

void ansi_fast_init_16color

(

void

)

#include <include/ascii-chat/video/terminal/ansi.h>

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

Definition at line 315 of file ansi.c.

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

Referenced by append_16color_bg(), append_16color_fg(), and session_display_create().

ansi_fast_init_256color()

void ansi_fast_init_256color

(

void

)

#include <include/ascii-chat/video/terminal/ansi.h>

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

Definition at line 232 of file ansi.c.

                                   {
  prewarm_sgr256_cache();
}

References prewarm_sgr256_cache().

Referenced by session_display_create().

ansi_is_already_colorized()

bool ansi_is_already_colorized	(	const char *	message,
		size_t	pos )

#include <include/ascii-chat/video/terminal/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 102 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_with_color().

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 <include/ascii-chat/video/terminal/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 169 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.

ansi_rle_finish()

void ansi_rle_finish

(

ansi_rle_context_t *

ctx

)

#include <include/ascii-chat/video/terminal/ansi.h>

Finish RLE sequence with reset and null terminator

Parameters

ctx	RLE context

Definition at line 211 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.

ansi_rle_init()

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

#include <include/ascii-chat/video/terminal/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 156 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.

ansi_skip_escape()

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

#include <include/ascii-chat/video/terminal/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 78 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;
}

ansi_strip_escapes()

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

#include <include/ascii-chat/video/terminal/ansi.h>

When code needs to work with rgb error, it keeps r, g, b here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields.

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 27 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 <include/ascii-chat/video/terminal/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 338 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().

append_16color_fg()

char * append_16color_fg	(	char *	dst,
		uint8_t	color_index )

#include <include/ascii-chat/video/terminal/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 322 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().

append_256color_bg()

char * append_256color_bg	(	char *	dst,
		uint8_t	color_index )

#include <include/ascii-chat/video/terminal/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 243 of file ansi.c.

                                                   {
  uint8_t length;
  const char *sequence = get_sgr256_bg_string(index, &length);
  memcpy(dst, sequence, length);
  return dst + length;
}

References get_sgr256_bg_string(), and index.

append_256color_fg()

char * append_256color_fg	(	char *	dst,
		uint8_t	color_index )

#include <include/ascii-chat/video/terminal/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 236 of file ansi.c.

                                                   {
  uint8_t length;
  const char *sequence = get_sgr256_fg_string(index, &length);
  memcpy(dst, sequence, length);
  return dst + length;
}

References get_sgr256_fg_string(), and index.

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 )

#include <include/ascii-chat/video/terminal/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 505 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 <include/ascii-chat/video/terminal/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 145 of file ansi.c.

                                                                      {
  return append_sgr_truecolor_bg(dst, r, g, b);
}

References append_sgr_truecolor_bg().

Referenced by ansi_rle_add_pixel(), and grep_highlight_colored().

append_truecolor_fg()

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

#include <include/ascii-chat/video/terminal/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 141 of file ansi.c.

                                                                      {
  return append_sgr_truecolor_fg(dst, r, g, b);
}

References append_sgr_truecolor_fg().

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 <include/ascii-chat/video/terminal/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 149 of file ansi.c.

                                                                                                                {
  return append_sgr_truecolor_fg_bg(dst, fr, fg, fb, br, bg, bb);
}

References append_sgr_truecolor_fg_bg().

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 <include/ascii-chat/video/terminal/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 397 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 ascii_frame_emit_row(), get_256color_rgb(), and rgb_to_16color_dithered().

get_256color_rgb()

void get_256color_rgb	(	uint8_t	index,
		uint8_t *	r,
		uint8_t *	g,
		uint8_t *	b )

#include <include/ascii-chat/video/terminal/ansi.h>

Expand an xterm 256-color palette entry to RGB.

Definition at line 278 of file ansi.c.

                                                                         {
  if (!r || !g || !b) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Missing palette RGB output");
    return;
  }
  if (index < 16) {
    get_16color_rgb(index, r, g, b);
    return;
  }
  if (index >= 232) {
    *r = *g = *b = (uint8_t)(8 + (index - 232) * 10);
    return;
  }
  static const uint8_t levels[] = {0, 95, 135, 175, 215, 255};
  int cube = index - 16;
  *r = levels[cube / 36];
  *g = levels[(cube / 6) % 6];
  *b = levels[cube % 6];
}

References ERROR_INVALID_PARAM, get_16color_rgb(), index, and SET_ERRNO.

rgb_to_16color()

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

#include <include/ascii-chat/video/terminal/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 354 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(), colorscheme_current_palette(), rgb_to_16color_dithered(), and simd_quantize_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 <include/ascii-chat/video/terminal/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 428 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(), height, rgb_error_t::r, rgb_to_16color(), and width.

Referenced by ascii_render().

rgb_to_256color()

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

#include <include/ascii-chat/video/terminal/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 251 of file ansi.c.

                                                         {
  // Xterm cube levels are nonuniform. Compare the nearest cube entry with
  // the nearest gray, including cube black/white rather than clipping them.
  static const int levels[] = {0, 95, 135, 175, 215, 255};
  int values[] = {r, g, b}, cube[3], error = 0;
  for (int c = 0; c < 3; c++) {
    cube[c] = 0;
    for (int i = 1; i < 6; i++)
      if (abs(values[c] - levels[i]) < abs(values[c] - levels[cube[c]]))
        cube[c] = i;
    int delta = values[c] - levels[cube[c]];
    error += delta * delta;
  }
  int gray = ((int)r + g + b - 9) / 30;
  if (gray < 0)
    gray = 0;
  if (gray > 23)
    gray = 23;
  int level = 8 + 10 * gray;
  int dr = r - level, dg = g - level, db = b - level;
  if (dr * dr + dg * dg + db * db < error)
    return (uint8_t)(232 + gray);
  return (uint8_t)(16 + cube[0] * 36 + cube[1] * 6 + cube[2]);
}

Referenced by append_color_fg_for_mode(), colorscheme_compile_scheme(), colorscheme_current_palette(), and simd_quantize_scalar().