ansi.c

Go to the documentation of this file.

 
#include <ascii-chat/common.h>
#include <ascii-chat/util/lifecycle.h>
#include <ascii-chat/video/ascii/common.h>
#include <ascii-chat/video/terminal/ansi.h>
#include <ascii-chat/util/math.h>
#include <ascii-chat/platform/init.h>
#include <ascii-chat/options/options.h>
#include <string.h>
#include <time.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include <limits.h>
 
/* ===== BASIC ANSI UTILITIES ===== */
 
char *ansi_strip_escapes(const char *input, size_t input_len) {
  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;
}
 
const char *ansi_skip_escape(const char *ptr, const char *end) {
  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;
}
 
bool ansi_is_already_colorized(const char *message, size_t pos) {
  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;
}
 
/* ===== 256-COLOR LOOKUP TABLES ===== */
 
static char color256_strings[256][16];    // Pre-built SGR strings like "\033[38;5;123m"
static char color256_bg_strings[256][16]; // Pre-built SGR strings like "\033[48;5;123m"
static lifecycle_t g_color256_lc = LIFECYCLE_INIT;
 
/* ===== 16-COLOR LOOKUP TABLES ===== */
 
static char color16_fg_strings[16][16];
static char color16_bg_strings[16][16];
static lifecycle_t g_color16_lc = LIFECYCLE_INIT;
 
/* ===== TRUECOLOR FUNCTIONS ===== */
 
// Fast foreground color: \033[38;2;R;G;Bm
// Maximum output: 19 bytes (\033[38;2;255;255;255m)
char *append_truecolor_fg(char *dst, uint8_t r, uint8_t g, uint8_t b) {
  // 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;
}
 
// Fast background color: \033[48;2;R;G;Bm
// Maximum output: 19 bytes (\033[48;2;255;255;255m)
char *append_truecolor_bg(char *dst, uint8_t r, uint8_t g, uint8_t b) {
  // 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;
}
 
// Combined foreground + background: \033[38;2;R;G;B;48;2;r;g;bm
// Maximum output: 38 bytes (\033[38;2;255;255;255;48;2;255;255;255m)
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) {
  // 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;
}
 
/* ===== RUN-LENGTH ENCODING FUNCTIONS ===== */
 
// Initialize run-length encoding context
void ansi_rle_init(ansi_rle_context_t *ctx, char *buffer, size_t capacity, ansi_color_mode_t mode) {
  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;
}
 
// Add pixel with run-length encoding - only emit SGR when color changes
void ansi_rle_add_pixel(ansi_rle_context_t *ctx, uint8_t r, uint8_t g, uint8_t b, char ascii_char) {
  // 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;
  }
}
 
// Finish RLE sequence with reset and null terminator
void ansi_rle_finish(ansi_rle_context_t *ctx) {
  // 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';
  }
}
 
/* ===== INITIALIZATION FUNCTIONS ===== */
 
// Initialize the decimal lookup table (call once at startup)
void ansi_fast_init(void) {
  // Initialize the dec3 cache used by truecolor functions
  ascii_simd_init();
}
 
// 256-color mode initialization (optional high-speed mode)
// Private initialization function (called exactly once via lifecycle)
static void do_init_256color(void) {
  for (int i = 0; i < 256; i++) {
    SAFE_SNPRINTF(color256_strings[i], sizeof(color256_strings[i]), "\033[38;5;%dm", i);
    SAFE_SNPRINTF(color256_bg_strings[i], sizeof(color256_bg_strings[i]), "\033[48;5;%dm", i);
  }
}
 
// Public initialization wrapper - thread-safe using lifecycle API
void ansi_fast_init_256color(void) {
  if (!lifecycle_init(&g_color256_lc, "ansi_256color")) {
    return; // Already initialized
  }
  do_init_256color();
}
 
/* ===== 256-COLOR FUNCTIONS ===== */
 
// Fast 256-color foreground
char *append_256color_fg(char *dst, uint8_t color_index) {
  const char *color_str = color256_strings[color_index];
  size_t len = strlen(color_str);
  SAFE_MEMCPY(dst, len, color_str, len);
  return dst + len;
}
 
// Fast 256-color background
char *append_256color_bg(char *dst, uint8_t color_index) {
  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;
}
 
// Convert RGB to closest 256-color palette index
uint8_t rgb_to_256color(uint8_t r, uint8_t g, uint8_t b) {
  // 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);
}
 
/* ===== 16-COLOR FUNCTIONS ===== */
 
// Private initialization function (called exactly once via lifecycle)
static void do_init_16color(void) {
  // 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]);
  }
}
 
// Public initialization wrapper - thread-safe using lifecycle API
void ansi_fast_init_16color(void) {
  if (!lifecycle_init(&g_color16_lc, "ansi_16color")) {
    return; // Already initialized
  }
  do_init_16color();
}
 
char *append_16color_fg(char *dst, uint8_t color_index) {
  // 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;
}
 
char *append_16color_bg(char *dst, uint8_t color_index) {
  // 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;
}
 
uint8_t rgb_to_16color(uint8_t r, uint8_t g, uint8_t b) {
  // 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;
}
 
// Get the actual RGB values for a 16-color ANSI index
void get_16color_rgb(uint8_t color_index, uint8_t *r, uint8_t *g, uint8_t *b) {
  // 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];
}
 
// Floyd-Steinberg dithering for 16-color terminals
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) {
  // 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;
}
 
/* ===== MODE-AWARE COLOR FUNCTIONS ===== */
 
// Terminal capability-aware color function
char *append_color_fg_for_mode(char *dst, uint8_t r, uint8_t g, uint8_t b, terminal_color_mode_t mode) {
  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;
  }
}