ascii_simd.c File Reference

⚡ Main SIMD ASCII rendering dispatcher with architecture detection and fallback handling More...

Go to the source code of this file.

Functions
size_t	write_rgb_triplet (uint8_t value, char *dst)
void	init_default_luminance_palette (void)
void	init_dec3 (void)
void	ascii_simd_init (void)
ImageRGB	alloc_image (int w, int h)
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,...)
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])
char *	image_print_simd (image_t *image, const char *ascii_chars)
void	print_simd_capabilities (void)
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)

Variables
global_dec3_cache_t	g_dec3_cache = {.dec3_initialized = false}
char	g_default_luminance_palette [256]

Detailed Description

⚡ Main SIMD ASCII rendering dispatcher with architecture detection and fallback handling

Definition in file ascii_simd.c.

Function Documentation

alloc_image()

ImageRGB alloc_image	(	int	w,
		int	h
	)

Definition at line 106 of file ascii_simd.c.

                                   {
  ImageRGB out;
  out.w = w;
  out.h = h;
  size_t n = (size_t)w * (size_t)h * 3u;
  out.pixels = SAFE_MALLOC(n, uint8_t *);
  return out;
}

ascii_simd_init()

void ascii_simd_init

(

void

)

Definition at line 98 of file ascii_simd.c.

                           {
  // Initialize SIMD lookup tables manually (constructor disabled for musl compatibility)
  // Both init functions have guards to prevent double-initialization
  init_dec3();
  init_default_luminance_palette();
}

References init_dec3(), and init_default_luminance_palette().

Referenced by ansi_fast_init(), and server_main().

benchmark_simd_color_conversion()

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

Definition at line 501 of file ascii_simd.c.

                                                                                                              {
  simd_benchmark_t result = {0};
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  // Estimate output buffer size for colored ASCII (much larger than monochrome)
  // Each pixel can generate ~25 bytes of ANSI escape codes + 1 char
  size_t output_buffer_size = pixel_count * 30 + (size_t)width * 10; // Extra for newlines/reset codes
 
  // Generate test data and test image for unified functions
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(output_buffer_size, char *);
 
  // Create test image for new unified functions
  image_t *frame = image_new(width, height);
  if (!frame) {
    SAFE_FREE(test_pixels);
    SAFE_FREE(output_buffer);
    return result;
  }
 
  // Use synthetic gradient data for consistent cross-platform benchmarking
  printf("Using coherent gradient data for realistic color testing\n");
  srand(12345); // For consistent gradient variation across runs
  for (size_t i = 0; i < pixel_count; i++) {
    int x = i % width;
    int y = i / width;
    // Create smooth gradients with some variation (mimics real images)
    int base_r = (x * 255) / width;
    int base_g = (y * 255) / height;
    int base_b = ((x + y) * 127) / (width + height);
 
    // Add realistic variation
    int temp_r = base_r + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_g = base_g + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_b = base_b + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
    test_pixels[i].r = clamp_rgb(temp_r);
    test_pixels[i].g = clamp_rgb(temp_g);
    test_pixels[i].b = clamp_rgb(temp_b);
  }
 
  // Populate test image with same data as test_pixels
  frame->pixels = test_pixels;
 
  const char *mode_str = background_mode ? "background" : "foreground";
  printf("Benchmarking COLOR %s %dx%d (%zu pixels) x %d iterations...\n", mode_str, width, height, pixel_count,
         iterations);
 
  // Benchmark scalar color version
  double start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = image_print_color(frame, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.scalar_time = time_ns_to_s(time_get_ns()) - start;
 
#if SIMD_SUPPORT_SSE2
  // Benchmark SSE2 color using unified function
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *ascii_output = render_ascii_sse2_unified_optimized(frame, background_mode, true, DEFAULT_ASCII_PALETTE);
    if (ascii_output)
      SAFE_FREE(ascii_output);
  }
  result.sse2_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_SSSE3
  // Benchmark SSSE3 color using unified function
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *ascii_output = render_ascii_ssse3_unified_optimized(frame, background_mode, true, DEFAULT_ASCII_PALETTE);
    if (ascii_output)
      SAFE_FREE(ascii_output);
  }
  result.ssse3_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_AVX2
  // Benchmark AVX2 color using unified function
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *ascii_output = render_ascii_avx2_unified_optimized(frame, background_mode, true, DEFAULT_ASCII_PALETTE);
    if (ascii_output)
      SAFE_FREE(ascii_output);
  }
  result.avx2_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_NEON
  // Benchmark NEON color
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    // Create temporary image for unified function
    image_t temp_image = {.pixels = test_pixels, .w = width, .h = height, .alloc_method = IMAGE_ALLOC_SIMD};
    char *ascii_output = render_ascii_neon_unified_optimized(&temp_image, background_mode, true, DEFAULT_ASCII_PALETTE);
    if (ascii_output)
      SAFE_FREE(ascii_output);
  }
  result.neon_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
  // Find best method
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
  // Cleanup - frame owns test_pixels now
  frame->pixels = NULL; // Don't double-free
  image_destroy(frame);
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References DEFAULT_ASCII_PALETTE, image_destroy(), image_new(), image_print_color(), and time_get_ns().

