render.h File Reference

Go to the source code of this file.

Data Structures
struct	ascii_temporal_cell_t
	For ascii stabilizer, this is the live record that ties cells, width, height, configuration together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. More...
struct	ascii_stabilizer_t
struct	ascii_frame_t
	When code needs to work with ascii frame, it keeps output, output_target, width, source_height here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. More...

Macros
#define	ASCII_INLINE_SCRATCH_COLUMNS   512
#define	ASCII_SCRATCH_PLANES   6
#define	DECLARE_ASCII_PROCESSOR(isa)
#define	DECLARE_HALF_PROCESSOR(isa)

Enumerations
enum	ascii_color_t { ASCII_COLOR_NONE , ASCII_COLOR_16 , ASCII_COLOR_256 , ASCII_COLOR_TRUE }

Functions
asciichat_error_t	ascii_stabilizer_prepare (ascii_stabilizer_t *state, size_t width, size_t height, uint64_t configuration)
void	ascii_stabilizer_reset (ascii_stabilizer_t *state)
ascii_stabilizer_t *	ascii_stabilizer_set_target (ascii_stabilizer_t *state)
uint32_t	ascii_stabilizer_choose (ascii_temporal_cell_t *cell, const uint8_t samples[16], uint32_t candidate, uint64_t candidate_error, uint64_t previous_error, uint32_t color, uint64_t elapsed_ns, uint32_t *stabilized_color)
char *	ascii_render (const image_t *image, const char *palette, ascii_color_t color, bool background, bool dither, const simd_cells_t *ops)
bool	ascii_glyph_palette_supported (const char *palette)
char *	ascii_render_glyph_match (const image_t *image, ascii_color_t color, const simd_cells_t *ops, const char *palette)
char *	ascii_render_glyph_match_mode (const image_t *image, ascii_color_t color, const simd_cells_t *ops, const char *palette, bool background)
char *	ascii_render_halfblocks (const uint8_t *rgb, int width, int height, int stride_bytes, ascii_color_t color, const simd_cells_t *ops)
asciichat_error_t	ascii_frame_init (ascii_frame_t *frame, const image_t *image, const char *palette)
void	ascii_frame_emit_row (ascii_frame_t *frame, ascii_color_t mode, bool background, bool more_rows, const simd_cells_t *ops)
char *	ascii_frame_finish (ascii_frame_t *frame)
char *	render_ascii_cells_sse2 (const image_t *, const char *, ascii_color_t, bool)
char *	render_ascii_cells_ssse3 (const image_t *, const char *, ascii_color_t, bool)
char *	render_ascii_cells_avx2 (const image_t *, const char *, ascii_color_t, bool)
char *	render_ascii_cells_neon (const image_t *, const char *, ascii_color_t, bool)
char *	render_ascii_cells_sve (const image_t *, const char *, ascii_color_t, bool)
asciichat_error_t	ascii_half_frame_init (ascii_frame_t *frame, const uint8_t *rgb, int width, int height, int *stride, ascii_color_t mode)
void	ascii_frame_emit_halfrow (ascii_frame_t *frame, ascii_color_t mode, bool more_rows, const simd_cells_t *ops)
char *	render_halfblocks_sse2 (const uint8_t *, int, int, int, ascii_color_t)
char *	render_halfblocks_ssse3 (const uint8_t *, int, int, int, ascii_color_t)
char *	render_halfblocks_avx2 (const uint8_t *, int, int, int, ascii_color_t)
char *	render_halfblocks_neon (const uint8_t *, int, int, int, ascii_color_t)
char *	render_halfblocks_sve (const uint8_t *, int, int, int, ascii_color_t)
outbuf_t *	ascii_render_set_output_target (outbuf_t *target)

Macro Definition Documentation

ASCII_INLINE_SCRATCH_COLUMNS

#define ASCII_INLINE_SCRATCH_COLUMNS   512

Definition at line 4 of file include/ascii-chat/video/ascii/render.h.

Referenced by ascii_frame_t::_Alignas().

ASCII_SCRATCH_PLANES

#define ASCII_SCRATCH_PLANES   6

Definition at line 5 of file include/ascii-chat/video/ascii/render.h.

Referenced by ascii_frame_t::_Alignas().

DECLARE_ASCII_PROCESSOR

#define DECLARE_ASCII_PROCESSOR

(

isa

)

Value:

char *render_ascii_cells_##isa(const image_t *, const char *, ascii_color_t, bool)

Definition at line 91 of file include/ascii-chat/video/ascii/render.h.

DECLARE_HALF_PROCESSOR

#define DECLARE_HALF_PROCESSOR

(

isa

)

Value:

char *render_halfblocks_##isa(const uint8_t *, int, int, int, ascii_color_t)

Definition at line 102 of file include/ascii-chat/video/ascii/render.h.

Enumeration Type Documentation

ascii_color_t

enum ascii_color_t

Shared terminal-cell contract for every ISA and scalar fallback. Palettes use complete UTF-8 glyphs from cache64. Runs never cross rows. Background mode sets a contrasting foreground. Colored rows finish with SGR reset before newline; monochrome rows carry no SGR or erase sequences. The returned buffer is owned by the caller and freed with SAFE_FREE. ISA entry points select their vector stages; callers must check CPU support.

Enumerator
ASCII_COLOR_NONE
ASCII_COLOR_16
ASCII_COLOR_256
ASCII_COLOR_TRUE

Definition at line 18 of file include/ascii-chat/video/ascii/render.h.

{ ASCII_COLOR_NONE, ASCII_COLOR_16, ASCII_COLOR_256, ASCII_COLOR_TRUE } ascii_color_t;

Function Documentation

ascii_frame_emit_halfrow()

void ascii_frame_emit_halfrow	(	ascii_frame_t *	frame,
		ascii_color_t	mode,
		bool	more_rows,
		const simd_cells_t *	ops )

