backends.h File Reference

Go to the source code of this file.

Functions
char *	digital_rain_render_at (digital_rain_t *rain, const char *frame, float seconds)
char *	rainbow_render_ansi_at (const char *frame, float seconds)
asciichat_error_t	test_pattern_render_at (struct test_pattern *pattern, int index, double time_ms, bool cadence)

Function Documentation

digital_rain_render_at()

char * digital_rain_render_at	(	digital_rain_t *	rain,
		const char *	frame,
		float	seconds )

Definition at line 384 of file digital_rain.c.

                                                                                     {
  if (!rain || !frame) {
    log_error("NULL parameter");
    return NULL;
  }
 
  if (!isfinite(seconds) || seconds < 0)
    return NULL;
  float elapsed = fmaxf(0.0f, seconds - rain->time);
  rain->time = seconds;
  float sim_time = seconds;
  // brightness_decay retains its meaning as a blend factor at 60 Hz.
  float decay = fminf(1.0f, fmaxf(0.0f, rain->brightness_decay));
  float alpha = elapsed > 0 ? 1.0f - powf(1.0f - decay, elapsed * 60.0f) : 0.0f;
 
  if (rain->rainbow_mode)
    color_filter_calculate_rainbow(sim_time, &rain->color_r, &rain->color_g, &rain->color_b);
 
  size_t input_len = strlen(frame);
  if (input_len > (SIZE_MAX - 1024) / 48)
    return NULL;
  size_t output_capacity = input_len * 48 + 1024;
  char *output = SAFE_MALLOC(output_capacity, char *);
  if (!output)
    return NULL;
 
  const char *src = frame;
  char *dst = output;
  size_t remaining = output_capacity;
  int col = 0, row = 0;
  float foreground_luminance = 1.0f, background_luminance = 0.0f;
  bool has_background = false;
  bool colored = false;
 
  while (*src && remaining > 100) {
    if (*src == '\033') {
      int r, g, b;
      bool foreground;
      const char *after = parse_ansi_color(src, &r, &g, &b, &foreground);
      if (after) {
        float luminance = fminf(1.0f, fmaxf(0.0f, (0.2126f * r + 0.7152f * g + 0.0722f * b) / 255.0f));
        if (foreground)
          foreground_luminance = luminance;
        else {
          background_luminance = luminance;
          has_background = true;
        }
        src = after;
      } else {
        after = skip_ansi_sequence(src);
        size_t count = (size_t)(after - src);
        if ((count == 4 && memcmp(src, "\033[0m", 4) == 0) || (count == 3 && memcmp(src, "\033[m", 3) == 0)) {
          foreground_luminance = 1.0f;
          has_background = false;
        }
        memcpy(dst, src, count);
        dst += count;
        remaining -= count;
        src = after;
      }
      continue;
    }
    if (*src == '\n' || *src == '\r') {
      if (*src == '\n')
        row++;
      col = 0;
      *dst++ = *src++;
      remaining--;
      continue;
    }
 
    float head;
    float brightness = get_rain_brightness(rain, col, row, sim_time, &head);
    // Update once per cell, independently of how many ANSI sequences precede it.
    if (row < rain->num_rows && col < rain->num_columns) {
      size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
      if (!rain->first_frame)
        brightness = rain->previous_brightness[idx] + (brightness - rain->previous_brightness[idx]) * alpha;
      rain->previous_brightness[idx] = brightness;
    }
    int count = generate_rain_color(dst, remaining, rain, brightness, head, foreground_luminance, true);
    colored = true;
    dst += count;
    remaining -= (size_t)count;
    if (has_background) {
      count = generate_rain_color(dst, remaining, rain, brightness, head, background_luminance, false);
      dst += count;
      remaining -= (size_t)count;
    }
    uint32_t codepoint;
    int bytes = utf8_decode((const uint8_t *)src, &codepoint);
    if (bytes <= 0) {
      bytes = 1;
      codepoint = (uint8_t)*src;
    }
    if (bytes == 1 && codepoint > 32 && codepoint < 127) {
      *dst++ = (char)mutate_glyph(codepoint, col, row, sim_time);
      src++;
      remaining--;
    } else {
      memcpy(dst, src, (size_t)bytes);
      dst += bytes;
      src += bytes;
      remaining -= (size_t)bytes;
    }
    col++;
  }
  // Monochrome input has no trailing SGR reset to copy. The effect introduces
  // colors itself, so every colored result must restore terminal attributes.
  if (colored) {
    const char reset[] = "\033[0m";
    if (remaining < sizeof(reset)) {
      SAFE_FREE(output);
      return NULL;
    }
    memcpy(dst, reset, sizeof(reset));
  } else {
    *dst = '\0';
  }
  rain->first_frame = false;
  return output;
}