benchmark_simd_color_conversion_with_source()

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
	)

Definition at line 861 of file ascii_simd.c.

                                                                                {
  (void)iterations; // Intentionally unused - uses adaptive iteration counts instead
  simd_benchmark_t result = {0};
  (void)use_256color; // Suppress unused parameter warning
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  size_t output_buffer_size = pixel_count * 30 + (size_t)width * 10;
 
  // Allocate buffers for benchmarking
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(output_buffer_size, char *);
 
  // Calculate adaptive iterations for color benchmarking (ignore passed iterations)
  int adaptive_iterations = calculate_adaptive_iterations(pixel_count, 10.0);
 
  const char *mode_str = background_mode ? "background" : "foreground";
 
  // Variables for webcam capture cleanup
 
  if (source_image) {
    printf("Using provided source image data for COLOR %s %dx%d benchmarking with %d iterations...\n", mode_str, width,
           height, adaptive_iterations);
 
    // Use provided source image - resize if needed
    if (source_image->w == width && source_image->h == height) {
      // Direct copy
      for (size_t i = 0; i < pixel_count; i++) {
        test_pixels[i].r = source_image->pixels[i].r;
        test_pixels[i].g = source_image->pixels[i].g;
        test_pixels[i].b = source_image->pixels[i].b;
      }
    } else {
      // Resize source image to target dimensions
      float x_ratio = (float)source_image->w / width;
      float y_ratio = (float)source_image->h / height;
 
      for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
          int src_x = (int)(x * x_ratio);
          int src_y = (int)(y * y_ratio);
 
          // Bounds check
          if (src_x >= source_image->w)
            src_x = source_image->w - 1;
          if (src_y >= source_image->h)
            src_y = source_image->h - 1;
 
          // Use size_t for index calculations to prevent integer overflow
          size_t src_idx = (size_t)src_y * (size_t)source_image->w + (size_t)src_x;
          size_t dst_idx = (size_t)y * (size_t)width + (size_t)x;
 
          test_pixels[dst_idx].r = source_image->pixels[src_idx].r;
          test_pixels[dst_idx].g = source_image->pixels[src_idx].g;
          test_pixels[dst_idx].b = source_image->pixels[src_idx].b;
        }
      }
    }
  } else {
    // No source image provided: use synthetic gradient data for consistent testing
    printf("Using synthetic gradient data for COLOR %s %dx%d benchmarking with %d iterations...\n", mode_str, width,
           height, adaptive_iterations);
 
    srand(12345); // Consistent results across runs
    for (size_t i = 0; i < pixel_count; i++) {
      int x = i % width;
      int y = i / width;
      int base_r = (x * 255) / width;
      int base_g = (y * 255) / height;
      int base_b = ((x + y) * 127) / (width + height);
 
      int temp_r = base_r + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_g = base_g + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_b = base_b + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
      test_pixels[i].r = clamp_rgb(temp_r);
      test_pixels[i].g = clamp_rgb(temp_g);
      test_pixels[i].b = clamp_rgb(temp_b);
    }
  }
 
  printf("Benchmarking COLOR %s conversion using %d iterations...\n", mode_str, adaptive_iterations);
 
  // FIX #5: Prewarm 256-color caches to avoid first-frame penalty (~1.5-2MB cache build)
  prewarm_sgr256_fg_cache(); // Warmup 256-entry FG cache
  prewarm_sgr256_cache();    // Warmup 65,536-entry FG+BG cache
 
  // Benchmark scalar color conversion (pure conversion, no I/O)
  double start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image == NULL) {
      SAFE_FREE(test_pixels);
      SAFE_FREE(output_buffer);
      FATAL(ERROR_MEMORY, "Failed to allocate test_image in benchmark iteration %d", i);
    }
    memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
    char *result_ascii = ascii_convert(test_image, width, height, false, false, false, DEFAULT_ASCII_PALETTE,
                                       g_default_luminance_palette);
    if (result_ascii)
      SAFE_FREE(result_ascii);
    image_destroy(test_image);
  }
  result.scalar_time = time_ns_to_s(time_get_ns()) - start;
 
  // Find best method -- default to scalar and let simd beat it.
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_sse2_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.sse2_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_SSSE3
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_ssse3_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.ssse3_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_AVX2
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_avx2_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.avx2_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_NEON
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    // Create temporary image for unified function
    image_t temp_image = {.pixels = test_pixels, .w = width, .h = height, .alloc_method = IMAGE_ALLOC_SIMD};
    char *result =
        render_ascii_neon_unified_optimized(&temp_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result)
      SAFE_FREE(result);
  }
  result.neon_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_SVE
  start = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    // Create temporary image for unified function
    image_t temp_image = {.pixels = test_pixels, .w = width, .h = height, .alloc_method = IMAGE_ALLOC_SIMD};
    char *result =
        render_ascii_sve_unified_optimized(&temp_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result)
      SAFE_FREE(result);
  }
  result.sve_time = time_ns_to_s(time_get_ns()) - start;