Definition at line 453 of file lib/video/ascii/render.c.

                                                                                                                 {
  if (frame->stabilizer) {
    size_t top_row = frame->row * 2;
    bool has_bottom = top_row + 1 < frame->source_height;
    for (size_t x = 0; x < frame->width; ++x) {
      uint32_t *pixels[] = {&frame->packed[x], &frame->index[x]};
      for (size_t half = 0; half < (has_bottom ? 2u : 1u); ++half) {
        uint32_t color = *pixels[half];
        uint8_t luma = (uint8_t)((76u * (color >> 16) + 150u * ((color >> 8) & 255) + 29u * (color & 255)) >> 8);
        uint8_t samples[16];
        memset(samples, luma, sizeof(samples));
        ascii_temporal_cell_t *cell = &frame->stabilizer->cells[(top_row + half) * frame->width + x];
        ascii_stabilizer_choose(cell, samples, 0, 0, UINT64_MAX, color, frame->stabilizer->elapsed_ns, pixels[half]);
      }
      if (!has_bottom)
        frame->index[x] = frame->packed[x];
    }
    if (mode == ASCII_COLOR_TRUE) {
      memcpy(frame->fg, frame->packed, frame->width * sizeof(uint32_t));
      memcpy(frame->bg, frame->index, frame->width * sizeof(uint32_t));
    } else if (mode != ASCII_COLOR_NONE) {
      ops->quantize(frame->packed, frame->fg, frame->width, mode == ASCII_COLOR_16 ? 16 : 256);
      ops->quantize(frame->index, frame->bg, frame->width, mode == ASCII_COLOR_16 ? 16 : 256);
    }
    ops->halfblock(frame->packed, frame->index, frame->glyph, frame->fg, frame->bg, frame->width, (unsigned)mode,
                   frame->table);
  }
  emit_prepared_row(&frame->output, mode, ops, frame->glyph, frame->fg, frame->bg, frame->width);
  emit_row_end(&frame->output, mode != ASCII_COLOR_NONE, more_rows);
  ++frame->row;
}

References ASCII_COLOR_16, ASCII_COLOR_NONE, ASCII_COLOR_TRUE, ascii_stabilizer_choose(), ascii_frame_t::bg, ascii_stabilizer_t::cells, ascii_stabilizer_t::elapsed_ns, emit_row_end(), ascii_frame_t::fg, ascii_frame_t::glyph, simd_cells_t::halfblock, ascii_frame_t::index, ascii_frame_t::output, ascii_frame_t::packed, simd_cells_t::quantize, ascii_frame_t::row, ascii_frame_t::source_height, ascii_frame_t::stabilizer, ascii_frame_t::table, and ascii_frame_t::width.

Referenced by ascii_render_halfblocks().

ascii_frame_emit_row()

void ascii_frame_emit_row	(	ascii_frame_t *	frame,
		ascii_color_t	mode,
		bool	background,
		bool	more_rows,
		const simd_cells_t *	ops )

Definition at line 340 of file lib/video/ascii/render.c.

                                                   {
  if (frame->stabilizer && !frame->temporal_preselected) {
    const uint64_t elapsed = frame->stabilizer->elapsed_ns;
    const bool recent = elapsed <= ASCII_TEMPORAL_MAX_INTERVAL_NS;
    const unsigned weight = recent ? (unsigned)(elapsed * 256 / (elapsed + ASCII_TEMPORAL_COLOR_TIME_NS)) : 256;
    for (size_t x = 0; x < frame->width; ++x) {
      ascii_temporal_cell_t *cell = &frame->stabilizer->cells[frame->row * frame->width + x];
      uint8_t luma = frame->luma[x];
      uint32_t glyph = frame->glyph[x];
      uint32_t color = frame->packed[x];
      if (cell->valid && recent && abs((int)luma - (int)cell->samples[0]) <= ASCII_TEMPORAL_MOTION_LIMIT) {
        if (cell->glyph != glyph) {
          // Only nearby brightness bins can win the hysteresis test. Searching
          // outward avoids scanning the entire 64-entry palette for every cell.
          unsigned bin = luma >> 2;
          int best_delta = (int)luma - ((int)bin * 4 + 2);
          uint64_t best_error = (uint64_t)(best_delta * best_delta);
          uint64_t margin = best_error / 8 + 128;
          for (unsigned distance = 1; distance < 64; ++distance) {
            bool found = false;
            for (int direction = -1; direction <= 1; direction += 2) {
              int index = (int)bin + direction * (int)distance;
              if (index < 0 || index >= 64 || frame->table[index] != cell->glyph)
                continue;
              int delta = (int)luma - (index * 4 + 2);
              uint64_t error = (uint64_t)(delta * delta);
              if (error <= best_error || error - best_error <= margin)
                glyph = cell->glyph;
              found = true;
            }
            // Bins farther than this cannot fall within the error margin.
            int nearest_delta = (int)distance * 4 - 3;
            if (found || (uint64_t)(nearest_delta * nearest_delta) > best_error + margin)
              break;
          }
        }
        color = temporal_blend_color(cell->color, color, weight);
      }
      cell->samples[0] = luma;
      cell->glyph = frame->glyph[x] = glyph;
      cell->color = frame->packed[x] = color;
      cell->valid = true;
      if (background)
        frame->luma[x] =
            (uint8_t)((77u * (color >> 16) + 150u * ((color >> 8) & 255) + 29u * (color & 255) + 128u) >> 8);
    }
    if (!frame->dithered && (mode == ASCII_COLOR_16 || mode == ASCII_COLOR_256))
      ops->quantize(frame->packed, frame->index, frame->width, mode == ASCII_COLOR_16 ? 16 : 256);
  }
  for (size_t x = 0; x < frame->width; ++x) {
    frame->fg[x] = frame->bg[x] = UINT32_MAX;
    if (mode == ASCII_COLOR_NONE)
      continue;
    uint32_t value = mode == ASCII_COLOR_TRUE ? frame->packed[x] : frame->index[x];
    uint32_t contrast = frame->luma[x] < 128 ? (mode == ASCII_COLOR_TRUE ? 0xffffffu : 15u) : 0;
    if (mode == ASCII_COLOR_16) {
      uint8_t r, g, b;
      get_16color_rgb((uint8_t)value, &r, &g, &b);
      contrast = (77 * r + 150 * g + 29 * b) / 256 < 127 ? 15u : 0;
    }
    frame->fg[x] = background ? contrast : value;
    frame->bg[x] = background ? value : UINT32_MAX;
  }
  emit_prepared_row(&frame->output, mode, ops, frame->glyph, frame->fg, frame->bg, frame->width);
  emit_row_end(&frame->output, mode != ASCII_COLOR_NONE, more_rows);
  ++frame->row;
}

