cells.c

Go to the documentation of this file.

#include <ascii-chat/video/ascii/simd/cells.h>
#include <ascii-chat/video/terminal/ansi.h>
 
int glyph_shape_correlation_scalar(const int16_t samples[16], const int16_t mask[16]) {
  int dot = 0;
  for (int i = 0; i < 16; ++i)
    dot += samples[i] * mask[i];
  return dot;
}
void simd_pack_scalar(const uint8_t *rgb, uint32_t *out, size_t count) {
  for (size_t i = 0; i < count; ++i)
    out[i] = ((uint32_t)rgb[3 * i] << 16) | ((uint32_t)rgb[3 * i + 1] << 8) | rgb[3 * i + 2];
}
void simd_lookup_scalar(const uint8_t *luma, const uint32_t table[64], uint32_t *out, size_t count) {
  for (size_t i = 0; i < count; ++i)
    out[i] = table[luma[i] >> 2];
}
void simd_quantize_scalar(const uint32_t *rgb, uint32_t *out, size_t count, unsigned colors) {
  for (size_t i = 0; i < count; ++i) {
    uint8_t r = (uint8_t)(rgb[i] >> 16), g = (uint8_t)(rgb[i] >> 8), b = (uint8_t)rgb[i];
    out[i] = colors == 16 ? rgb_to_16color(r, g, b) : rgb_to_256color(r, g, b);
  }
}
size_t simd_run_scalar(const uint32_t *glyph, const uint32_t *fg, const uint32_t *bg, size_t count) {
  size_t i = 1;
  for (; i < count && glyph[i] == glyph[0] && fg[i] == fg[0] && bg[i] == bg[0]; ++i) {
  }
  return count ? i : 0;
}
void simd_halfblock_scalar(const uint32_t *top, const uint32_t *bottom, uint32_t *glyph, uint32_t *fg, uint32_t *bg,
                           size_t count, unsigned mode, const uint32_t keys[5]) {
  for (size_t i = 0; i < count; ++i) {
    uint32_t t = top[i], b = bottom[i];
    unsigned yt = (76 * (t >> 16) + 150 * ((t >> 8) & 255) + 29 * (t & 255)) >> 8;
    unsigned yb = (76 * (b >> 16) + 150 * ((b >> 8) & 255) + 29 * (b & 255)) >> 8;
    bool transparent = mode == 0 ? yt < 16 && yb < 16 : t == 0 && b == 0;
    glyph[i] = transparent ? (uint32_t)' ' : mode == 0 ? keys[yt >> 6] : keys[4];
    if (mode == 0 || transparent)
      fg[i] = bg[i] = UINT32_MAX;
  }
}
#define CELLS(isa, mono, dot)                                                                                          \
  {simd_luminance_##isa,                                                                                               \
   simd_pack_##isa,                                                                                                    \
   simd_lookup_##isa,                                                                                                  \
   simd_quantize_##isa,                                                                                                \
   simd_halfblock_##isa,                                                                                               \
   simd_run_##isa,                                                                                                     \
   mono,                                                                                                               \
   dot}
#if SIMD_SUPPORT_SSE2
#define GLYPH_CORRELATION_X86 glyph_shape_correlation_sse2
const simd_cells_t simd_cells_sse2 = CELLS(sse2, NULL, GLYPH_CORRELATION_X86);
#else
#define GLYPH_CORRELATION_X86 glyph_shape_correlation_scalar
#endif
#if SIMD_SUPPORT_SSSE3
const simd_cells_t simd_cells_ssse3 = CELLS(ssse3, NULL, GLYPH_CORRELATION_X86);
#endif
#if SIMD_SUPPORT_AVX2
const simd_cells_t simd_cells_avx2 = CELLS(avx2, NULL, glyph_shape_correlation_avx2);
#endif
#if SIMD_SUPPORT_NEON
const simd_cells_t simd_cells_neon = CELLS(neon, simd_emit_mono_neon, glyph_shape_correlation_neon);
#endif
#if SIMD_SUPPORT_SVE
const simd_cells_t simd_cells_sve = CELLS(sve, NULL, glyph_shape_correlation_sve);
#endif
const simd_cells_t simd_cells_scalar = CELLS(scalar, NULL, glyph_shape_correlation_scalar);
const simd_cells_t *simd_cells_backend(void) {
  uint32_t features = simd_backend()->required_features;
  (void)features;
#if SIMD_SUPPORT_SSE2
  if (features == CPU_FEATURE_SSE2)
    return &simd_cells_sse2;
#endif
#if SIMD_SUPPORT_SSSE3
  if (features == CPU_FEATURE_SSSE3)
    return &simd_cells_ssse3;
#endif
#if SIMD_SUPPORT_AVX2
  if (features == CPU_FEATURE_AVX2)
    return &simd_cells_avx2;
#endif
#if SIMD_SUPPORT_NEON
  if (features == CPU_FEATURE_NEON)
    return &simd_cells_neon;
#endif
#if SIMD_SUPPORT_SVE
  if (features == CPU_FEATURE_SVE)
    return &simd_cells_sve;
#endif
  return &simd_cells_scalar;
}