video/ascii/common.h

Go to the documentation of this file.

#pragma once

 
/* Existing buffer budgets in bytes, including NUL for text storage. */
#define ASCII_LUMINANCE_LEVELS 256
#define ASCII_PALETTE_BUFFER_SIZE 256
 
#include <stdbool.h>
#include <stddef.h>
#include <libplatform/atomic.h>
#include <ascii-chat/video/rgba/image.h>
#include <ascii-chat/uthash.h>
#include "../../common.h"
 
// Check for SIMD support and include architecture-specific headers
// CMake explicitly controls which SIMD levels to enable via ENABLE_SIMD_* options
// and defines SIMD_SUPPORT_* to 1 (enabled) or 0 (disabled).
//
// Only auto-detect from compiler macros if CMake hasn't already defined them.
// This ensures CMake's explicit choices (e.g., AVX2-only, no SSE2/SSSE3) are respected.
//
// Disable SIMD on Windows with Clang due to intrinsics compatibility issues
#if defined(_WIN32) && defined(__clang__) && __clang_major__ >= 20
// Windows with Clang 20+ has issues with MMX intrinsics
// Keep SIMD disabled until fixed
#else
// Only auto-detect if CMake hasn't already defined the macro
#if defined(__ARM_FEATURE_SVE) && !defined(SIMD_SUPPORT_SVE)
#define SIMD_SUPPORT_SVE 1
#endif
 
#if defined(__AVX2__) && !defined(SIMD_SUPPORT_AVX2)
#define SIMD_SUPPORT_AVX2 1
#endif
 
#if defined(__SSE2__) && !defined(SIMD_SUPPORT_SSE2)
#define SIMD_SUPPORT_SSE2 1
#endif
 
#if defined(__SSSE3__) && !defined(SIMD_SUPPORT_SSSE3)
#define SIMD_SUPPORT_SSSE3 1
#endif
 
#if defined(__ARM_NEON) && !defined(SIMD_SUPPORT_NEON)
#define SIMD_SUPPORT_NEON 1
#endif
#endif
 
// Availability means a backend was compiled, not that the running CPU supports it.
#if SIMD_SUPPORT_SVE || SIMD_SUPPORT_AVX2 || SIMD_SUPPORT_SSSE3 || SIMD_SUPPORT_SSE2 || SIMD_SUPPORT_NEON
#define SIMD_SUPPORT 1
#endif


#define LUMA_RED 77
#define LUMA_GREEN 150
#define LUMA_BLUE 29
#define LUMA_THRESHOLD 128


typedef struct {
  uint8_t len; 
  char s[3];   
} dec3_t;

typedef struct {
  dec3_t dec3_table[256]; 
  bool dec3_initialized;  
} global_dec3_cache_t;

extern global_dec3_cache_t g_dec3_cache;
 
// Pre-computed ANSI escape code templates
// static const char ANSI_FG_PREFIX[] = "\033[38;2;";  // Unused, replaced by inline constants
// static const char ANSI_BG_PREFIX[] = "\033[48;2;";  // Unused, replaced by inline constants
// static const char ANSI_SUFFIX[] = "m";

void init_dec3(void);

void ascii_simd_init(void);

extern char g_default_luminance_palette[ASCII_LUMINANCE_LEVELS];

void init_default_luminance_palette(void);

typedef struct {
  char *data; 
  size_t len; 
  size_t cap; 
} Str;

void str_init(Str *s);

void str_destroy(Str *s);

void str_reserve(Str *s, size_t need);

void str_append_bytes(Str *s, const void *src, size_t n);

void str_append_c(Str *s, char c);

void str_printf(Str *s, const char *fmt, ...);

typedef struct {
  int cFR, cFG, cFB; 
  int cBR, cBG, cBB; 
  int runLen;        
  int seeded;        
} RLEState;

typedef struct {
  int w;           
  int h;           
  uint8_t *pixels; 
} ImageRGB;

ImageRGB alloc_image(int w, int h);

void convert_pixels_scalar(const rgb_pixel_t *pixels, char *ascii_chars, int count,
                           const char luminance_palette[ASCII_LUMINANCE_LEVELS]);