References ASCII_COLOR_16, ASCII_COLOR_256, ASCII_COLOR_NONE, ASCII_COLOR_TRUE, ASCII_TEMPORAL_COLOR_TIME_NS, ASCII_TEMPORAL_MAX_INTERVAL_NS, ASCII_TEMPORAL_MOTION_LIMIT, ascii_frame_t::bg, ascii_stabilizer_t::cells, ascii_temporal_cell_t::color, ascii_frame_t::dithered, ascii_stabilizer_t::elapsed_ns, emit_row_end(), ascii_frame_t::fg, get_16color_rgb(), ascii_frame_t::glyph, ascii_temporal_cell_t::glyph, ascii_frame_t::index, index, ascii_frame_t::luma, ascii_frame_t::output, ascii_frame_t::packed, simd_cells_t::quantize, ascii_frame_t::row, ascii_temporal_cell_t::samples, ascii_frame_t::stabilizer, ascii_frame_t::table, ascii_frame_t::temporal_preselected, ascii_temporal_cell_t::valid, and ascii_frame_t::width.

Referenced by ascii_frame_t::_Alignas(), ascii_render(), and ascii_render_glyph_match_mode().

ascii_frame_finish()

char * ascii_frame_finish

(

ascii_frame_t *

frame

)

Definition at line 408 of file lib/video/ascii/render.c.

                                               {
  if (frame->scratch != frame->inline_scratch)
    release_scratch(frame->scratch);
  ob_term(&frame->output);
  if (frame->output_target)
    *frame->output_target = frame->output;
  return frame->output.buf;
}

References outbuf_t::buf, ob_term(), ascii_frame_t::output, ascii_frame_t::output_target, and ascii_frame_t::scratch.

Referenced by ascii_frame_t::_Alignas(), ascii_render(), ascii_render_glyph_match_mode(), and ascii_render_halfblocks().

ascii_frame_init()

asciichat_error_t ascii_frame_init	(	ascii_frame_t *	frame,
		const image_t *	image,
		const char *	palette )

Definition at line 305 of file lib/video/ascii/render.c.

                                                                                                    {
  ASCII_OTEL_SCOPE(ASCII_FRAME_INIT);
  outbuf_t *target = g_output_target;
  memset(frame, 0, sizeof(*frame));
  if (!image || !image->pixels || image->w <= 0 || image->h <= 0 || !palette || !palette[0])
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid image or palette");
  size_t bytes, pixels, capacity, rows;
  if (checked_size_mul((size_t)image->w, (size_t)image->h, &pixels) != ASCIICHAT_OK ||
      checked_size_mul(pixels, 48u, &capacity) != ASCIICHAT_OK ||
      checked_size_mul((size_t)image->h, 5u, &rows) != ASCIICHAT_OK ||
      checked_size_add(capacity, rows, &capacity) != ASCIICHAT_OK ||
      checked_size_add(capacity, 1u, &capacity) != ASCIICHAT_OK ||
      checked_size_mul((size_t)image->w, 6 * sizeof(uint32_t), &bytes) != ASCIICHAT_OK)
    return ERROR_INVALID_PARAM;
  utf8_palette_cache_t *cache = get_utf8_palette_cache(palette);
  if (!cache)
    return ERROR_INVALID_PARAM;
  prepare_output(frame, capacity, target);
  frame->width = (size_t)image->w;
  if (g_stabilizer_target && g_stabilizer_target->cells && g_stabilizer_target->width == (size_t)image->w &&
      g_stabilizer_target->height == (size_t)image->h)
    frame->stabilizer = g_stabilizer_target;
  for (size_t i = 0; i < 64; ++i)
    memcpy(frame->table + i, cache->cache64[i].utf8_bytes, cache->cache64[i].byte_len);
  frame->scratch = acquire_scratch(frame->inline_scratch, bytes);
  if (!frame->scratch)
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate ASCII scratch workspace");
  frame->packed = frame->scratch;
  frame->index = frame->packed + frame->width;
  frame->glyph = frame->index + frame->width;
  frame->fg = frame->glyph + frame->width;
  frame->bg = frame->fg + frame->width;
  frame->luma = (uint8_t *)(frame->bg + frame->width);
  return ASCIICHAT_OK;
}

References ASCII_OTEL_SCOPE, ASCIICHAT_OK, ascii_frame_t::bg, utf8_char_t::byte_len, utf8_palette_cache::cache64, ERROR_INVALID_PARAM, ERROR_MEMORY, ascii_frame_t::fg, get_utf8_palette_cache(), ascii_frame_t::glyph, image_t::h, ascii_frame_t::index, ascii_frame_t::luma, ascii_frame_t::packed, image_t::pixels, ascii_frame_t::scratch, SET_ERRNO, ascii_frame_t::stabilizer, ascii_frame_t::table, utf8_char_t::utf8_bytes, image_t::w, and ascii_frame_t::width.

Referenced by ascii_frame_t::_Alignas(), ascii_render(), and ascii_render_glyph_match_mode().

ascii_glyph_palette_supported()

bool ascii_glyph_palette_supported

(

const char *

palette

)

Definition at line 540 of file lib/video/ascii/render.c.

                                                        {
  if (!palette || !*palette)
    return false;
  for (const uint8_t *p = (const uint8_t *)palette; *p;) {
    size_t length;
    if (glyph_palette_index(p, &length) < 0)
      return false;
    p += length;
  }
  return true;
}

