ascii_simd.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include "../image.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 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";
static const char ANSI_RESET[] = "\033[0m";
 
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_free(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_simd(image_t *image, const char *ascii_chars);
 
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_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);
 
// Include architecture-specific implementations
#if SIMD_SUPPORT_SSE2
#include "video/simd/sse2.h"
#endif
#if SIMD_SUPPORT_SSSE3
#include "video/simd/ssse3.h"
#endif
#if SIMD_SUPPORT_AVX2
#include "video/simd/avx2.h"
#endif
#if SIMD_SUPPORT_SVE
#include "video/simd/sve.h"
#endif
#if SIMD_SUPPORT_NEON
#include "video/simd/neon.h"
#endif