char *convert_pixels_scalar_with_newlines(image_t *image, const char luminance_palette[ASCII_LUMINANCE_LEVELS]);
 
// Row-based functions removed - use image_print_color() instead

typedef struct {
  double scalar_time;      
  double sse2_time;        
  double ssse3_time;       
  double avx2_time;        
  double neon_time;        
  double sve_time;         
  double speedup_best;     
  const char *best_method; 
} simd_benchmark_t;

simd_benchmark_t benchmark_simd_conversion(int width, int height, int iterations);

simd_benchmark_t benchmark_simd_color_conversion(int width, int height, int iterations, bool background_mode);

simd_benchmark_t benchmark_simd_conversion_with_source(int width, int height, int iterations, bool background_mode,
                                                       const image_t *source_image, bool use_256color);

simd_benchmark_t benchmark_simd_color_conversion_with_source(int width, int height, int iterations,
                                                             bool background_mode, const image_t *source_image,
                                                             bool use_256color);

void print_simd_capabilities(void);

char *image_print_color_simd(image_t *image, bool use_background_mode, bool use_256color, const char *ascii_chars);

void set_color_quality_mode(bool high_quality);

bool get_256_color_fast_path(void);

void prewarm_sgr256_fg_cache(void);

void prewarm_sgr256_cache(void);

char *get_sgr256_fg_string(uint8_t fg, uint8_t *len_out);

char *get_sgr256_bg_string(uint8_t bg, uint8_t *len_out);

char *get_sgr256_fg_bg_string(uint8_t fg, uint8_t bg, uint8_t *len_out);

size_t write_row_rep_from_arrays_enhanced(const uint8_t *fg_r, const uint8_t *fg_g, const uint8_t *fg_b,
                                          const uint8_t *bg_r, const uint8_t *bg_g, const uint8_t *bg_b,
                                          const uint8_t *fg_idx, const uint8_t *bg_idx, const char *ascii_chars,
                                          int width, char *dst, size_t cap, bool is_truecolor);

#define RAMP64_SIZE 64
#define CACHE_FREQUENCY_DECAY_TIME 10000 // 10 seconds in milliseconds
#define CACHE_RECENCY_SCALE 100
#define CACHE_MAX_LIFETIME 3600 // 1 hour maximum cache lifetime in seconds
 
typedef struct {
  uint8_t width;                      
  uint8_t utf8_bytes[UTF8_MAX_BYTES]; 
  uint8_t byte_len;                   
  uint8_t _pad;                       
} utf8_char_t;
 
typedef struct utf8_palette_cache {
  utf8_char_t cache[256];                          
  utf8_char_t cache64[64];                         
  uint8_t char_index_ramp[ASCII_LUMINANCE_LEVELS]; 
  atomic_t last_access_time;                       
  atomic_t access_count;                           
  uint32_t total_age_seconds;                      
  uint64_t creation_time;                          
  double cached_score;                             
  size_t heap_index;                               
  uint32_t key;                                    
  char palette_hash[ASCII_PALETTE_BUFFER_SIZE];    
  bool initialized;                                
  bool is_valid;                                   
 
  // uthash handle for hash table
  UT_hash_handle hh; 
} utf8_palette_cache_t;

void build_utf8_luminance_cache(const char *ascii_chars, utf8_char_t cache[256]);

void build_utf8_ramp64_cache(const char *ascii_chars, utf8_char_t cache64[64],
                             uint8_t char_index_ramp[ASCII_LUMINANCE_LEVELS]);

utf8_palette_cache_t *get_utf8_palette_cache(const char *ascii_chars);

void simd_caches_destroy_all(void);
 
// Include architecture-specific implementations
#if SIMD_SUPPORT_SSE2
#include <ascii-chat/video/ascii/sse2.h>
#endif
#if SIMD_SUPPORT_SSSE3
#include <ascii-chat/video/ascii/ssse3.h>
#endif
#if SIMD_SUPPORT_AVX2
#include <ascii-chat/video/ascii/avx2.h>
#endif
#if SIMD_SUPPORT_SVE
#include <ascii-chat/video/ascii/sve.h>
#endif
#if SIMD_SUPPORT_NEON
#include <ascii-chat/video/ascii/neon.h>
#endif