Referenced by acip_render_settings_prepare(), ascii_convert_with_buffers_stabilized(), ascii_render_glyph_match_mode(), mirror_convert_frame(), and validate_glyph_palette().

ascii_half_frame_init()

asciichat_error_t ascii_half_frame_init	(	ascii_frame_t *	frame,
		const uint8_t *	rgb,
		int	width,
		int	height,
		int *	stride,
		ascii_color_t	mode )

Definition at line 417 of file lib/video/ascii/render.c.

                                                            {
  ASCII_OTEL_SCOPE(ASCII_HALF_FRAME_INIT);
  outbuf_t *target = g_output_target;
  memset(frame, 0, sizeof(*frame));
  size_t row_bytes, extent, bytes, capacity;
  if (!rgb || width <= 0 || height <= 0 || mode < ASCII_COLOR_NONE || mode > ASCII_COLOR_TRUE ||
      checked_size_mul((size_t)width, 3, &row_bytes) != ASCIICHAT_OK || row_bytes > INT_MAX)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid half-block input");
  if (*stride <= 0)
    *stride = (int)row_bytes;
  if ((size_t)*stride < row_bytes || checked_size_mul((size_t)*stride, (size_t)height, &extent) != ASCIICHAT_OK ||
      checked_size_mul((size_t)width, 6 * sizeof(uint32_t), &bytes) != ASCIICHAT_OK ||
      checked_size_mul((size_t)width, ((size_t)height + 1) / 2, &capacity) != ASCIICHAT_OK ||
      checked_size_mul(capacity, 48u, &capacity) != ASCIICHAT_OK ||
      checked_size_add(capacity, 1u, &capacity) != ASCIICHAT_OK)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid half-block stride or size");
  prepare_output(frame, capacity, target);
  frame->width = (size_t)width;
  frame->source_height = (size_t)height;
  if (g_stabilizer_target && g_stabilizer_target->cells && g_stabilizer_target->width == (size_t)width &&
      g_stabilizer_target->height == (size_t)height)
    frame->stabilizer = g_stabilizer_target;
  frame->scratch = acquire_scratch(frame->inline_scratch, bytes);
  if (!frame->scratch)
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate ASCII scratch workspace");
  frame->packed = frame->scratch;
  frame->index = frame->packed + width;
  frame->glyph = frame->index + width;
  frame->fg = frame->glyph + width;
  frame->bg = frame->fg + width;
  const char blocks[5][4] = {"\xe2\x96\x91", "\xe2\x96\x92", "\xe2\x96\x93", "\xe2\x96\x88", "\xe2\x96\x80"};
  for (size_t i = 0; i < 5; ++i)
    memcpy(frame->table + i, blocks[i], 3);
  return ASCIICHAT_OK;
}

References ASCII_COLOR_TRUE, ASCII_OTEL_SCOPE, ASCIICHAT_OK, ascii_frame_t::bg, ERROR_INVALID_PARAM, ERROR_MEMORY, ascii_frame_t::fg, ascii_frame_t::glyph, height, ascii_frame_t::index, ascii_frame_t::packed, ascii_frame_t::scratch, SET_ERRNO, ascii_frame_t::source_height, ascii_frame_t::stabilizer, ascii_frame_t::table, ascii_frame_t::width, and width.

Referenced by ascii_render_halfblocks().

ascii_render()

char * ascii_render	(	const image_t *	image,
		const char *	palette,
		ascii_color_t	color,
		bool	background,
		bool	dither,
		const simd_cells_t *	ops )

Definition at line 197 of file lib/video/ascii/render.c.

                                            {
  if (!ops || mode < ASCII_COLOR_NONE || mode > ASCII_COLOR_TRUE) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid rendering backend or color mode");
    return NULL;
  }
  if (!dither) {
#if SIMD_SUPPORT_SSE2
    if (ops == &simd_cells_sse2)
      return render_ascii_cells_sse2(image, palette, mode, background);
#endif
#if SIMD_SUPPORT_SSSE3
    if (ops == &simd_cells_ssse3)
      return render_ascii_cells_ssse3(image, palette, mode, background);
#endif
#if SIMD_SUPPORT_AVX2
    if (ops == &simd_cells_avx2)
      return render_ascii_cells_avx2(image, palette, mode, background);
#endif
#if SIMD_SUPPORT_NEON
    if (ops == &simd_cells_neon)
      return render_ascii_cells_neon(image, palette, mode, background);
#endif
#if SIMD_SUPPORT_SVE
    if (ops == &simd_cells_sve)
      return render_ascii_cells_sve(image, palette, mode, background);
#endif
  }
  ascii_frame_t frame;
  if (ascii_frame_init(&frame, image, palette) != ASCIICHAT_OK)
    return NULL;
  rgb_error_t *errors = NULL;
  if (mode == ASCII_COLOR_16 && dither)
    errors = SAFE_CALLOC((size_t)image->w * (size_t)image->h, sizeof(rgb_error_t), rgb_error_t *);
  frame.dithered = errors != NULL;
  for (int y = 0; y < image->h; ++y) {
    const uint8_t *source = (const uint8_t *)(image->pixels + (size_t)y * frame.width);
    ops->luminance(source, frame.luma, frame.width);
    ops->pack(source, frame.packed, frame.width);
    ops->lookup(frame.luma, frame.table, frame.glyph, frame.width);
    if (mode == ASCII_COLOR_16 || mode == ASCII_COLOR_256) {
      if (errors) {
        // Floyd-Steinberg error propagation is ordered; the other stages remain SIMD.
        for (int x = 0; x < image->w; ++x) {
          uint32_t pixel = frame.packed[x];
          frame.index[x] = rgb_to_16color_dithered((int)(pixel >> 16), (int)((pixel >> 8) & 255), (int)(pixel & 255), x,
                                                   y, image->w, image->h, errors);
        }
      } else
        ops->quantize(frame.packed, frame.index, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
    }
    ascii_frame_emit_row(&frame, mode, background, y + 1 < image->h, ops);
  }
  SAFE_FREE(errors);
  return ascii_frame_finish(&frame);
}

