ascii_wasm.c File Reference

Go to the source code of this file.

Functions
char *	ascii_convert (image_t *original, const ssize_t width, const ssize_t height, const bool color, const bool _aspect_ratio, const bool stretch, const char *palette_chars, const char luminance_palette[256])
int	build_client_luminance_palette (const char *palette_chars, size_t palette_len, char luminance_mapping[256])
EMSCRIPTEN_KEEPALIVE char *	convert_frame_to_ascii (uint8_t *rgba_data, int width, int height, int ascii_width, int ascii_height)
EMSCRIPTEN_KEEPALIVE void	free_ascii_buffer (char *buffer)

Function Documentation

ascii_convert()

char * ascii_convert ( image_t *  original, const ssize_t  width, const ssize_t  height, const bool  color, const bool  _aspect_ratio, const bool  stretch, const char *  palette_chars, const char  luminance_palette[256]  )

extern

Definition at line 69 of file ascii.c.

                                                       {
  if (original == NULL || !palette_chars || !luminance_palette) {
    log_error("ascii_convert: invalid parameters");
    return NULL;
  }
 
  // Check for empty strings
  if (palette_chars[0] == '\0' || luminance_palette[0] == '\0') {
    log_error("ascii_convert: empty palette strings");
    return NULL;
  }
 
  // Start with the target dimensions requested by the user (or detected from
  // the terminal). These can be modified by aspect_ratio() if stretching is
  // disabled and one of the dimensions was left to be calculated
  // automatically.
  ssize_t resized_width = width;
  ssize_t resized_height = height;
 
  // If stretch is enabled, use full dimensions, otherwise calculate aspect ratio
  if (_aspect_ratio) {
    // The server now provides images at width*2 x height pixels
    // The aspect_ratio function will handle terminal character aspect ratio
    aspect_ratio(original->w, original->h, resized_width, resized_height, stretch, &resized_width, &resized_height);
  }
 
  // Calculate padding for centering
  size_t pad_width = 0;
  size_t pad_height = 0;
 
  if (_aspect_ratio) {
    // Only calculate padding when not stretching
    ssize_t pad_width_ss = width > resized_width ? (width - resized_width) / 2 : 0;
    pad_width = (size_t)pad_width_ss;
 
    ssize_t pad_height_ss = height > resized_height ? (height - resized_height) / 2 : 0;
    pad_height = (size_t)pad_height_ss;
  }
 
  // Resize the captured frame to the aspect-correct dimensions.
  if (resized_width <= 0 || resized_height <= 0) {
    log_error("Invalid dimensions for resize: width=%zd, height=%zd", resized_width, resized_height);
    return NULL;
  }
 
  // Validate dimensions fit in image_t's int fields before casting
  if (resized_width > INT_MAX || resized_height > INT_MAX) {
    log_error("Dimensions exceed INT_MAX: width=%zd, height=%zd", resized_width, resized_height);
    return NULL;
  }
 
  // Always resize to target dimensions
  image_t *resized = image_new((size_t)resized_width, (size_t)resized_height);
  if (!resized) {
    log_error("Failed to allocate resized image");
    return NULL;
  }
 
  image_clear(resized);
  image_resize(original, resized);
 
  char *ascii;
  if (color) {
    // Check for half-block mode first (requires NEON)
    if (GET_OPTION(render_mode) == RENDER_MODE_HALF_BLOCK) {
#if SIMD_SUPPORT_NEON
      // Use NEON half-block renderer
      const uint8_t *rgb_data = (const uint8_t *)resized->pixels;
      ascii = rgb_to_truecolor_halfblocks_neon(rgb_data, resized->w, resized->h, 0);
#else
      log_error("Half-block mode requires NEON support (ARM architecture)");
      image_destroy(resized);
      return NULL;
#endif
    } else {
#ifdef SIMD_SUPPORT
      // Standard color modes (foreground/background)
      bool use_background = (GET_OPTION(render_mode) == RENDER_MODE_BACKGROUND);
      ascii = image_print_color_simd(resized, use_background, false, palette_chars);
#else
      ascii = image_print_color(resized, palette_chars);
#endif
    }
  } else {
    // Use grayscale/monochrome conversion with client's palette
#ifdef SIMD_SUPPORT
    ascii = image_print_simd(resized, luminance_palette);
#else
    ascii = image_print(resized, palette_chars);
#endif
  }
 
  if (!ascii) {
    log_error("Failed to convert image to ASCII");
    image_destroy(resized);
    return NULL;
  }
 
  size_t ascii_len = strlen(ascii);
  if (ascii_len == 0) {
    log_error("ASCII conversion returned empty string (resized dimensions: %dx%d)", resized->w, resized->h);
    SAFE_FREE(ascii);
    image_destroy(resized);
    return NULL;
  }
 
  char *ascii_width_padded = ascii_pad_frame_width(ascii, pad_width);
  SAFE_FREE(ascii);
 
  char *ascii_padded = ascii_pad_frame_height(ascii_width_padded, pad_height);
  SAFE_FREE(ascii_width_padded);
 
  // Only destroy resized if we allocated it (not when using original directly)
  image_destroy(resized);
 
  return ascii_padded;
}

