test_pattern.c File Reference

Go to the source code of this file.

Data Structures
struct	test_pattern
	test pattern is intentionally a small, concrete record. Fields such as image, rgba give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. More...

Macros
#define	TEST_PATTERN_GRADIENT_INTERVALS   4096

Functions
asciichat_error_t	test_pattern_resize (test_pattern_t *p, int width, int height)
asciichat_error_t	test_pattern_create (int width, int height, test_pattern_t **out)
void	test_pattern_destroy (test_pattern_t *p)
image_t *	test_pattern_image (test_pattern_t *p)
const uint8_t *	test_pattern_rgba (test_pattern_t *p)
asciichat_error_t	test_pattern_render (test_pattern_t *p, int index, double time_ms, bool cadence)
asciichat_error_t	test_pattern_render_at (test_pattern_t *p, int index, double time_ms, bool cadence)

Macro Definition Documentation

TEST_PATTERN_GRADIENT_INTERVALS

#define TEST_PATTERN_GRADIENT_INTERVALS   4096

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

Referenced by test_pattern_render_at().

Function Documentation

test_pattern_create()

asciichat_error_t test_pattern_create	(	int	width,
		int	height,
		test_pattern_t **	out )

Independent, reusable RGB renderer. Time is elapsed milliseconds, not frame count.

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

                                                                                   {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing test pattern output");
  *out = NULL;
  test_pattern_t *p = SAFE_CALLOC(1, sizeof(*p), test_pattern_t *);
  asciichat_error_t result = test_pattern_resize(p, width, height);
  if (result != ASCIICHAT_OK) {
    test_pattern_destroy(p);
    return result;
  }
  *out = p;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, height, out, SAFE_CALLOC, SET_ERRNO, test_pattern_destroy(), test_pattern_resize(), and width.

Referenced by TestPatternBinding::TestPatternBinding().

test_pattern_destroy()

void test_pattern_destroy

(

test_pattern_t *

p

)

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

                                             {
  if (!p)
    return;
  if (p->image)
    image_destroy(p->image);
  SAFE_FREE(p->rgba);
  SAFE_FREE(p);
}

References test_pattern::image, image_destroy(), test_pattern::rgba, and SAFE_FREE.

Referenced by media_source_destroy(), test_pattern_create(), and TestPatternBinding::~TestPatternBinding().

test_pattern_image()

image_t * test_pattern_image

(

test_pattern_t *

p

)

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

                                               {
  return p ? p->image : NULL;
}

References test_pattern::image.

test_pattern_render()

asciichat_error_t test_pattern_render	(	test_pattern_t *	p,
		int	index,
		double	time_ms,
		bool	cadence )

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

                                                                                                  {
  animation_sample_t sample;
  animation_config_t config = {.type = ANIMATION_TEST_PATTERN, .fps = 60, .speed = 1};
  asciichat_error_t err = animation_sample_at(config, time_ms / 1000.0, &sample);
  if (err != ASCIICHAT_OK)
    return err;
  animation_target_t target = {.type = ANIMATION_TARGET_TEST_PATTERN,
                               .test_pattern = {.context = p, .index = index, .cadence = cadence}};
  return animation_apply(&sample, &target);
}

References animation_apply(), animation_sample_at(), ANIMATION_TARGET_TEST_PATTERN, ANIMATION_TEST_PATTERN, ASCIICHAT_OK, and index.

Referenced by TestPatternBinding::render().

test_pattern_render_at()

asciichat_error_t test_pattern_render_at	(	test_pattern_t *	p,
		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().

test_pattern_resize()

asciichat_error_t test_pattern_resize	(	test_pattern_t *	p,
		int	width,
		int	height )

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

                                                                                {
  if (!p || width < 1 || height < 1)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid test pattern dimensions");
  if (p->image && p->image->w == width && p->image->h == height)
    return ASCIICHAT_OK;
  image_t *next = image_new(width, height);
  if (!next)
    return SET_ERRNO(ERROR_MEMORY, "Test pattern image allocation failed");
  if (p->image)
    image_destroy(p->image);
  p->image = next;
  SAFE_FREE(p->rgba);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_MEMORY, image_t::h, height, test_pattern::image, image_destroy(), image_new(), test_pattern::rgba, SAFE_FREE, SET_ERRNO, image_t::w, and width.

Referenced by TestPatternBinding::render(), and test_pattern_create().

test_pattern_rgba()

const uint8_t * test_pattern_rgba

(

test_pattern_t *

pattern

)

Reusable RGBA view for browser upload; invalidated by resize/destroy.

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

                                                    {
  if (!p || !p->image)
    return NULL;
  size_t count = (size_t)p->image->w * p->image->h;
  if (!p->rgba)
    p->rgba = SAFE_MALLOC(count * 4, uint8_t *);
  for (size_t i = 0; i < count; i++) {
    p->rgba[i * 4] = p->image->pixels[i].r;
    p->rgba[i * 4 + 1] = p->image->pixels[i].g;
    p->rgba[i * 4 + 2] = p->image->pixels[i].b;
    p->rgba[i * 4 + 3] = 255;
  }
  return p->rgba;
}

References rgb_pixel_t::b, rgb_pixel_t::g, image_t::h, test_pattern::image, image_t::pixels, rgb_pixel_t::r, test_pattern::rgba, SAFE_MALLOC, and image_t::w.

Referenced by TestPatternBinding::render().