References ASCII_COLOR_16, ASCII_COLOR_256, ASCII_COLOR_TRUE, ascii_frame_emit_row(), ascii_frame_finish(), ascii_frame_init(), ASCIICHAT_OK, ascii_frame_t::dithered, ERROR_INVALID_PARAM, ascii_frame_t::glyph, image_t::h, ascii_frame_t::index, simd_cells_t::lookup, ascii_frame_t::luma, simd_cells_t::luminance, simd_cells_t::pack, ascii_frame_t::packed, image_t::pixels, simd_cells_t::quantize, render_ascii_cells_avx2(), render_ascii_cells_neon(), render_ascii_cells_sse2(), render_ascii_cells_ssse3(), render_ascii_cells_sve(), rgb_to_16color_dithered(), SAFE_CALLOC, SAFE_FREE, SET_ERRNO, simd_cells_avx2, simd_cells_neon, simd_cells_sse2, simd_cells_ssse3, simd_cells_sve, source, ascii_frame_t::table, image_t::w, and ascii_frame_t::width.

Referenced by image_print(), image_print_16color(), image_print_16color_dithered(), image_print_16color_dithered_with_background(), image_print_256color(), image_print_color(), image_print_color_background(), image_print_color_simd(), image_print_color_utf8(), and image_print_with_capabilities().

ascii_render_glyph_match()

char * ascii_render_glyph_match	(	const image_t *	image,
		ascii_color_t	color,
		const simd_cells_t *	ops,
		const char *	palette )

Definition at line 584 of file lib/video/ascii/render.c.

                                                                                                                       {
  return ascii_render_glyph_match_mode(image, mode, ops, palette, false);
}

References ascii_render_glyph_match_mode().

ascii_render_glyph_match_mode()

char * ascii_render_glyph_match_mode	(	const image_t *	image,
		ascii_color_t	color,
		const simd_cells_t *	ops,
		const char *	palette,
		bool	background )