#endif
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  // Normalize timing results by iteration count to get per-frame times
  result.scalar_time /= adaptive_iterations;
  if (result.sse2_time > 0)
    result.sse2_time /= adaptive_iterations;
  if (result.ssse3_time > 0)
    result.ssse3_time /= adaptive_iterations;
  if (result.avx2_time > 0)
    result.avx2_time /= adaptive_iterations;
  if (result.neon_time > 0)
    result.neon_time /= adaptive_iterations;
  // Recalculate best time after normalization
  best_time = result.scalar_time;
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time)
    best_time = result.sse2_time;
#endif
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time)
    best_time = result.ssse3_time;
#endif
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time)
    best_time = result.avx2_time;
#endif
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time)
    best_time = result.neon_time;
#endif
#if SIMD_SUPPORT_SVE
  if (result.sve_time > 0 && result.sve_time < best_time)
    best_time = result.sve_time;
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
  printf("------------\n");
  printf("scalar: %f\n", result.scalar_time);
  if (result.sse2_time > 0)
    printf("SSE2: %f\n", result.sse2_time);
  if (result.ssse3_time > 0)
    printf("SSSE3: %f\n", result.ssse3_time);
  if (result.avx2_time > 0)
    printf("avx2: %f\n", result.avx2_time);
  if (result.neon_time > 0)
    printf("neon: %f\n", result.neon_time);
  if (result.sve_time > 0)
    printf("sve: %f\n", result.sve_time);
  printf("Best method: %s, time: %f (%.2fx speedup (<1.0 = bad))\n", result.best_method, best_time,
         result.speedup_best);
  printf("------------\n");
 
  // Frame data already cleaned up in webcam capture section
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References ascii_convert(), DEFAULT_ASCII_PALETTE, g_default_luminance_palette, image_destroy(), image_new(), prewarm_sgr256_cache(), prewarm_sgr256_fg_cache(), and time_get_ns().