References digital_rain::brightness_decay, digital_rain::color_b, color_filter_calculate_rainbow(), digital_rain::color_g, digital_rain::color_r, digital_rain::first_frame, log_error, digital_rain::num_columns, digital_rain::previous_brightness, digital_rain::rainbow_mode, SAFE_FREE, SAFE_MALLOC, digital_rain::time, and utf8_decode().

Referenced by animation_apply().

rainbow_render_ansi_at()

char * rainbow_render_ansi_at	(	const char *	frame,
		float	seconds )

Definition at line 366 of file color_filter.c.

                                                                          {
  if (!ansi_string) {
    return NULL;
  }
 
  // Calculate rainbow color once for this frame
  uint8_t rainbow_r = 0, rainbow_g = 0, rainbow_b = 0;
  color_filter_calculate_rainbow(time_seconds, &rainbow_r, &rainbow_g, &rainbow_b);
 
  // Build the replacement ANSI code string once
  char rainbow_code[VIDEO_RGBA_COLOR_FILTER_RAINBOW_CODE_BUFFER_SIZE];
  snprintf(rainbow_code, sizeof(rainbow_code), "\x1b[38;2;%d;%d;%dm", rainbow_r, rainbow_g, rainbow_b);
  size_t rainbow_code_len = strlen(rainbow_code);
 
  // Check if there are any ANSI codes to replace
  if (!strstr(ansi_string, "\x1b[38;2;")) {
    return NULL; // No ANSI codes found, no replacement needed
  }
 
  size_t input_len = strlen(ansi_string);
  size_t replacements = 0;
  const char *scan = ansi_string;
  while ((scan = strstr(scan, "\x1b[38;2;")) != NULL) {
    const char *end = strchr(scan + 7, 'm');
    if (!end)
      break;
    replacements++;
    scan = end + 1;
  }
  if (input_len == SIZE_MAX || replacements > (SIZE_MAX - input_len - 1) / rainbow_code_len)
    return NULL;
  char *new_result = SAFE_MALLOC(input_len + replacements * rainbow_code_len + 1, char *);
  if (!new_result) {
    return NULL;
  }
 
  // Replace all RGB color codes with rainbow color
  const char *src = ansi_string;
  char *dst = new_result;
 
  while (*src) {
    const char *ansi_start = strstr(src, "\x1b[38;2;");
    if (ansi_start) {
      // Copy everything before this ANSI code
      size_t before_len = (size_t)(ansi_start - src);
      memcpy(dst, src, before_len);
      dst += before_len;
 
      // Skip the old ANSI code (find the 'm' that ends it)
      const char *ansi_end = strchr(ansi_start + 7, 'm');
      if (ansi_end) {
        // Copy the rainbow replacement code
        // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - binary data
        memcpy(dst, rainbow_code, rainbow_code_len);
        dst += rainbow_code_len;
 
        // Move source past the old code
        src = ansi_end + 1;
      } else {
        // Preserve a malformed trailing sequence without duplicating the prefix.
        size_t remaining = strlen(ansi_start);
        memcpy(dst, ansi_start, remaining);
        dst += remaining;
        break;
      }
    } else {
      // No more ANSI codes, copy the rest
      size_t remaining = strlen(src);
      memcpy(dst, src, remaining);
      dst += remaining;
      break;
    }
  }
  *dst = '\0';
 
  return new_result;
}

References color_filter_calculate_rainbow(), SAFE_MALLOC, and VIDEO_RGBA_COLOR_FILTER_RAINBOW_CODE_BUFFER_SIZE.

Referenced by animation_apply().

test_pattern_render_at()

asciichat_error_t test_pattern_render_at	(	struct test_pattern *	pattern,
		int	index,
		double	time_ms,
		bool	cadence )