References ascii_pad_frame_height(), ascii_pad_frame_width(), aspect_ratio(), image_clear(), image_destroy(), image_new(), image_print(), image_print_color(), image_print_color_simd(), image_print_simd(), and image_resize().

Referenced by benchmark_simd_color_conversion_with_source(), and convert_frame_to_ascii().

build_client_luminance_palette()

int build_client_luminance_palette ( const char *  palette_chars, size_t  palette_len, char  luminance_mapping[256]  )

extern

Definition at line 279 of file palette.c.

                                                                                                               {
  if (!palette_chars || palette_len == 0 || !luminance_mapping) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for client luminance palette");
    return -1;
  }
 
  // Map 256 luminance values to palette indices for this specific client
  for (int i = 0; i < 256; i++) {
    // Linear mapping with proper rounding
    size_t palette_index = (i * (palette_len - 1) + 127) / 255;
    if (palette_index >= palette_len) {
      palette_index = palette_len - 1;
    }
    luminance_mapping[i] = palette_chars[palette_index];
  }
 
  return 0;
}

Referenced by initialize_client_palette().

convert_frame_to_ascii()

EMSCRIPTEN_KEEPALIVE char * convert_frame_to_ascii	(	uint8_t *	rgba_data,
		int	width,
		int	height,
		int	ascii_width,
		int	ascii_height
	)

Definition at line 39 of file ascii_wasm.c.

                                                                                       {
  ensure_palette_initialized();
 
  // Create image_t structure
  image_t image;
  image.w = width;
  image.h = height;
 
  // Allocate RGB pixel array (3 bytes per pixel)
  image.pixels = (rgb_pixel_t *)malloc(width * height * sizeof(rgb_pixel_t));
  if (!image.pixels) {
    return NULL;
  }
 
  // Convert RGBA to RGB (skip alpha channel)
  for (int i = 0; i < width * height; i++) {
    image.pixels[i].r = rgba_data[i * 4 + 0];
    image.pixels[i].g = rgba_data[i * 4 + 1];
    image.pixels[i].b = rgba_data[i * 4 + 2];
    // Skip alpha channel (rgba_data[i * 4 + 3])
  }
 
  // Call ascii_convert
  // Parameters: image, target_width, target_height, color, aspect_ratio, stretch, palette, luminance
  char *result = ascii_convert(&image, ascii_width, ascii_height,
                               false, // color: false for monochrome (simpler for MVP)
                               true,  // aspect_ratio: true to maintain aspect
                               false, // stretch: false to preserve aspect ratio
                               WASM_PALETTE, g_luminance_palette);
 
  // Free the temporary RGB buffer
  free(image.pixels);
 
  return result;
}

References ascii_convert().

free_ascii_buffer()

EMSCRIPTEN_KEEPALIVE void free_ascii_buffer

(

char *

buffer

)

Definition at line 78 of file ascii_wasm.c.

                                     {
  if (buffer) {
    free(buffer);
  }
}