video/ascii/common.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <ascii-chat/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
 
// Define umbrella SIMD_SUPPORT macro if any specific SIMD is supported
#if defined(SIMD_SUPPORT_SVE) || defined(SIMD_SUPPORT_AVX2) || defined(SIMD_SUPPORT_SSSE3) ||                          \
    defined(SIMD_SUPPORT_SSE2) || defined(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[256];
 
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[256]);
 
char *convert_pixels_scalar_with_newlines(image_t *image, const char luminance_palette[256]);
 
// 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[4]; 
  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[256]; 
  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[256];       
  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[256]);
 
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