Definition at line 160 of file video/anim/test_pattern.c.

                                                                                                     {
  if (!p || !p->image || index < 0 || index > 1 || !isfinite(time_ms) || time_ms < 0)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid test pattern frame parameters");
  int w = p->image->w, h = p->image->h;
  double phase = fmod(time_ms, index ? 4000 : 10000) / (index ? 4000 : 10000);
  rgb_pixel_t dark = {16, 24, 32}, white = {255, 255, 255};
  rgb_pixel_t first = hue(phase * 360, 0.5), last = hue(fmod(phase + 0.5, 1) * 360, 0.5);
  double box = fmin(fmax(32, fmin(w, h) / 4.0), fmin(w, h) / 2.0);
  double bx = fmod(time_ms / 11, w + box) - box, by = fmod(time_ms / 17, h + box) - box;
  double stripe = w / 12.0, offset = phase * w;
  int first_stripe = (int)ceil(-offset / stripe);
  double radius = fmin(fmax(12, fmin(w, h) / 8.0), fmin(w, h) / 4.0);
  double cx = w + radius - phase * (w + radius * 2), cy = h / 2.0 + sin(phase * 12.566370614359172) * h / 4.0;
  rgb_pixel_t colors[12];
  for (int i = 0; i < 12; i++)
    colors[i] = hue(i * 30, 0.55);
  uint32_t frame = (uint32_t)fmod(floor(time_ms / (1000.0 / 60)), 512);
  uint32_t code = frame ^ (frame >> 1);
  const int slots[8] = {6, 4, 2, 0, 1, 3, 5, 7};
  rgb_pixel_t *pixels = p->image->pixels;
  if (index == 1) {
    // The background is constant down each column. Rasterize one row, then copy.
    for (int x = 0; x < w; x++) {
      rgb_pixel_t pixel = dark;
      if (cadence) {
        int slot = (int)(x / fmax(2, w / 8.0));
        if (slot < 8)
          pixel = (code & (1u << slots[slot])) ? white : (rgb_pixel_t){0, 0, 0};
      } else {
        int k = (int)floor((x - offset) / stripe) + 1;
        for (int j = k; j <= k + 1; j++)
          if (j >= first_stripe && j <= first_stripe + 12)
            blend(&pixel, colors[(j % 12 + 12) % 12], overlap(x, j * stripe + offset - stripe, j * stripe + offset));
      }
      pixels[x] = pixel;
    }
    for (int y = 1; y < h; y++)
      memcpy(pixels + (size_t)y * w, pixels, (size_t)w * sizeof(*pixels));
    if (cadence)
      return ASCIICHAT_OK;
    int top = (int)fmax(0, floor(cy - radius - 1)), bottom = (int)fmin(h, ceil(cy + radius + 1));
    int left = (int)fmax(0, floor(cx - radius - 1)), right = (int)fmin(w, ceil(cx + radius + 1));
    for (int y = top; y < bottom; y++)
      for (int x = left; x < right; x++) {
        double dx0 = x + 0.5 - cx, dy0 = y + 0.5 - cy, d2 = dx0 * dx0 + dy0 * dy0;
        if (d2 > (radius + 0.75) * (radius + 0.75))
          continue;
        double coverage = 1;
        if (d2 > (radius - 0.75) * (radius - 0.75)) {
          int inside = 0;
          for (int sy = 0; sy < 4; sy++)
            for (int sx = 0; sx < 4; sx++) {
              double dx = x + (sx + 0.5) / 4 - cx, dy = y + (sy + 0.5) / 4 - cy;
              if (dx * dx + dy * dy < radius * radius)
                inside++;
            }
          coverage = inside / 16.0;
        }
        blend(&pixels[(size_t)y * w + x], white, coverage);
      }
  } else {
    // A fixed-point ramp avoids three floating-point conversions per source
    // pixel. 4096 intervals keep rounding within one RGB level of Canvas.
    rgb_pixel_t gradient[TEST_PATTERN_GRADIENT_INTERVALS + 1];
    for (int i = 0; i <= TEST_PATTERN_GRADIENT_INTERVALS; i++) {
      double t = i / (double)TEST_PATTERN_GRADIENT_INTERVALS;
      gradient[i] = (rgb_pixel_t){(uint8_t)(first.r * (1 - t) + last.r * t + 0.5),
                                  (uint8_t)(first.g * (1 - t) + last.g * t + 0.5),
                                  (uint8_t)(first.b * (1 - t) + last.b * t + 0.5)};
    }
    double scale = (double)TEST_PATTERN_GRADIENT_INTERVALS * 65536 / ((double)w * w + (double)h * h);
    uint32_t step = (uint32_t)(w * scale + 0.5);
    for (int y = 0; y < h; y++) {
      uint32_t position = (uint32_t)((0.5 * w + (y + 0.5) * h) * scale + 0.5);
      for (int x = 0; x < w; x++, position += step)
        pixels[(size_t)y * w + x] = gradient[position >> 16];
    }
    int top = (int)fmax(0, floor(by)), bottom = (int)fmin(h, ceil(by + box));
    int left = (int)fmax(0, floor(bx)), right = (int)fmin(w, ceil(bx + box));
    for (int y = top; y < bottom; y++)
      for (int x = left; x < right; x++)
        blend(&pixels[(size_t)y * w + x], white, 0.8 * overlap(x, bx, bx + box) * overlap(y, by, by + box));
  }
  render_test_label(p->image);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, rgb_pixel_t::b, colors, ERROR_INVALID_PARAM, rgb_pixel_t::g, image_t::h, test_pattern::image, index, image_t::pixels, rgb_pixel_t::r, SET_ERRNO, TEST_PATTERN_GRADIENT_INTERVALS, and image_t::w.

Referenced by animation_apply().