benchmark_simd_conversion()

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

Definition at line 334 of file ascii_simd.c.

                                                                                  {
  (void)iterations; // Intentionally unused - uses adaptive iteration counts instead
  simd_benchmark_t result = {0};
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  // Generate test data and test image
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(pixel_count, char *);
 
  // Create test image for new image-based functions
  image_t *test_image = image_new(width, height);
  if (!test_image) {
    SAFE_FREE(test_pixels);
    SAFE_FREE(output_buffer);
    return result;
  }
 
  // Use synthetic data for consistent cross-platform testing
  printf("Using synthetic gradient data for consistent benchmarking\n");
  srand(12345); // Consistent results across runs // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
  for (size_t i = 0; i < pixel_count; i++) {
    int x = i % width;
    int y = i / width;
    // Create realistic gradient pattern with some variation
    int base_r = (x * 255) / width;
    int base_g = (y * 255) / height;
    int base_b = ((x + y) * 127) / (width + height);
 
    // Add small random variation to make it realistic
    int temp_r = base_r + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_g = base_g + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_b = base_b + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
    test_pixels[i].r = clamp_rgb(temp_r);
    test_pixels[i].g = clamp_rgb(temp_g);
    test_pixels[i].b = clamp_rgb(temp_b);
  }
 
  // Copy test data to test image pixels
  memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
 
  // Calculate adaptive iterations for reliable timing
  int adaptive_iterations = calculate_adaptive_iterations(pixel_count, 10.0);
  printf("Benchmarking MONO %dx%d (%zu pixels) using %d adaptive iterations (ignoring passed iterations)...\n", width,
         height, pixel_count, adaptive_iterations);
 
  // Benchmark scalar using image-based API
  ensure_default_palette_ready();
  double start_mono = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = image_print(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.scalar_time = (time_ns_to_s(time_get_ns()) - start_mono) / adaptive_iterations;
 
#if SIMD_SUPPORT_SSE2
  // Benchmark SSE2 using new image-based timing function
  // Benchmark SSE2 monochrome rendering
  double start_sse2 = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_sse2(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.sse2_time = (time_ns_to_s(time_get_ns()) - start_sse2) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_SSSE3
  // Benchmark SSSE3 using new image-based timing function
  // Benchmark SSSE3 monochrome rendering
  double start_ssse3 = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_ssse3(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.ssse3_time = (time_ns_to_s(time_get_ns()) - start_ssse3) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_AVX2
  // Benchmark AVX2 using optimized single-pass implementation
  // Benchmark AVX2 monochrome rendering
  double start_avx2 = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_avx2(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.avx2_time = (time_ns_to_s(time_get_ns()) - start_avx2) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_NEON
  // Benchmark NEON using new image-based timing function
  // TODO: Update benchmark to use custom palette testing
  // Benchmark NEON monochrome rendering
  double start_neon = time_ns_to_s(time_get_ns());
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_neon(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.neon_time = (time_ns_to_s(time_get_ns()) - start_neon) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_SVE
  // SVE benchmarking disabled - function removed
  result.sve_time = 0.0;
#endif
 
  // Find best method
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
#if SIMD_SUPPORT_SVE
  if (result.sve_time > 0 && result.sve_time < best_time) {
    best_time = result.sve_time;
    result.best_method = "SVE";
  }
#endif
 
  // Cleanup
  image_destroy(test_image);
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References DEFAULT_ASCII_PALETTE, image_destroy(), image_new(), image_print(), and time_get_ns().

benchmark_simd_conversion_with_source()

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
	)

Definition at line 656 of file ascii_simd.c.

                                                                                                       {
  simd_benchmark_t result = {0};
  (void)background_mode; // Suppress unused parameter warning
  (void)use_256color;    // Suppress unused parameter warning
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  // Generate test data
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  const size_t output_buffer_size = pixel_count * 16;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(output_buffer_size, char *);
 
  if (source_image && source_image->pixels) {
    printf("Using provided image data (%dx%d) for testing\n", source_image->w, source_image->h);
 
    // Resize source image to test dimensions if needed
    if (source_image->w == width && source_image->h == height) {
      // Direct copy
      for (size_t i = 0; i < pixel_count; i++) {
        test_pixels[i].r = source_image->pixels[i].r;
        test_pixels[i].g = source_image->pixels[i].g;
        test_pixels[i].b = source_image->pixels[i].b;
      }
    } else {
      // Simple nearest-neighbor resize
      for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
          int src_x = (x * source_image->w) / width;
          int src_y = (y * source_image->h) / height;
          // Use size_t for index calculations to prevent integer overflow
          size_t src_idx = (size_t)src_y * (size_t)source_image->w + (size_t)src_x;
          size_t dst_idx = (size_t)y * (size_t)width + (size_t)x;
 
          if (src_idx < (size_t)source_image->w * (size_t)source_image->h) {
            test_pixels[dst_idx].r = source_image->pixels[src_idx].r;
            test_pixels[dst_idx].g = source_image->pixels[src_idx].g;
            test_pixels[dst_idx].b = source_image->pixels[src_idx].b;
          }
        }
      }
      printf("Resized image data from %dx%d to %dx%d\n", source_image->w, source_image->h, width, height);
    }
  } else {
    // Fall back to synthetic gradient data
    printf("No source image provided, using synthetic gradient data\n");
    srand(12345); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
    for (size_t i = 0; i < pixel_count; i++) {
      int x = i % width;
      int y = i / width;
      int base_r = (x * 255 / width);
      int base_g = (y * 255 / height);
      int base_b = ((x + y) * 127 / (width + height));
 
      int temp_r = base_r + (rand() % 16 - 8); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_g = base_g + (rand() % 16 - 8); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_b = base_b + (rand() % 16 - 8); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
      test_pixels[i].r = clamp_rgb(temp_r);
      test_pixels[i].g = clamp_rgb(temp_g);
      test_pixels[i].b = clamp_rgb(temp_b);
    }
  }
 
  // Calculate adaptive iterations for reliable timing
  int adaptive_iterations = calculate_adaptive_iterations(pixel_count, 10.0);
  printf("Benchmarking %dx%d (%zu pixels) using %d adaptive iterations (ignoring passed iterations)...\n", width,
         height, pixel_count, adaptive_iterations);
 
  // Benchmark all available SIMD variants using unified image-based API
  image_t *frame = image_new(width, height);
  memcpy(frame->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
 
  // Benchmark scalar using color conversion
  ensure_default_palette_ready();
  double start_scalar = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = image_print_color(frame, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.scalar_time = (time_ns_to_s(time_get_ns()) - start_scalar) / iterations;
 
#if SIMD_SUPPORT_SSE2
  // Benchmark SSE2 using unified optimized renderer
  // Benchmark SSE2 color rendering
  ensure_default_palette_ready();
  double start_sse2_color = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = render_ascii_sse2_unified_optimized(frame, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.sse2_time = (time_ns_to_s(time_get_ns()) - start_sse2_color) / iterations;
#endif
 
#if SIMD_SUPPORT_SSSE3
  // Benchmark SSSE3 using unified optimized renderer
  // Benchmark SSSE3 color rendering
  ensure_default_palette_ready();
  double start_ssse3_color = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str =
        render_ascii_ssse3_unified_optimized(frame, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.ssse3_time = (time_ns_to_s(time_get_ns()) - start_ssse3_color) / iterations;
#endif
 
#if SIMD_SUPPORT_AVX2
  // Benchmark AVX2 using unified optimized renderer
  // Benchmark AVX2 color rendering
  ensure_default_palette_ready();
  double start_avx2_color = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = render_ascii_avx2_unified_optimized(frame, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.avx2_time = (time_ns_to_s(time_get_ns()) - start_avx2_color) / iterations;
#endif
 
#if SIMD_SUPPORT_NEON
  // Benchmark NEON using unified optimized renderer
  // Benchmark NEON color rendering
  ensure_default_palette_ready();
  double start_neon_color = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = render_ascii_neon_unified_optimized(frame, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.neon_time = (time_ns_to_s(time_get_ns()) - start_neon_color) / iterations;
#endif
 
#if SIMD_SUPPORT_SVE
  // Benchmark SVE using unified optimized renderer
  // Benchmark SVE color rendering
  ensure_default_palette_ready();
  double start_sve_color = time_ns_to_s(time_get_ns());
  for (int i = 0; i < iterations; i++) {
    char *result_str = render_ascii_sve_unified_optimized(frame, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.sve_time = (time_ns_to_s(time_get_ns()) - start_sve_color) / iterations;
#endif
 
  // Find best method
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
#if SIMD_SUPPORT_SVE
  if (result.sve_time > 0 && result.sve_time < best_time) {
    best_time = result.sve_time;
    result.best_method = "SVE";
  }
#endif
 
  image_destroy(frame);
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References DEFAULT_ASCII_PALETTE, image_destroy(), image_new(), image_print_color(), and time_get_ns().

convert_pixels_scalar()

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

Definition at line 175 of file ascii_simd.c.

                                                                                                                       {
  for (int i = 0; i < count; i++) {
    const rgb_pixel_t *p = &pixels[i];
 
    // Calculate luminance using integer arithmetic
    int luminance = (LUMA_RED * p->r + LUMA_GREEN * p->g + LUMA_BLUE * p->b) >> 8;
 
    // Clamp to [0, 255]
    if (luminance > 255)
      luminance = 255;
 
    ascii_chars[i] = luminance_palette[luminance];
  }
}

convert_pixels_scalar_with_newlines()

char * convert_pixels_scalar_with_newlines	(	image_t *	image,
		const char	luminance_palette[256]
	)

Definition at line 190 of file ascii_simd.c.

                                                                                             {
  const int h = image->h;
  const int w = image->w;
 
  // Get UTF-8 character cache for RLE emission
  // Note: We need to reverse-engineer the palette chars from luminance_palette
  // For now, use a simpler approach with direct luminance lookup
 
  // Use outbuf_t for efficient UTF-8 RLE emission (same as SIMD renderers)
  outbuf_t ob = {0};
  const size_t max_char_bytes = 4; // Max UTF-8 character size
  ob.cap = (size_t)h * ((size_t)w * max_char_bytes + 1);
  ob.buf = SAFE_MALLOC(ob.cap ? ob.cap : 1, char *);
  if (!ob.buf) {
    log_error("Failed to allocate output buffer for scalar rendering");
    return NULL;
  }
 
  // Process pixels with RLE optimization
  for (int y = 0; y < h; y++) {
    const rgb_pixel_t *row_pixels = (const rgb_pixel_t *)&image->pixels[y * w];
 
    for (int x = 0; x < w;) {
      const rgb_pixel_t *p = &row_pixels[x];
 
      // Calculate luminance using integer arithmetic
      int luminance = (LUMA_RED * p->r + LUMA_GREEN * p->g + LUMA_BLUE * p->b) >> 8;
      if (luminance > 255)
        luminance = 255;
 
      char current_char = luminance_palette[luminance];
 
      // Find run length for same character (RLE optimization)
      int j = x + 1;
      while (j < w) {
        const rgb_pixel_t *next_p = &row_pixels[j];
        int next_luminance = (LUMA_RED * next_p->r + LUMA_GREEN * next_p->g + LUMA_BLUE * next_p->b) >> 8;
        if (next_luminance > 255)
          next_luminance = 255;
        char next_char = luminance_palette[next_luminance];
        if (next_char != current_char)
          break;
        j++;
      }
      uint32_t run = (uint32_t)(j - x);
 
      // Emit character with RLE (same as SIMD)
      ob_putc(&ob, current_char);
      if (rep_is_profitable(run)) {
        emit_rep(&ob, run - 1);
      } else {
        for (uint32_t k = 1; k < run; k++) {
          ob_putc(&ob, current_char);
        }
      }
      x = j;
    }
 
    // Add newline (except for last row)
    if (y != h - 1) {
      ob_putc(&ob, '\n');
    }
  }
 
  ob_term(&ob);
  return ob.buf;
}

References emit_rep(), ob_putc(), ob_term(), and rep_is_profitable().

image_print_simd()

char * image_print_simd	(	image_t *	image,
		const char *	ascii_chars
	)

Definition at line 260 of file ascii_simd.c.

                                                                {
#if SIMD_SUPPORT_AVX2
  return render_ascii_image_monochrome_avx2(image, ascii_chars);
#elif SIMD_SUPPORT_SSSE3
  return render_ascii_image_monochrome_ssse3(image, ascii_chars);
#elif SIMD_SUPPORT_SSE2
  return render_ascii_image_monochrome_sse2(image, ascii_chars);
#elif SIMD_SUPPORT_NEON
  return render_ascii_image_monochrome_neon(image, ascii_chars);
#else
  // Fallback to scalar implementation - use image_print which properly handles
  // the palette string (convert_pixels_scalar_with_newlines expects a 256-element
  // luminance lookup table, not the raw palette string)
  return image_print(image, ascii_chars);
#endif
}

References image_print().

Referenced by ascii_convert(), and image_print_with_capabilities().

init_dec3()

void init_dec3

(

void

)

Definition at line 66 of file ascii_simd.c.

                     {
  if (g_dec3_cache.dec3_initialized)
    return;
  for (int v = 0; v < 256; ++v) {
    int d2 = v / 100;     // 0..2
    int r = v - d2 * 100; // 0..99
    int d1 = r / 10;      // 0..9
    int d0 = r - d1 * 10; // 0..9
 
    if (d2) {
      g_dec3_cache.dec3_table[v].len = 3;
      g_dec3_cache.dec3_table[v].s[0] = '0' + d2;
      g_dec3_cache.dec3_table[v].s[1] = '0' + d1;
      g_dec3_cache.dec3_table[v].s[2] = '0' + d0;
    } else if (d1) {
      g_dec3_cache.dec3_table[v].len = 2;
      g_dec3_cache.dec3_table[v].s[0] = '0' + d1;
      g_dec3_cache.dec3_table[v].s[1] = '0' + d0;
    } else {
      g_dec3_cache.dec3_table[v].len = 1;
      g_dec3_cache.dec3_table[v].s[0] = '0' + d0;
    }
  }
  g_dec3_cache.dec3_initialized = true;
}

References g_dec3_cache.

Referenced by append_truecolor_bg(), append_truecolor_fg(), append_truecolor_fg_bg(), and ascii_simd_init().

init_default_luminance_palette()

void init_default_luminance_palette

(

void

)

Definition at line 40 of file ascii_simd.c.

                                          {
  static_mutex_lock(&g_default_palette_mutex);
 
  if (g_default_palette_initialized) {
    static_mutex_unlock(&g_default_palette_mutex);
    return;
  }
 
  // Build default luminance mapping using standard palette
  const size_t len = DEFAULT_ASCII_PALETTE_LEN;
  for (int i = 0; i < 256; i++) {
    size_t palette_index = (i * (len - 1) + 127) / 255;
    if (palette_index >= len) {
      palette_index = len - 1;
    }
    g_default_luminance_palette[i] = DEFAULT_ASCII_PALETTE[palette_index];
  }
  g_default_palette_initialized = true;
  static_mutex_unlock(&g_default_palette_mutex);
}

References DEFAULT_ASCII_PALETTE, DEFAULT_ASCII_PALETTE_LEN, and g_default_luminance_palette.

Referenced by ascii_simd_init().

print_simd_capabilities()

void print_simd_capabilities

(

void

)

Definition at line 284 of file ascii_simd.c.

                                   {
  printf("SIMD Support:\n");
#if SIMD_SUPPORT_AVX2
  printf("  ✓ AVX2 (32 pixels/cycle)\n");
#endif
#if SIMD_SUPPORT_NEON
  printf("  ✓ ARM NEON (16 pixels/cycle)\n");
#endif
#if SIMD_SUPPORT_SVE
  printf("  ✓ ARM SVE (scalable pixels/cycle)\n");
#endif
#if SIMD_SUPPORT_SSSE3
  printf("  ✓ SSSE3 (16 pixels/cycle)\n");
#endif
#if SIMD_SUPPORT_SSE2
  printf("  ✓ SSE2 (16 pixels/cycle)\n");
#endif
  printf("  ✓ Scalar fallback (1 pixel/cycle)\n");
}

str_append_bytes()

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

Definition at line 138 of file ascii_simd.c.

                                                         {
  str_reserve(s, s->len + n);
  memcpy(s->data + s->len, src, n);
  s->len += n;
}

References str_reserve().

Referenced by str_printf().

str_append_c()

void str_append_c	(	Str *	s,
		char	c
	)

Definition at line 144 of file ascii_simd.c.

                                  {
  str_reserve(s, s->len + 1);
  s->data[s->len++] = c;
}

References str_reserve().

str_destroy()

void str_destroy

(

Str *

s

)

Definition at line 122 of file ascii_simd.c.

                         {
  SAFE_FREE(s->data);
  s->data = NULL;
  s->len = s->cap = 0;
}

str_init()

void str_init

(

Str *

s

)

Definition at line 116 of file ascii_simd.c.

                      {
  s->data = NULL;
  s->len = 0;
  s->cap = 0;
}

str_printf()

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

Definition at line 149 of file ascii_simd.c.

                                              {
  va_list ap;
  va_start(ap, fmt);
  char stackbuf[256];
  int n = safe_vsnprintf(stackbuf, sizeof(stackbuf), fmt, ap);
  va_end(ap);
  if (n < 0)
    return;
  if ((size_t)n < sizeof(stackbuf)) {
    str_append_bytes(s, stackbuf, (size_t)n);
    return;
  }
  char *heap;
  heap = SAFE_MALLOC((size_t)n + 1, char *);
  va_start(ap, fmt);
  safe_vsnprintf(heap, (size_t)n + 1, fmt, ap);
  va_end(ap);
  str_append_bytes(s, heap, (size_t)n);
  SAFE_FREE(heap);
}

References safe_vsnprintf(), and str_append_bytes().

str_reserve()

void str_reserve	(	Str *	s,
		size_t	need
	)

Definition at line 128 of file ascii_simd.c.

                                      {
  if (need <= s->cap)
    return;
  size_t ncap = s->cap ? s->cap : 4096;
  while (ncap < need)
    ncap = (ncap * 3) / 2 + 64;
  s->data = SAFE_REALLOC(s->data, ncap, char *);
  s->cap = ncap;
}

Referenced by str_append_bytes(), and str_append_c().

write_rgb_triplet()

size_t write_rgb_triplet	(	uint8_t	value,
		char *	dst
	)

Definition at line 28 of file ascii_simd.c.

                                                   {
  const dec3_t *d = &g_dec3_cache.dec3_table[value];
  memcpy(dst, d->s, d->len);
  return d->len;
}

References g_dec3_cache.

Variable Documentation

g_dec3_cache

global_dec3_cache_t g_dec3_cache = {.dec3_initialized = false}

Definition at line 25 of file ascii_simd.c.

{.dec3_initialized = false};

Referenced by append_sgr_truecolor_bg(), append_sgr_truecolor_fg(), append_sgr_truecolor_fg_bg(), append_truecolor_bg(), append_truecolor_fg(), append_truecolor_fg_bg(), init_dec3(), and write_rgb_triplet().

g_default_luminance_palette

char g_default_luminance_palette[256]

Definition at line 35 of file ascii_simd.c.

Referenced by benchmark_simd_color_conversion_with_source(), and init_default_luminance_palette().