Definition at line 588 of file lib/video/ascii/render.c.

                                                                          {
  if (!image || !image->pixels || !ops || image->w <= 0 || image->h <= 0 || image->w % 8 || image->h % 8 ||
      mode < ASCII_COLOR_NONE || mode > ASCII_COLOR_TRUE) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid glyph matching input");
    return NULL;
  }
  bool allowed[GLYPH_COUNT] = {false};
  int candidates[GLYPH_COUNT];
  // Restrict the atlas to unique palette entries before scoring any cells.
  size_t candidate_count = 0;
  int (*shape_correlation)(const int16_t[16], const int16_t[16]) =
      ops->glyph_shape_correlation ? ops->glyph_shape_correlation : glyph_shape_correlation_scalar;
  if (palette) {
    if (!ascii_glyph_palette_supported(palette)) {
      SET_ERRNO(ERROR_INVALID_PARAM, "Glyph palette contains an unsupported character");
      return NULL;
    }
    for (const uint8_t *p = (const uint8_t *)palette; *p;) {
      size_t length;
      int index = glyph_palette_index(p, &length);
      if (!allowed[index]) {
        allowed[index] = true;
        candidates[candidate_count++] = index;
      }
      p += length;
    }
  } else {
    for (int i = 0; i < GLYPH_ASCII_COUNT; ++i) {
      allowed[i] = true;
      candidates[candidate_count++] = i;
    }
  }
  // Prepare coverage and its sufficient statistics once per frame.
  glyph_candidate_t glyphs[GLYPH_COUNT];
  // Precompute each mask's brightness and centered shape for correlation.
  for (size_t c = 0; c < candidate_count; ++c) {
    int g = candidates[c];
    glyph_candidate_t *glyph = &glyphs[c];
    glyph->key = glyph_key(g);
    uint8_t block_mask[16];
    const uint8_t *mask = g < GLYPH_ASCII_COUNT ? glyph_masks[g] : block_mask;
    if (g >= GLYPH_ASCII_COUNT)
      glyph_block_mask(g - GLYPH_ASCII_COUNT, block_mask);
    glyph->sum = glyph->energy = 0;
    for (int i = 0; i < 16; ++i) {
      glyph->mask[i] = mask[i];
      glyph->sum += mask[i];
    }
    int mean = glyph->sum / 16;
    glyph->tone = glyph->sum * 255 / (g < GLYPH_ASCII_COUNT ? GLYPH_MASK_MAX_SUM : 16 * 255);
    for (int i = 0; i < 16; ++i) {
      glyph->centered[i] = (int16_t)((int)mask[i] - mean);
      glyph->energy += glyph->centered[i] * glyph->centered[i];
    }
  }
  image_t cells = *image;
  cells.w /= 8;
  cells.h /= 8;
  ascii_frame_t frame;
  if (ascii_frame_init(&frame, &cells, " .") != ASCIICHAT_OK)
    return NULL;
  frame.temporal_preselected = true;
  for (int y = 0; y < cells.h; ++y) {
    for (int x = 0; x < cells.w; ++x) {
      int16_t samples[3][16] = {{0}};
      int sums[3] = {0};
      uint8_t patch[16];
      int sample_mean = 0;
      for (int sy = 0; sy < 4; ++sy) {
        const rgb_pixel_t *top = image->pixels + (size_t)(y * 8 + sy * 2) * (size_t)image->w + (size_t)(x * 8);
        const rgb_pixel_t *bottom = top + image->w;
        for (int sx = 0; sx < 4; ++sx) {
          const rgb_pixel_t a = top[sx * 2], b = top[sx * 2 + 1];
          const rgb_pixel_t c = bottom[sx * 2], d = bottom[sx * 2 + 1];
          int i = sy * 4 + sx;
          int red = (a.r + b.r + c.r + d.r) / 4;
          int green = (a.g + b.g + c.g + d.g) / 4;
          int blue = (a.b + b.b + c.b + d.b) / 4;
          patch[i] = (uint8_t)((77 * red + 150 * green + 29 * blue) >> 8);
          samples[0][i] = (int16_t)red;
          samples[1][i] = (int16_t)green;
          samples[2][i] = (int16_t)blue;
          sample_mean += patch[i];
          for (int channel = 0; channel < 3; ++channel)
            sums[channel] += samples[channel][i];
        }
      }
      // Compare local shape independently of the patch's average brightness.
      sample_mean /= 16;
      int16_t centered_samples[16];
      int sample_energy = 0;
      for (int i = 0; i < 16; ++i) {
        int centered = (int)patch[i] - sample_mean;
        centered_samples[i] = (int16_t)centered;
        sample_energy += centered * centered;
      }
      size_t best = 0, previous_index = 0;
      uint64_t best_error = UINT64_MAX;
      uint64_t previous_error = UINT64_MAX;
      ascii_temporal_cell_t *previous = frame.stabilizer ? &frame.stabilizer->cells[(size_t)y * frame.width + x] : NULL;
      for (size_t c = 0; c < candidate_count; ++c) {
        bool is_previous = previous && previous->valid && previous->glyph == glyphs[c].key;
        int tone_delta = sample_mean - glyphs[c].tone;
        int tone_error = 16 * tone_delta * tone_delta;
        // Shape error cannot lower the score below the brightness error.
        if (!is_previous && (uint64_t)tone_error > best_error)
          continue;
        int dot = shape_correlation(centered_samples, glyphs[c].centered);
        uint64_t error = (uint64_t)(tone_error + sample_energy + glyphs[c].energy - 2 * dot);
        if (is_previous) {
          previous_error = error;
          previous_index = c;
        }
        if (error < best_error) {
          best_error = error;
          best = c;
        }
      }
      uint32_t rgb = glyph_foreground(&glyphs[best], samples, sums);
      uint32_t bg_rgb =
          ((uint32_t)(sums[0] / 128) << 16) | ((uint32_t)(sums[1] / 128) << 8) | (uint32_t)(sums[2] / 128);
      uint32_t selected = glyphs[best].key;
      if (previous) {
        ascii_temporal_cell_t old = *previous;
        unsigned motion = 0;
        unsigned color_motion = 0;
        for (int i = 0; i < 16; ++i)
          motion += (unsigned)abs((int)patch[i] - (int)old.samples[i]);
        if (old.valid && mode != ASCII_COLOR_NONE) {
          for (int channel = 0; channel < 3; ++channel)
            for (int i = 0; i < 16; ++i)
              color_motion += (unsigned)abs(samples[channel][i] - (int)old.rgb_samples[channel][i]);
          color_motion /= 48;
        }
        uint64_t elapsed = frame.stabilizer->elapsed_ns;
        uint64_t effective_elapsed = color_motion > ASCII_TEMPORAL_MOTION_LIMIT ? UINT64_MAX : elapsed;
        selected = ascii_stabilizer_choose(previous, patch, selected, best_error, previous_error, rgb,
                                           effective_elapsed, &rgb);
        if (selected != glyphs[best].key) {
          *previous = old;
          selected = ascii_stabilizer_choose(previous, patch, glyphs[best].key, best_error, previous_error,
                                             glyph_foreground(&glyphs[previous_index], samples, sums),
                                             effective_elapsed, &rgb);
        }
        if (old.valid && motion / 16 <= ASCII_TEMPORAL_MOTION_LIMIT && color_motion <= ASCII_TEMPORAL_MOTION_LIMIT &&
            elapsed <= ASCII_TEMPORAL_MAX_INTERVAL_NS) {
          unsigned weight = (unsigned)(elapsed * 256 / (elapsed + ASCII_TEMPORAL_COLOR_TIME_NS));
          bg_rgb = temporal_blend_color(old.background, bg_rgb, weight);
        }
        for (int channel = 0; channel < 3; ++channel)
          for (int i = 0; i < 16; ++i)
            previous->rgb_samples[channel][i] = (uint8_t)samples[channel][i];
        previous->background = bg_rgb;
      }
      frame.glyph[x] = selected;
      frame.packed[x] = rgb;
      frame.index[x] = bg_rgb;
      frame.luma[x] = (uint8_t)((77 * ((rgb >> 16) & 255) + 150 * ((rgb >> 8) & 255) + 29 * (rgb & 255)) >> 8);
    }
    if (background && mode != ASCII_COLOR_NONE) {
      if (mode == ASCII_COLOR_TRUE) {
        memcpy(frame.fg, frame.packed, frame.width * sizeof(uint32_t));
        memcpy(frame.bg, frame.index, frame.width * sizeof(uint32_t));
      } else {
        ops->quantize(frame.packed, frame.fg, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
        ops->quantize(frame.index, frame.bg, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
      }
      emit_prepared_row(&frame.output, mode, ops, frame.glyph, frame.fg, frame.bg, frame.width);
      emit_row_end(&frame.output, true, y + 1 < cells.h);
      ++frame.row;
    } else {
      if (mode == ASCII_COLOR_16 || mode == ASCII_COLOR_256)
        ops->quantize(frame.packed, frame.index, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
      ascii_frame_emit_row(&frame, mode, false, y + 1 < cells.h, ops);
    }
  }
  return ascii_frame_finish(&frame);
}

References ASCII_COLOR_16, ASCII_COLOR_256, ASCII_COLOR_NONE, ASCII_COLOR_TRUE, ascii_frame_emit_row(), ascii_frame_finish(), ascii_frame_init(), ascii_glyph_palette_supported(), ascii_stabilizer_choose(), ASCII_TEMPORAL_COLOR_TIME_NS, ASCII_TEMPORAL_MAX_INTERVAL_NS, ASCII_TEMPORAL_MOTION_LIMIT, ASCIICHAT_OK, rgb_pixel_t::b, ascii_temporal_cell_t::background, ascii_frame_t::bg, ascii_stabilizer_t::cells, cells, glyph_candidate_t::centered, ascii_stabilizer_t::elapsed_ns, emit_row_end(), glyph_candidate_t::energy, ERROR_INVALID_PARAM, ascii_frame_t::fg, rgb_pixel_t::g, ascii_frame_t::glyph, GLYPH_ASCII_COUNT, GLYPH_COUNT, GLYPH_MASK_MAX_SUM, simd_cells_t::glyph_shape_correlation, glyph_shape_correlation_scalar(), image_t::h, ascii_frame_t::index, index, glyph_candidate_t::key, ascii_frame_t::luma, glyph_candidate_t::mask, ascii_frame_t::output, ascii_frame_t::packed, image_t::pixels, simd_cells_t::quantize, rgb_pixel_t::r, ascii_temporal_cell_t::rgb_samples, ascii_frame_t::row, ascii_temporal_cell_t::samples, SET_ERRNO, ascii_frame_t::stabilizer, glyph_candidate_t::sum, ascii_frame_t::temporal_preselected, glyph_candidate_t::tone, ascii_temporal_cell_t::valid, image_t::w, and ascii_frame_t::width.

Referenced by ascii_convert_with_buffers_stabilized(), and ascii_render_glyph_match().

ascii_render_halfblocks()

char * ascii_render_halfblocks	(	const uint8_t *	rgb,
		int	width,
		int	height,
		int	stride_bytes,
		ascii_color_t	color,
		const simd_cells_t *	ops )

Two source rows per terminal row; the supplied backend processes both rows.

Definition at line 254 of file lib/video/ascii/render.c.

                                                       {
#if SIMD_SUPPORT_SSE2
  if (ops == &simd_cells_sse2)
    return render_halfblocks_sse2(rgb, width, height, stride, mode);
#endif
#if SIMD_SUPPORT_SSSE3
  if (ops == &simd_cells_ssse3)
    return render_halfblocks_ssse3(rgb, width, height, stride, mode);
#endif
#if SIMD_SUPPORT_AVX2
  if (ops == &simd_cells_avx2)
    return render_halfblocks_avx2(rgb, width, height, stride, mode);
#endif
#if SIMD_SUPPORT_NEON
  if (ops == &simd_cells_neon)
    return render_halfblocks_neon(rgb, width, height, stride, mode);
#endif
#if SIMD_SUPPORT_SVE
  if (ops == &simd_cells_sve)
    return render_halfblocks_sve(rgb, width, height, stride, mode);
#endif
 
  if (width <= 0 || height <= 0)
    return platform_strdup("");
  if (!ops) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid half-block backend");
    return NULL;
  }
  ascii_frame_t frame;
  if (ascii_half_frame_init(&frame, rgb, width, height, &stride, mode) != ASCIICHAT_OK)
    return NULL;
  for (size_t y = 0; y < (size_t)height; y += 2) {
    const uint8_t *top = rgb + y * (size_t)stride;
    const uint8_t *bottom = y + 1 < (size_t)height ? top + stride : top;
    ops->pack(top, frame.packed, frame.width);
    ops->pack(bottom, frame.index, frame.width);
    if (mode == ASCII_COLOR_TRUE) {
      memcpy(frame.fg, frame.packed, frame.width * sizeof(uint32_t));
      memcpy(frame.bg, frame.index, frame.width * sizeof(uint32_t));
    } else if (mode != ASCII_COLOR_NONE) {
      ops->quantize(frame.packed, frame.fg, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
      ops->quantize(frame.index, frame.bg, frame.width, mode == ASCII_COLOR_16 ? 16 : 256);
    }
    ops->halfblock(frame.packed, frame.index, frame.glyph, frame.fg, frame.bg, frame.width, (unsigned)mode,
                   frame.table);
    ascii_frame_emit_halfrow(&frame, mode, y + 2 < (size_t)height, ops);
  }
  return ascii_frame_finish(&frame);
}

References ASCII_COLOR_16, ASCII_COLOR_NONE, ASCII_COLOR_TRUE, ascii_frame_emit_halfrow(), ascii_frame_finish(), ascii_half_frame_init(), ASCIICHAT_OK, ascii_frame_t::bg, ERROR_INVALID_PARAM, ascii_frame_t::fg, ascii_frame_t::glyph, simd_cells_t::halfblock, height, ascii_frame_t::index, simd_cells_t::pack, ascii_frame_t::packed, simd_cells_t::quantize, render_halfblocks_avx2(), render_halfblocks_neon(), render_halfblocks_sse2(), render_halfblocks_ssse3(), render_halfblocks_sve(), SET_ERRNO, simd_cells_avx2, simd_cells_neon, simd_cells_sse2, simd_cells_ssse3, simd_cells_sve, ascii_frame_t::table, ascii_frame_t::width, and width.

Referenced by ascii_convert(), image_print_with_capabilities(), rgb_to_16color_halfblocks_scalar(), rgb_to_256color_halfblocks_scalar(), rgb_to_halfblocks_scalar(), and rgb_to_truecolor_halfblocks_scalar().

ascii_render_set_output_target()

outbuf_t * ascii_render_set_output_target

(

outbuf_t *

target

)

Internal one-shot output target, consumed by the next frame initializer. Returns the prior target so capability conversion can restore its scope.

Definition at line 126 of file lib/video/ascii/render.c.

                                                           {
  outbuf_t *previous = g_output_target;
  g_output_target = target;
  return previous;
}

Referenced by ascii_convert_with_buffers_stabilized().

ascii_stabilizer_choose()

uint32_t ascii_stabilizer_choose	(	ascii_temporal_cell_t *	cell,
		const uint8_t	samples[16],
		uint32_t	candidate,
		uint64_t	candidate_error,
		uint64_t	previous_error,
		uint32_t	color,
		uint64_t	elapsed_ns,
		uint32_t *	stabilized_color )

Choose a glyph using current and previous candidate errors and patch motion.

Definition at line 97 of file lib/video/ascii/render.c.

                                                             {
  unsigned motion = 0;
  if (cell->valid) {
    for (size_t i = 0; i < 16; ++i)
      motion += (unsigned)abs((int)samples[i] - (int)cell->samples[i]);
    motion /= 16;
  }
  uint32_t result = candidate;
  uint32_t output_color = color;
  if (cell->valid && motion <= ASCII_TEMPORAL_MOTION_LIMIT && elapsed_ns <= ASCII_TEMPORAL_MAX_INTERVAL_NS) {
    uint64_t margin = candidate_error / 8 + 128;
    if (previous_error != UINT64_MAX &&
        (previous_error <= candidate_error || previous_error - candidate_error <= margin))
      result = cell->glyph;
    // Weight depends on elapsed time, avoiding a different response at each FPS.
    unsigned weight = (unsigned)(elapsed_ns * 256 / (elapsed_ns + ASCII_TEMPORAL_COLOR_TIME_NS));
    output_color = temporal_blend_color(cell->color, color, weight);
  }
  memcpy(cell->samples, samples, sizeof(cell->samples));
  cell->glyph = result;
  cell->color = output_color;
  cell->valid = true;
  if (stabilized_color)
    *stabilized_color = output_color;
  return result;
}

References ASCII_TEMPORAL_COLOR_TIME_NS, ASCII_TEMPORAL_MAX_INTERVAL_NS, ASCII_TEMPORAL_MOTION_LIMIT, ascii_temporal_cell_t::color, ascii_temporal_cell_t::glyph, ascii_temporal_cell_t::samples, and ascii_temporal_cell_t::valid.

Referenced by ascii_frame_emit_halfrow(), and ascii_render_glyph_match_mode().

ascii_stabilizer_prepare()

asciichat_error_t ascii_stabilizer_prepare	(	ascii_stabilizer_t *	state,
		size_t	width,
		size_t	height,
		uint64_t	configuration )

Prepare history for a viewport and rendering contract, resetting it on change.

Definition at line 67 of file lib/video/ascii/render.c.

                                                                   {
  if (!state || !width || !height || width > SIZE_MAX / height ||
      width * height > SIZE_MAX / sizeof(ascii_temporal_cell_t))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid stabilization viewport");
  if (state->cells && state->width == width && state->height == height && state->configuration == configuration)
    return ASCIICHAT_OK;
  ascii_temporal_cell_t *cells = SAFE_CALLOC(width * height, sizeof(*cells), ascii_temporal_cell_t *);
  if (!cells)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate stabilization history");
  SAFE_FREE(state->cells);
  state->cells = cells;
  state->width = width;
  state->height = height;
  state->configuration = configuration;
  state->last_timestamp_ns = 0;
  state->elapsed_ns = UINT64_MAX;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, cells, ERROR_INVALID_PARAM, ERROR_MEMORY, height, SAFE_CALLOC, SAFE_FREE, SET_ERRNO, and width.

Referenced by ascii_convert_with_buffers_stabilized().

ascii_stabilizer_reset()

void ascii_stabilizer_reset

(

ascii_stabilizer_t *

state

)

Definition at line 60 of file lib/video/ascii/render.c.

                                                       {
  if (!state)
    return;
  SAFE_FREE(state->cells);
  memset(state, 0, sizeof(*state));
}

References SAFE_FREE.

Referenced by mirror_convert_frame(), session_display_destroy(), session_display_reset_stabilizer(), session_host_destroy(), and session_render_reset_stabilizer().

ascii_stabilizer_set_target()

ascii_stabilizer_t * ascii_stabilizer_set_target

(

ascii_stabilizer_t *

state

)

Select history for the current thread until the previous target is restored.

Definition at line 54 of file lib/video/ascii/render.c.

                                                                           {
  ascii_stabilizer_t *previous = g_stabilizer_target;
  g_stabilizer_target = state;
  return previous;
}

Referenced by ascii_convert_with_buffers_stabilized().

render_ascii_cells_avx2()

char * render_ascii_cells_avx2	(	const image_t *	,
		const char *	,
		ascii_color_t	,
		bool	)

Referenced by ascii_render().

render_ascii_cells_neon()

char * render_ascii_cells_neon	(	const image_t *	,
		const char *	,
		ascii_color_t	,
		bool	)

Referenced by ascii_render().

render_ascii_cells_sse2()

char * render_ascii_cells_sse2	(	const image_t *	,
		const char *	,
		ascii_color_t	,
		bool	)

Referenced by ascii_render().

render_ascii_cells_ssse3()

char * render_ascii_cells_ssse3	(	const image_t *	,
		const char *	,
		ascii_color_t	,
		bool	)

Referenced by ascii_render().

render_ascii_cells_sve()

char * render_ascii_cells_sve	(	const image_t *	,
		const char *	,
		ascii_color_t	,
		bool	)

References height, and width.

Referenced by ascii_render().

render_halfblocks_avx2()

char * render_halfblocks_avx2	(	const uint8_t *	,
		int	,
		int	,
		int	,
		ascii_color_t	)

Referenced by ascii_render_halfblocks().

render_halfblocks_neon()

char * render_halfblocks_neon	(	const uint8_t *	,
		int	,
		int	,
		int	,
		ascii_color_t	)

Referenced by ascii_render_halfblocks().

render_halfblocks_sse2()

char * render_halfblocks_sse2	(	const uint8_t *	,
		int	,
		int	,
		int	,
		ascii_color_t	)

Referenced by ascii_render_halfblocks().

render_halfblocks_ssse3()

char * render_halfblocks_ssse3	(	const uint8_t *	,
		int	,
		int	,
		int	,
		ascii_color_t	)

Referenced by ascii_render_halfblocks().

render_halfblocks_sve()

char * render_halfblocks_sve	(	const uint8_t *	,
		int	,
		int	,
		int	,
		ascii_color_t	)

Referenced by ascii_render_halfblocks().