image.c File Reference

🖨️ Image processing: format detection, decoding, scaling, and pixel format conversion More...

Go to the source code of this file.

Functions
image_t *	image_new (size_t width, size_t height)
	Create a new image with standard allocation.
void	image_destroy (image_t *p)
	Destroy an image allocated with image_new()
image_t *	image_new_from_pool (size_t width, size_t height)
	Create a new image from buffer pool.
void	image_destroy_to_pool (image_t *image)
	Destroy an image allocated from buffer pool.
void	image_clear (image_t *p)
	Clear image (set all pixels to black)
rgb_pixel_t *	image_pixel (image_t *p, const int x, const int y)
void	image_resize (const image_t *s, image_t *d)
	Resize image using nearest-neighbor interpolation.
void	image_resize_interpolation (const image_t *source, image_t *dest)
	Resize image using bilinear interpolation.
void	precalc_rgb_palettes (const float red, const float green, const float blue)
	Precalculate RGB palettes with color adjustment.
char *	image_print (const image_t *p, const char *palette)
	Print image as ASCII art (monochrome)
void	quantize_color (int *r, int *g, int *b, int levels)
	Quantize color to specified number of levels.
char *	image_print_color (const image_t *p, const char *palette)
	Print image as ASCII art with color.
char *	rgb_to_ansi_fg (int r, int g, int b)
	Convert RGB to ANSI foreground color code.
char *	rgb_to_ansi_bg (int r, int g, int b)
	Convert RGB to ANSI background color code.
void	rgb_to_ansi_8bit (int r, int g, int b, int *fg_code, int *bg_code)
	Convert RGB to 8-bit ANSI color codes.
char *	image_print_with_capabilities (const image_t *image, const terminal_capabilities_t *caps, const char *palette, const char luminance_palette[256] __attribute__((unused)))
char *	image_print_256color (const image_t *image, const char *palette)
	Print image using 256-color ANSI mode.
char *	image_print_16color (const image_t *image, const char *palette)
	Print image using 16-color ANSI mode.
char *	image_print_16color_dithered (const image_t *image, const char *palette)
	Print image using 16-color ANSI mode with dithering.
char *	image_print_16color_dithered_with_background (const image_t *image, bool use_background, const char *palette)
	Print image using 16-color ANSI mode with dithering and background colors.

Detailed Description

🖨️ Image processing: format detection, decoding, scaling, and pixel format conversion

Definition in file video/image.c.

Function Documentation

image_pixel()

rgb_pixel_t * image_pixel ( image_t *  p, const int  x, const int  y  )

inline

Definition at line 224 of file video/image.c.

                                                                      {
  // Add bounds checking to prevent buffer overflow on invalid coordinates
  if (!p || !p->pixels || x < 0 || x >= p->w || y < 0 || y >= p->h) {
    return NULL;
  }
  return &p->pixels[x + y * p->w];
}

References image_t::h, image_t::pixels, and image_t::w.

image_print_with_capabilities()

char * image_print_with_capabilities	(	const image_t *	image,
		const terminal_capabilities_t *	caps,
		const char *	palette,
		const char luminance_palette	__attribute__((unused))[256]
	)

Definition at line 655 of file video/image.c.

                                                                                               {
 
  if (!image || !image->pixels || !caps || !palette) {
    SET_ERRNO(ERROR_INVALID_PARAM, "image=%p or image->pixels=%p or caps=%p or palette=%p is NULL", image,
              image->pixels, caps, palette);
    return NULL;
  }
 
  // Handle half-block mode first (requires NEON)
  if (caps->render_mode == RENDER_MODE_HALF_BLOCK) {
#if SIMD_SUPPORT_NEON
    // Use NEON half-block renderer
    const uint8_t *rgb_data = (const uint8_t *)image->pixels;
    return rgb_to_truecolor_halfblocks_neon(rgb_data, image->w, image->h, 0);
#else
    SET_ERRNO(ERROR_INVALID_STATE, "Half-block mode requires NEON support (ARM architecture)");
    return NULL;
#endif
  }
 
  // Standard color modes
  bool use_background_mode = (caps->render_mode == RENDER_MODE_BACKGROUND);
 
  char *result = NULL;
 
  // Choose the appropriate printing method based on terminal capabilities
  switch (caps->color_level) {
  case TERM_COLOR_TRUECOLOR:
    // Use existing truecolor printing function with client's palette
#ifdef SIMD_SUPPORT
    result = image_print_color_simd((image_t *)image, use_background_mode, false, palette);
#else
    result = image_print_color(image, palette);
#endif
    break;
 
  case TERM_COLOR_256:
#ifdef SIMD_SUPPORT
    result = image_print_color_simd((image_t *)image, use_background_mode, true, palette);
#else
    // Use 256-color conversion
    result = image_print_256color(image, palette);
#endif
    break;
 
  case TERM_COLOR_16:
    // Use 16-color conversion with Floyd-Steinberg dithering for better quality
    result = image_print_16color_dithered_with_background(image, use_background_mode, palette);
    break;
 
  case TERM_COLOR_NONE:
  default:
    // Use grayscale/monochrome conversion with client's custom palette
#ifdef SIMD_SUPPORT
    result = image_print_simd((image_t *)image, palette);
#else
    result = image_print(image, palette);
#endif
    break;
  }
 
  // Note: Background mode is now handled via capabilities rather than global state
  return result;
}

References terminal_capabilities_t::color_level, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, image_t::h, image_print(), image_print_16color_dithered_with_background(), image_print_256color(), image_print_color(), image_print_color_simd(), image_print_simd(), image_t::pixels, terminal_capabilities_t::render_mode, RENDER_MODE_BACKGROUND, RENDER_MODE_HALF_BLOCK, SET_ERRNO, TERM_COLOR_16, TERM_COLOR_256, TERM_COLOR_NONE, TERM_COLOR_TRUECOLOR, and image_t::w.

Referenced by ascii_convert_with_capabilities().